Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <tools/string.hxx>
21 :
22 : #include <svx/dialogs.hrc>
23 : #include "svx/rulritem.hxx"
24 : #include <com/sun/star/awt/Rectangle.hpp>
25 : #include <com/sun/star/frame/status/LeftRightMargin.hpp>
26 : #include <com/sun/star/frame/status/UpperLowerMargin.hpp>
27 :
28 : //------------------------------------------------------------------------
29 :
30 512 : TYPEINIT1_AUTOFACTORY(SvxPagePosSizeItem, SfxPoolItem);
31 472 : TYPEINIT1_AUTOFACTORY(SvxLongLRSpaceItem, SfxPoolItem);
32 472 : TYPEINIT1_AUTOFACTORY(SvxLongULSpaceItem, SfxPoolItem);
33 92 : TYPEINIT1(SvxColumnItem, SfxPoolItem);
34 3 : TYPEINIT1(SvxObjectItem, SfxPoolItem);
35 :
36 : //------------------------------------------------------------------------
37 :
38 3 : int SvxLongLRSpaceItem::operator==( const SfxPoolItem& rCmp) const
39 : {
40 3 : return SfxPoolItem::operator==(rCmp) &&
41 : lLeft==((const SvxLongLRSpaceItem &)rCmp).lLeft &&
42 3 : lRight==((const SvxLongLRSpaceItem &)rCmp).lRight;
43 : }
44 :
45 :
46 : //------------------------------------------------------------------------
47 :
48 0 : String SvxLongLRSpaceItem::GetValueText() const
49 : {
50 0 : return String();
51 : }
52 :
53 : #define TWIP_TO_MM100(TWIP) ((TWIP) >= 0 ? (((TWIP)*127L+36L)/72L) : (((TWIP)*127L-36L)/72L))
54 : #define MM100_TO_TWIP(MM100) ((MM100) >= 0 ? (((MM100)*72L+63L)/127L) : (((MM100)*72L-63L)/127L))
55 :
56 0 : bool SvxLongLRSpaceItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
57 : {
58 0 : sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
59 0 : nMemberId &= ~CONVERT_TWIPS;
60 :
61 : sal_Int32 nVal;
62 0 : switch( nMemberId )
63 : {
64 : case 0:
65 : {
66 0 : ::com::sun::star::frame::status::LeftRightMargin aLeftRightMargin;
67 0 : aLeftRightMargin.Left = bConvert ? TWIP_TO_MM100( lLeft ) : lLeft;
68 0 : aLeftRightMargin.Right = bConvert ? TWIP_TO_MM100( lRight ) : lRight;
69 0 : rVal <<= aLeftRightMargin;
70 0 : return sal_True;
71 : }
72 :
73 0 : case MID_LEFT: nVal = lLeft; break;
74 0 : case MID_RIGHT: nVal = lRight; break;
75 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
76 : }
77 :
78 0 : if ( bConvert )
79 0 : nVal = TWIP_TO_MM100( nVal );
80 :
81 0 : rVal <<= nVal;
82 0 : return true;
83 : }
84 :
85 : // -----------------------------------------------------------------------
86 0 : bool SvxLongLRSpaceItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
87 : {
88 0 : sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
89 0 : nMemberId &= ~CONVERT_TWIPS;
90 :
91 0 : sal_Int32 nVal = 0;
92 0 : if ( nMemberId == 0 )
93 : {
94 0 : ::com::sun::star::frame::status::LeftRightMargin aLeftRightMargin;
95 0 : if ( rVal >>= aLeftRightMargin )
96 : {
97 0 : lLeft = bConvert ? MM100_TO_TWIP( aLeftRightMargin.Left ) : aLeftRightMargin.Left;
98 0 : lRight = bConvert ? MM100_TO_TWIP( aLeftRightMargin.Right ) : aLeftRightMargin.Right;
99 0 : return true;
100 : }
101 : }
102 0 : else if ( rVal >>= nVal )
103 : {
104 0 : if ( bConvert )
105 0 : nVal = MM100_TO_TWIP( nVal );
106 :
107 0 : switch( nMemberId )
108 : {
109 0 : case MID_LEFT: lLeft = nVal; break;
110 0 : case MID_RIGHT: lRight = nVal; break;
111 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
112 : }
113 :
114 0 : return true;
115 : }
116 :
117 0 : return false;
118 : }
119 :
120 : //------------------------------------------------------------------------
121 :
122 0 : SfxItemPresentation SvxLongLRSpaceItem::GetPresentation
123 : (
124 : SfxItemPresentation /*ePres*/,
125 : SfxMapUnit /*eCoreUnit*/,
126 : SfxMapUnit /*ePresUnit*/,
127 : String& /*rText*/, const IntlWrapper *
128 : ) const
129 : {
130 :
131 0 : return SFX_ITEM_PRESENTATION_NONE;
132 : }
133 :
134 : //------------------------------------------------------------------------
135 :
136 306 : SfxPoolItem* SvxLongLRSpaceItem::Clone(SfxItemPool *) const
137 : {
138 306 : return new SvxLongLRSpaceItem(*this);
139 : }
140 :
141 : //------------------------------------------------------------------------
142 :
143 104 : SvxLongLRSpaceItem::SvxLongLRSpaceItem(long lL, long lR, sal_uInt16 nId)
144 : : SfxPoolItem(nId),
145 : lLeft(lL),
146 104 : lRight(lR)
147 104 : {}
148 :
149 : //------------------------------------------------------------------------
150 :
151 0 : SvxLongLRSpaceItem::SvxLongLRSpaceItem() :
152 : SfxPoolItem( 0 ),
153 : lLeft( 0 ),
154 0 : lRight( 0 )
155 0 : {}
156 :
157 : //------------------------------------------------------------------------
158 :
159 316 : SvxLongLRSpaceItem::SvxLongLRSpaceItem(const SvxLongLRSpaceItem &rCpy)
160 : : SfxPoolItem(rCpy),
161 : lLeft(rCpy.lLeft),
162 316 : lRight(rCpy.lRight)
163 316 : {}
164 :
165 : //------------------------------------------------------------------------
166 :
167 3 : int SvxLongULSpaceItem::operator==( const SfxPoolItem& rCmp) const
168 : {
169 3 : return SfxPoolItem::operator==(rCmp) &&
170 : lLeft==((const SvxLongULSpaceItem &)rCmp).lLeft &&
171 3 : lRight==((const SvxLongULSpaceItem &)rCmp).lRight;
172 : }
173 :
174 :
175 : //------------------------------------------------------------------------
176 :
177 0 : String SvxLongULSpaceItem::GetValueText() const
178 : {
179 0 : return String();
180 : }
181 :
182 0 : bool SvxLongULSpaceItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
183 : {
184 0 : sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
185 0 : nMemberId &= ~CONVERT_TWIPS;
186 :
187 : sal_Int32 nVal;
188 0 : switch( nMemberId )
189 : {
190 : case 0:
191 : {
192 0 : ::com::sun::star::frame::status::UpperLowerMargin aUpperLowerMargin;
193 0 : aUpperLowerMargin.Upper = bConvert ? TWIP_TO_MM100( lLeft ) : lLeft;
194 0 : aUpperLowerMargin.Lower = bConvert ? TWIP_TO_MM100( lRight ) : lRight;
195 0 : rVal <<= aUpperLowerMargin;
196 0 : return true;
197 : }
198 :
199 0 : case MID_UPPER: nVal = lLeft; break;
200 0 : case MID_LOWER: nVal = lRight; break;
201 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
202 : }
203 :
204 0 : if ( bConvert )
205 0 : nVal = TWIP_TO_MM100( nVal );
206 :
207 0 : rVal <<= nVal;
208 0 : return true;
209 : }
210 :
211 : // -----------------------------------------------------------------------
212 0 : bool SvxLongULSpaceItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
213 : {
214 0 : sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
215 0 : nMemberId &= ~CONVERT_TWIPS;
216 :
217 0 : sal_Int32 nVal = 0;
218 0 : if ( nMemberId == 0 )
219 : {
220 0 : ::com::sun::star::frame::status::UpperLowerMargin aUpperLowerMargin;
221 0 : if ( rVal >>= aUpperLowerMargin )
222 : {
223 0 : lLeft = bConvert ? MM100_TO_TWIP( aUpperLowerMargin.Upper ) : aUpperLowerMargin.Upper;
224 0 : lRight = bConvert ? MM100_TO_TWIP( aUpperLowerMargin.Lower ) : aUpperLowerMargin.Lower;
225 0 : return true;
226 : }
227 : }
228 0 : else if ( rVal >>= nVal )
229 : {
230 0 : if ( bConvert )
231 0 : nVal = MM100_TO_TWIP( nVal );
232 :
233 0 : switch( nMemberId )
234 : {
235 0 : case MID_UPPER: lLeft = nVal; break;
236 0 : case MID_LOWER: lRight = nVal; break;
237 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
238 : }
239 :
240 0 : return true;
241 : }
242 :
243 0 : return false;
244 : }
245 :
246 : //------------------------------------------------------------------------
247 :
248 0 : SfxItemPresentation SvxLongULSpaceItem::GetPresentation
249 : (
250 : SfxItemPresentation /*ePres*/,
251 : SfxMapUnit /*eCoreUnit*/,
252 : SfxMapUnit /*ePresUnit*/,
253 : String& /*rText*/, const IntlWrapper *
254 : ) const
255 : {
256 0 : return SFX_ITEM_PRESENTATION_NONE;
257 : }
258 :
259 : //------------------------------------------------------------------------
260 :
261 306 : SfxPoolItem* SvxLongULSpaceItem::Clone(SfxItemPool *) const
262 : {
263 306 : return new SvxLongULSpaceItem(*this);
264 : }
265 :
266 : //------------------------------------------------------------------------
267 :
268 104 : SvxLongULSpaceItem::SvxLongULSpaceItem(long lL, long lR, sal_uInt16 nId)
269 : : SfxPoolItem(nId),
270 : lLeft(lL),
271 104 : lRight(lR)
272 104 : {}
273 :
274 : //------------------------------------------------------------------------
275 :
276 316 : SvxLongULSpaceItem::SvxLongULSpaceItem(const SvxLongULSpaceItem &rCpy)
277 : : SfxPoolItem(rCpy),
278 : lLeft(rCpy.lLeft),
279 316 : lRight(rCpy.lRight)
280 316 : {}
281 :
282 : //------------------------------------------------------------------------
283 :
284 0 : SvxLongULSpaceItem::SvxLongULSpaceItem() :
285 : SfxPoolItem( 0 ),
286 : lLeft( 0 ),
287 0 : lRight( 0 )
288 0 : {}
289 :
290 : //------------------------------------------------------------------------
291 :
292 3 : int SvxPagePosSizeItem::operator==( const SfxPoolItem& rCmp) const
293 : {
294 3 : return SfxPoolItem::operator==(rCmp) &&
295 3 : aPos == ((const SvxPagePosSizeItem &)rCmp).aPos &&
296 : lWidth == ((const SvxPagePosSizeItem &)rCmp).lWidth &&
297 6 : lHeight == ((const SvxPagePosSizeItem &)rCmp).lHeight;
298 : }
299 :
300 0 : bool SvxPagePosSizeItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
301 : {
302 0 : nMemberId &= ~CONVERT_TWIPS;
303 :
304 : sal_Int32 nVal;
305 0 : switch ( nMemberId )
306 : {
307 : case 0 :
308 : {
309 0 : com::sun::star::awt::Rectangle aPagePosSize;
310 0 : aPagePosSize.X = aPos.X();
311 0 : aPagePosSize.Y = aPos.Y();
312 0 : aPagePosSize.Width = lWidth;
313 0 : aPagePosSize.Height = lHeight;
314 0 : rVal <<= aPagePosSize;
315 0 : return true;
316 : }
317 :
318 0 : case MID_X: nVal = aPos.X(); break;
319 0 : case MID_Y: nVal = aPos.Y(); break;
320 0 : case MID_WIDTH: nVal = lWidth; break;
321 0 : case MID_HEIGHT: nVal = lHeight; break;
322 :
323 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
324 : }
325 :
326 0 : rVal <<= nVal;
327 0 : return true;
328 : }
329 :
330 0 : bool SvxPagePosSizeItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
331 : {
332 0 : nMemberId &= ~CONVERT_TWIPS;
333 :
334 0 : sal_Int32 nVal = 0;
335 0 : if ( nMemberId == 0 )
336 : {
337 0 : com::sun::star::awt::Rectangle aPagePosSize;
338 0 : if ( rVal >>= aPagePosSize )
339 : {
340 0 : aPos.X() = aPagePosSize.X;
341 0 : aPos.Y() = aPagePosSize.Y;
342 0 : lWidth = aPagePosSize.Width;
343 0 : lHeight = aPagePosSize.Height;
344 0 : return sal_True;
345 : }
346 : else
347 0 : return sal_False;
348 : }
349 0 : else if ( rVal >>= nVal )
350 : {
351 0 : switch ( nMemberId )
352 : {
353 0 : case MID_X: aPos.X() = nVal; break;
354 0 : case MID_Y: aPos.Y() = nVal; break;
355 0 : case MID_WIDTH: lWidth = nVal; break;
356 0 : case MID_HEIGHT: lHeight = nVal; break;
357 :
358 0 : default: OSL_FAIL("Wrong MemberId!"); return sal_False;
359 : }
360 :
361 0 : return true;
362 : }
363 :
364 0 : return false;
365 : }
366 :
367 : //------------------------------------------------------------------------
368 :
369 0 : String SvxPagePosSizeItem::GetValueText() const
370 : {
371 0 : return String();
372 : }
373 :
374 : //------------------------------------------------------------------------
375 :
376 0 : SfxItemPresentation SvxPagePosSizeItem::GetPresentation
377 : (
378 : SfxItemPresentation /*ePres*/,
379 : SfxMapUnit /*eCoreUnit*/,
380 : SfxMapUnit /*ePresUnit*/,
381 : String& /*rText*/, const IntlWrapper *
382 : ) const
383 : {
384 0 : return SFX_ITEM_PRESENTATION_NONE;
385 : }
386 :
387 : //------------------------------------------------------------------------
388 :
389 306 : SfxPoolItem* SvxPagePosSizeItem::Clone(SfxItemPool *) const
390 : {
391 306 : return new SvxPagePosSizeItem(*this);
392 : }
393 :
394 : //------------------------------------------------------------------------
395 :
396 104 : SvxPagePosSizeItem::SvxPagePosSizeItem(const Point &rP, long lW, long lH)
397 : : SfxPoolItem(SID_RULER_PAGE_POS),
398 : aPos(rP),
399 : lWidth(lW),
400 104 : lHeight(lH)
401 104 : {}
402 :
403 : //------------------------------------------------------------------------
404 :
405 326 : SvxPagePosSizeItem::SvxPagePosSizeItem(const SvxPagePosSizeItem &rCpy)
406 : : SfxPoolItem(rCpy),
407 : aPos(rCpy.aPos),
408 : lWidth(rCpy.lWidth),
409 326 : lHeight(rCpy.lHeight)
410 326 : {}
411 :
412 : //------------------------------------------------------------------------
413 :
414 0 : SvxPagePosSizeItem::SvxPagePosSizeItem()
415 : : SfxPoolItem( 0 ),
416 : aPos( 0, 0 ),
417 : lWidth( 0 ),
418 0 : lHeight( 0 )
419 0 : {}
420 :
421 : //------------------------------------------------------------------------
422 :
423 6 : int SvxColumnItem::operator==(const SfxPoolItem& rCmp) const
424 : {
425 12 : if(!SfxPoolItem::operator==(rCmp) ||
426 : nActColumn != ((const SvxColumnItem&)rCmp).nActColumn ||
427 : nLeft != ((const SvxColumnItem&)rCmp).nLeft ||
428 : nRight != ((const SvxColumnItem&)rCmp).nRight ||
429 : bTable != ((const SvxColumnItem&)rCmp).bTable ||
430 6 : Count() != ((const SvxColumnItem&)rCmp).Count())
431 0 : return sal_False;
432 :
433 6 : const sal_uInt16 nCount = ((const SvxColumnItem&)rCmp).Count();
434 16 : for(sal_uInt16 i = 0; i < nCount;++i) {
435 10 : if( (*this)[i] != ((const SvxColumnItem&)rCmp)[i] )
436 0 : return sal_False;
437 : }
438 6 : return sal_True;
439 : }
440 :
441 : //------------------------------------------------------------------------
442 :
443 0 : String SvxColumnItem::GetValueText() const
444 : {
445 0 : return String();
446 : }
447 :
448 : //------------------------------------------------------------------------
449 :
450 0 : SfxItemPresentation SvxColumnItem::GetPresentation
451 : (
452 : SfxItemPresentation /*ePres*/,
453 : SfxMapUnit /*eCoreUnit*/,
454 : SfxMapUnit /*ePresUnit*/,
455 : String& /*rText*/, const IntlWrapper *
456 : ) const
457 : {
458 0 : return SFX_ITEM_PRESENTATION_NONE;
459 : }
460 :
461 : //------------------------------------------------------------------------
462 :
463 45 : SfxPoolItem* SvxColumnItem::Clone( SfxItemPool * ) const
464 : {
465 45 : return new SvxColumnItem(*this);
466 : }
467 :
468 : //------------------------------------------------------------------------
469 :
470 1 : SvxColumnItem::SvxColumnItem( sal_uInt16 nAct ) :
471 :
472 : SfxPoolItem( SID_RULER_BORDERS ),
473 :
474 : nLeft ( 0 ),
475 : nRight ( 0 ),
476 : nActColumn ( nAct ),
477 : bTable ( sal_False ),
478 1 : bOrtho (sal_True )
479 :
480 : {
481 1 : }
482 :
483 : //------------------------------------------------------------------------
484 :
485 18 : SvxColumnItem::SvxColumnItem( sal_uInt16 nActCol, sal_uInt16 left, sal_uInt16 right ) :
486 :
487 : SfxPoolItem( SID_RULER_BORDERS ),
488 :
489 : nLeft ( left ),
490 : nRight ( right ),
491 : nActColumn ( nActCol ),
492 : bTable ( sal_True ),
493 18 : bOrtho ( sal_True )
494 : {
495 18 : }
496 :
497 45 : SvxColumnItem::SvxColumnItem( const SvxColumnItem& rCopy ) :
498 : SfxPoolItem( rCopy ),
499 : nLeft ( rCopy.nLeft ),
500 : nRight ( rCopy.nRight ),
501 : nActColumn( rCopy.nActColumn ),
502 : bTable ( rCopy.bTable ),
503 45 : bOrtho ( rCopy.bOrtho )
504 : {
505 115 : for(size_t i = 0; i < rCopy.Count(); ++i)
506 70 : aColumns.push_back(rCopy[i]);
507 45 : }
508 :
509 57 : SvxColumnItem::~SvxColumnItem()
510 : {
511 57 : }
512 :
513 0 : const SvxColumnItem &SvxColumnItem::operator=(const SvxColumnItem &rCopy)
514 : {
515 0 : nLeft = rCopy.nLeft;
516 0 : nRight = rCopy.nRight;
517 0 : bTable = rCopy.bTable;
518 0 : nActColumn = rCopy.nActColumn;
519 0 : aColumns.clear();
520 0 : for(size_t i = 0; i < rCopy.Count(); ++i)
521 0 : aColumns.push_back(rCopy[i]);
522 0 : return *this;
523 : }
524 :
525 1 : sal_Bool SvxColumnItem::CalcOrtho() const
526 : {
527 1 : const sal_uInt16 nCount = Count();
528 : DBG_ASSERT(nCount >= 2, "no columns");
529 1 : if(nCount < 2)
530 0 : return sal_False;
531 :
532 1 : long nColWidth = (*this)[0].GetWidth();
533 2 : for(sal_uInt16 i = 1; i < nCount; ++i) {
534 1 : if( (*this)[i].GetWidth() != nColWidth)
535 0 : return sal_False;
536 : }
537 : //!! Wide divider
538 1 : return sal_True;
539 : }
540 :
541 : //------------------------------------------------------------------------
542 :
543 0 : bool SvxColumnItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
544 : {
545 0 : nMemberId &= ~CONVERT_TWIPS;
546 0 : switch ( nMemberId )
547 : {
548 : case MID_COLUMNARRAY:
549 : {
550 0 : return false;
551 : }
552 0 : case MID_RIGHT: rVal <<= nRight; break;
553 0 : case MID_LEFT: rVal <<= nLeft; break;
554 0 : case MID_ORTHO: rVal <<= (sal_Bool) bOrtho; break;
555 0 : case MID_ACTUAL: rVal <<= (sal_Int32) nActColumn; break;
556 0 : case MID_TABLE: rVal <<= (sal_Bool) bTable; break;
557 0 : default: OSL_FAIL("Wrong MemberId!"); return sal_False;
558 : }
559 :
560 0 : return true;
561 : }
562 :
563 0 : bool SvxColumnItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
564 : {
565 0 : nMemberId &= ~CONVERT_TWIPS;
566 0 : sal_Int32 nVal = 0;
567 0 : switch ( nMemberId )
568 : {
569 : case MID_COLUMNARRAY:
570 : {
571 0 : return false;
572 : }
573 0 : case MID_RIGHT: rVal >>= nRight; break;
574 0 : case MID_LEFT: rVal >>= nLeft; break;
575 0 : case MID_ORTHO: rVal >>= nVal; bOrtho = (sal_Bool) nVal; break;
576 0 : case MID_ACTUAL: rVal >>= nVal; nActColumn = (sal_uInt16) nVal; break;
577 0 : case MID_TABLE: rVal >>= nVal; bTable = (sal_Bool) nVal; break;
578 0 : default: OSL_FAIL("Wrong MemberId!"); return sal_False;
579 : }
580 :
581 0 : return true;
582 : }
583 :
584 : //------------------------------------------------------------------------
585 :
586 0 : int SvxObjectItem::operator==( const SfxPoolItem& rCmp ) const
587 : {
588 0 : return SfxPoolItem::operator==(rCmp) &&
589 : nStartX == ((const SvxObjectItem&)rCmp).nStartX &&
590 : nEndX == ((const SvxObjectItem&)rCmp).nEndX &&
591 : nStartY == ((const SvxObjectItem&)rCmp).nStartY &&
592 : nEndY == ((const SvxObjectItem&)rCmp).nEndY &&
593 0 : bLimits == ((const SvxObjectItem&)rCmp).bLimits;
594 : }
595 :
596 : //------------------------------------------------------------------------
597 :
598 0 : String SvxObjectItem::GetValueText() const
599 : {
600 0 : return String();
601 : }
602 :
603 : //------------------------------------------------------------------------
604 :
605 0 : SfxItemPresentation SvxObjectItem::GetPresentation
606 : (
607 : SfxItemPresentation /*ePres*/,
608 : SfxMapUnit /*eCoreUnit*/,
609 : SfxMapUnit /*ePresUnit*/,
610 : String& /*rText*/, const IntlWrapper *
611 : ) const
612 : {
613 0 : return SFX_ITEM_PRESENTATION_NONE;
614 : }
615 :
616 : //------------------------------------------------------------------------
617 :
618 0 : SfxPoolItem* SvxObjectItem::Clone(SfxItemPool *) const
619 : {
620 0 : return new SvxObjectItem(*this);
621 : }
622 :
623 : //------------------------------------------------------------------------
624 :
625 0 : SvxObjectItem::SvxObjectItem( long nSX, long nEX,
626 : long nSY, long nEY, sal_Bool limits ) :
627 :
628 : SfxPoolItem( SID_RULER_OBJECT ),
629 :
630 : nStartX ( nSX ),
631 : nEndX ( nEX ),
632 : nStartY ( nSY ),
633 : nEndY ( nEY ),
634 0 : bLimits ( limits )
635 :
636 : {
637 0 : }
638 :
639 : //------------------------------------------------------------------------
640 :
641 0 : SvxObjectItem::SvxObjectItem( const SvxObjectItem& rCopy ) :
642 :
643 : SfxPoolItem( rCopy ),
644 :
645 : nStartX ( rCopy.nStartX ),
646 : nEndX ( rCopy.nEndX ),
647 : nStartY ( rCopy.nStartY ),
648 : nEndY ( rCopy.nEndY ),
649 0 : bLimits ( rCopy.bLimits )
650 :
651 : {
652 0 : }
653 :
654 0 : bool SvxObjectItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
655 : {
656 0 : nMemberId &= ~CONVERT_TWIPS;
657 0 : switch ( nMemberId )
658 : {
659 0 : case MID_START_X : rVal <<= nStartX; break;
660 0 : case MID_START_Y : rVal <<= nStartY; break;
661 0 : case MID_END_X : rVal <<= nEndX; break;
662 0 : case MID_END_Y : rVal <<= nEndY; break;
663 0 : case MID_LIMIT : rVal <<= bLimits; break;
664 : default:
665 : OSL_FAIL( "Wrong MemberId" );
666 0 : return sal_False;
667 : }
668 :
669 0 : return true;
670 : }
671 :
672 0 : bool SvxObjectItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
673 : {
674 0 : nMemberId &= ~CONVERT_TWIPS;
675 0 : bool bRet = false;
676 0 : switch ( nMemberId )
677 : {
678 0 : case MID_START_X : bRet = (rVal >>= nStartX); break;
679 0 : case MID_START_Y : bRet = (rVal >>= nStartY); break;
680 0 : case MID_END_X : bRet = (rVal >>= nEndX); break;
681 0 : case MID_END_Y : bRet = (rVal >>= nEndY); break;
682 0 : case MID_LIMIT : bRet = (rVal >>= bLimits); break;
683 : default: OSL_FAIL( "Wrong MemberId" );
684 : }
685 :
686 0 : return bRet;
687 : }
688 :
689 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
