xref: /aoo42x/main/cui/source/tabpages/transfrm.cxx (revision 07a3d7f1)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_cui.hxx"
26 
27 // include ---------------------------------------------------------------
28 
29 #include <tools/shl.hxx>
30 #include <sfx2/app.hxx>
31 #include <svx/svdview.hxx>
32 #include <svx/svdobj.hxx>
33 #include <svx/svdpagv.hxx>
34 #include <svx/svdotext.hxx>
35 #include <svx/sderitm.hxx>
36 #include <svx/dialogs.hrc>
37 #include <cuires.hrc>
38 #include "transfrm.hrc"
39 #include <editeng/sizeitem.hxx>
40 
41 #include "transfrm.hxx"
42 #include <dialmgr.hxx>
43 #include "svx/dlgutil.hxx"
44 #include <editeng/svxenum.hxx>
45 #include "svx/anchorid.hxx"
46 #include <sfx2/module.hxx>
47 #include <svl/rectitem.hxx>
48 #include <svl/aeitem.hxx>
49 #include <swpossizetabpage.hxx>
50 
51 // Toleranz fuer WorkingArea
52 #define DIFF 1000
53 
54 // static ----------------------------------------------------------------
55 
56 static sal_uInt16 pPosSizeRanges[] =
57 {
58 	SID_ATTR_TRANSFORM_POS_X,
59 	SID_ATTR_TRANSFORM_POS_Y,
60 	SID_ATTR_TRANSFORM_PROTECT_POS,
61 	SID_ATTR_TRANSFORM_PROTECT_POS,
62 	SID_ATTR_TRANSFORM_INTERN,
63 	SID_ATTR_TRANSFORM_INTERN,
64 	SID_ATTR_TRANSFORM_ANCHOR,
65 	SID_ATTR_TRANSFORM_VERT_ORIENT,
66 	SID_ATTR_TRANSFORM_WIDTH,
67 	SID_ATTR_TRANSFORM_SIZE_POINT,
68 	SID_ATTR_TRANSFORM_PROTECT_POS,
69 	SID_ATTR_TRANSFORM_INTERN,
70 	SID_ATTR_TRANSFORM_AUTOWIDTH,
71 	SID_ATTR_TRANSFORM_AUTOHEIGHT,
72 	0
73 };
74 
75 static sal_uInt16 pAngleRanges[] =
76 {
77 	SID_ATTR_TRANSFORM_ROT_X,
78 	SID_ATTR_TRANSFORM_ANGLE,
79 	SID_ATTR_TRANSFORM_INTERN,
80 	SID_ATTR_TRANSFORM_INTERN,
81 	0
82 };
83 
84 static sal_uInt16 pSlantRanges[] =
85 {
86 	SDRATTR_ECKENRADIUS,
87 	SDRATTR_ECKENRADIUS,
88 	SID_ATTR_TRANSFORM_SHEAR,
89 	SID_ATTR_TRANSFORM_SHEAR_VERTICAL,
90 	SID_ATTR_TRANSFORM_INTERN,
91 	SID_ATTR_TRANSFORM_INTERN,
92 	0
93 };
94 
lcl_ConvertRect(basegfx::B2DRange & rRange,const sal_uInt16 nDigits,const MapUnit ePoolUnit,const FieldUnit eDlgUnit)95 void lcl_ConvertRect(basegfx::B2DRange& rRange, const sal_uInt16 nDigits, const MapUnit ePoolUnit, const FieldUnit eDlgUnit)
96 {
97 	const basegfx::B2DPoint aTopLeft(
98 		(double)MetricField::ConvertValue(basegfx::fround(rRange.getMinX()), nDigits, ePoolUnit, eDlgUnit),
99 		(double)MetricField::ConvertValue(basegfx::fround(rRange.getMinY()), nDigits, ePoolUnit, eDlgUnit));
100 	const basegfx::B2DPoint aBottomRight(
101 		(double)MetricField::ConvertValue(basegfx::fround(rRange.getMaxX()), nDigits, ePoolUnit, eDlgUnit),
102 		(double)MetricField::ConvertValue(basegfx::fround(rRange.getMaxY()), nDigits, ePoolUnit, eDlgUnit));
103 
104 	rRange = basegfx::B2DRange(aTopLeft, aBottomRight);
105 }
106 
lcl_ScaleRect(basegfx::B2DRange & rRange,const Fraction aUIScale)107 void lcl_ScaleRect(basegfx::B2DRange& rRange, const Fraction aUIScale)
108 {
109 	const double fFactor(1.0 / double(aUIScale));
110 	rRange = basegfx::B2DRange(rRange.getMinimum() * fFactor, rRange.getMaximum() * fFactor);
111 }
112 
113 /*************************************************************************
114 |*
115 |* Konstruktor des Tab-Dialogs: Fuegt die Seiten zum Dialog hinzu
116 |*
117 \************************************************************************/
118 
SvxTransformTabDialog(Window * pParent,const SfxItemSet * pAttr,const SdrView * pSdrView,sal_uInt16 nAnchorTypes)119 SvxTransformTabDialog::SvxTransformTabDialog( Window* pParent, const SfxItemSet* pAttr,
120 								const SdrView* pSdrView, sal_uInt16 nAnchorTypes ) :
121 	SfxTabDialog( pParent, CUI_RES( RID_SVXDLG_TRANSFORM ), pAttr ),
122 	pView       ( pSdrView ),
123 	nAnchorCtrls(nAnchorTypes)
124 {
125 	DBG_ASSERT(pView, "no valid view (!)");
126 	FreeResource();
127 
128     //different positioning page in Writer
129     if(nAnchorCtrls & 0x00ff)
130     {
131         AddTabPage(RID_SVXPAGE_SWPOSSIZE, SvxSwPosSizeTabPage::Create, SvxSwPosSizeTabPage::GetRanges);
132         RemoveTabPage(RID_SVXPAGE_POSITION_SIZE);
133     }
134     else
135     {
136         AddTabPage(RID_SVXPAGE_POSITION_SIZE, SvxPositionSizeTabPage::Create, SvxPositionSizeTabPage::GetRanges);
137         RemoveTabPage(RID_SVXPAGE_SWPOSSIZE);
138     }
139 
140 	AddTabPage(RID_SVXPAGE_ANGLE, SvxAngleTabPage::Create, SvxAngleTabPage::GetRanges);
141 	AddTabPage(RID_SVXPAGE_SLANT, SvxSlantTabPage::Create, SvxSlantTabPage::GetRanges);
142 }
143 
144 // -----------------------------------------------------------------------
145 
~SvxTransformTabDialog()146 SvxTransformTabDialog::~SvxTransformTabDialog()
147 {
148 }
149 
150 // -----------------------------------------------------------------------
151 
PageCreated(sal_uInt16 nId,SfxTabPage & rPage)152 void SvxTransformTabDialog::PageCreated(sal_uInt16 nId, SfxTabPage &rPage)
153 {
154 	switch(nId)
155 	{
156 		case RID_SVXPAGE_POSITION_SIZE:
157 		{
158             SvxPositionSizeTabPage& rSvxPos =  static_cast<SvxPositionSizeTabPage&>(rPage);
159 			rSvxPos.SetView(pView);
160 			rSvxPos.Construct();
161 
162 			if(nAnchorCtrls & SVX_OBJ_NORESIZE)
163 			{
164 				rSvxPos.DisableResize();
165 			}
166 
167 			if(nAnchorCtrls & SVX_OBJ_NOPROTECT)
168 			{
169 				rSvxPos.DisableProtect();
170 				rSvxPos.UpdateControlStates();
171 			}
172 
173 			break;
174 		}
175         case RID_SVXPAGE_SWPOSSIZE :
176         {
177             SvxSwPosSizeTabPage& rSwPos =  static_cast<SvxSwPosSizeTabPage&>(rPage);
178 
179 			rSwPos.EnableAnchorTypes(nAnchorCtrls);
180             rSwPos.SetValidateFramePosLink(aValidateLink);
181             rSwPos.SetView(pView);
182 
183 			break;
184         }
185 
186 		case RID_SVXPAGE_ANGLE:
187 		{
188             SvxAngleTabPage& rSvxAng =  static_cast<SvxAngleTabPage&>(rPage);
189 
190 			rSvxAng.SetView( pView );
191 			rSvxAng.Construct();
192 
193 			break;
194 		}
195 
196 		case RID_SVXPAGE_SLANT:
197 		{
198             SvxSlantTabPage& rSvxSlnt =  static_cast<SvxSlantTabPage&>(rPage);
199 
200 			rSvxSlnt.SetView( pView );
201 			rSvxSlnt.Construct();
202 
203 			break;
204 		}
205 	}
206 }
207 
208 // -----------------------------------------------------------------------
209 
SetValidateFramePosLink(const Link & rLink)210 void SvxTransformTabDialog::SetValidateFramePosLink(const Link& rLink)
211 {
212     aValidateLink = rLink;
213 }
214 
215 /*************************************************************************
216 |*
217 |*      Dialog zum Aendern der Position des Drehwinkels und des Drehwinkels
218 |*      der Grafikobjekte
219 |*
220 \************************************************************************/
221 
SvxAngleTabPage(Window * pParent,const SfxItemSet & rInAttrs)222 SvxAngleTabPage::SvxAngleTabPage( Window* pParent, const SfxItemSet& rInAttrs  ) :
223 	SvxTabPage              ( pParent, CUI_RES( RID_SVXPAGE_ANGLE ), rInAttrs ),
224 	aFlPosition				( this, CUI_RES( FL_POSITION ) ),
225 	aFtPosX                 ( this, CUI_RES( FT_POS_X ) ),
226 	aMtrPosX                ( this, CUI_RES( MTR_FLD_POS_X ) ),
227 	aFtPosY                 ( this, CUI_RES( FT_POS_Y ) ),
228 	aMtrPosY                ( this, CUI_RES( MTR_FLD_POS_Y ) ),
229 	aFtPosPresets			( this, CUI_RES(FT_POSPRESETS) ),
230 	aCtlRect                ( this, CUI_RES( CTL_RECT ) ),
231 
232 	aFlAngle                ( this, CUI_RES( FL_ANGLE ) ),
233 	aFtAngle                ( this, CUI_RES( FT_ANGLE ) ),
234 	aMtrAngle               ( this, CUI_RES( MTR_FLD_ANGLE ) ),
235 	aFtAnglePresets			( this, CUI_RES(FT_ANGLEPRESETS) ),
236 	aCtlAngle               ( this, CUI_RES( CTL_ANGLE ),
237 								RP_RB, 200, 80, CS_ANGLE ),
238 	rOutAttrs               ( rInAttrs )
239 {
240 	FreeResource();
241 
242 	// calculate PoolUnit
243 	SfxItemPool* pPool = rOutAttrs.GetPool();
244 	DBG_ASSERT( pPool, "no pool (!)" );
245 	ePoolUnit = pPool->GetMetric(SID_ATTR_TRANSFORM_POS_X);
246 
247 	aMtrAngle.SetModifyHdl(LINK( this, SvxAngleTabPage, ModifiedHdl));
248 
249 	aCtlRect.SetAccessibleRelationLabeledBy(&aFtPosPresets);
250 	aCtlRect.SetAccessibleRelationMemberOf(&aFlPosition);
251 	aCtlAngle.SetAccessibleRelationLabeledBy(&aFtAnglePresets);
252 	aCtlAngle.SetAccessibleRelationMemberOf(&aFlAngle);
253 }
254 
255 // -----------------------------------------------------------------------
256 
Construct()257 void SvxAngleTabPage::Construct()
258 {
259 	DBG_ASSERT(pView, "No valid view (!)");
260 	eDlgUnit = GetModuleFieldUnit(GetItemSet());
261 	SetFieldUnit(aMtrPosX, eDlgUnit, sal_True);
262 	SetFieldUnit(aMtrPosY, eDlgUnit, sal_True);
263 
264 	if(FUNIT_MILE == eDlgUnit || FUNIT_KM == eDlgUnit)
265 	{
266 		aMtrPosX.SetDecimalDigits( 3 );
267 		aMtrPosY.SetDecimalDigits( 3 );
268 	}
269 
270 	{ // #i75273#
271 		Rectangle aTempRect(pView->GetAllMarkedRect());
272 		pView->GetSdrPageView()->LogicToPagePos(aTempRect);
273 		maRange = basegfx::B2DRange(aTempRect.Left(), aTempRect.Top(), aTempRect.Right(), aTempRect.Bottom());
274 	}
275 
276 	// Take anchor into account (Writer)
277 	const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
278 
279 	if(rMarkList.GetMarkCount())
280 	{
281 		const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
282 		maAnchor = basegfx::B2DPoint(pObj->GetAnchorPos().X(), pObj->GetAnchorPos().Y());
283 
284 		if(!maAnchor.equalZero()) // -> Writer
285 		{
286 			maRange = basegfx::B2DRange(maRange.getMinimum() - maAnchor, maRange.getMaximum() - maAnchor);
287 		}
288 	}
289 
290 	// take scale into account
291 	const Fraction aUIScale(pView->GetModel()->GetUIScale());
292 	lcl_ScaleRect(maRange, aUIScale);
293 
294 	// take UI units into account
295 	sal_uInt16 nDigits(aMtrPosX.GetDecimalDigits());
296 	lcl_ConvertRect(maRange, nDigits, (MapUnit)ePoolUnit, eDlgUnit);
297 
298 	if(!pView->IsRotateAllowed())
299 	{
300 		aFlPosition.Disable();
301 		aFtPosX.Disable();
302 		aMtrPosX.Disable();
303 		aFtPosY.Disable();
304 		aMtrPosY.Disable();
305 		aFtPosPresets.Disable();
306 		aCtlRect.Disable();
307 		aFlAngle.Disable();
308 		aFtAngle.Disable();
309 		aMtrAngle.Disable();
310 		aFtAnglePresets.Disable();
311 		aCtlAngle.Disable();
312 	}
313 }
314 
315 // -----------------------------------------------------------------------
316 
FillItemSet(SfxItemSet & rSet)317 sal_Bool SvxAngleTabPage::FillItemSet(SfxItemSet& rSet)
318 {
319 	sal_Bool bModified = sal_False;
320 
321 	if(aMtrAngle.IsValueModified() || aMtrPosX.IsValueModified() || aMtrPosY.IsValueModified())
322 	{
323 		const double fUIScale(double(pView->GetModel()->GetUIScale()));
324 		const double fTmpX((GetCoreValue(aMtrPosX, ePoolUnit) + maAnchor.getX()) * fUIScale);
325 		const double fTmpY((GetCoreValue(aMtrPosY, ePoolUnit) + maAnchor.getY()) * fUIScale);
326 
327 		rSet.Put(SfxInt32Item(GetWhich(SID_ATTR_TRANSFORM_ANGLE), static_cast<sal_Int32>(aMtrAngle.GetValue())));
328 		rSet.Put(SfxInt32Item(GetWhich(SID_ATTR_TRANSFORM_ROT_X), basegfx::fround(fTmpX)));
329         rSet.Put(SfxInt32Item(GetWhich(SID_ATTR_TRANSFORM_ROT_Y), basegfx::fround(fTmpY)));
330 
331 		bModified |= sal_True;
332 	}
333 
334 	return bModified;
335 }
336 
337 // -----------------------------------------------------------------------
338 
Reset(const SfxItemSet & rAttrs)339 void SvxAngleTabPage::Reset(const SfxItemSet& rAttrs)
340 {
341 	const double fUIScale(double(pView->GetModel()->GetUIScale()));
342 
343 	const SfxPoolItem* pItem = GetItem( rAttrs, SID_ATTR_TRANSFORM_ROT_X );
344 	if(pItem)
345 	{
346 		const double fTmp(((double)((const SfxInt32Item*)pItem)->GetValue() - maAnchor.getX()) / fUIScale);
347 		SetMetricValue(aMtrPosX, basegfx::fround(fTmp), ePoolUnit);
348 	}
349 	else
350 	{
351 		aMtrPosX.SetText( String() );
352 	}
353 
354 	pItem = GetItem(rAttrs, SID_ATTR_TRANSFORM_ROT_Y);
355 	if(pItem)
356 	{
357 		const double fTmp(((double)((const SfxInt32Item*)pItem)->GetValue() - maAnchor.getY()) / fUIScale);
358 		SetMetricValue(aMtrPosY, basegfx::fround(fTmp), ePoolUnit);
359 	}
360 	else
361 	{
362 		aMtrPosX.SetText( String() );
363 	}
364 
365 	pItem = GetItem( rAttrs, SID_ATTR_TRANSFORM_ANGLE );
366 	if(pItem)
367 	{
368 		aMtrAngle.SetValue(((const SfxInt32Item*)pItem)->GetValue());
369 	}
370 	else
371 	{
372 		aMtrAngle.SetText( String() );
373 	}
374 
375 	aMtrAngle.SaveValue();
376 	ModifiedHdl(this);
377 }
378 
379 // -----------------------------------------------------------------------
380 
Create(Window * pWindow,const SfxItemSet & rSet)381 SfxTabPage* SvxAngleTabPage::Create( Window* pWindow, const SfxItemSet& rSet)
382 {
383     return(new SvxAngleTabPage(pWindow, rSet));
384 }
385 
386 //------------------------------------------------------------------------
387 
GetRanges()388 sal_uInt16* SvxAngleTabPage::GetRanges()
389 {
390 	return(pAngleRanges);
391 }
392 
393 // -----------------------------------------------------------------------
394 
ActivatePage(const SfxItemSet &)395 void SvxAngleTabPage::ActivatePage(const SfxItemSet& /*rSet*/)
396 {
397 }
398 
399 // -----------------------------------------------------------------------
400 
DeactivatePage(SfxItemSet * _pSet)401 int SvxAngleTabPage::DeactivatePage( SfxItemSet* _pSet )
402 {
403     if(_pSet)
404 	{
405         FillItemSet(*_pSet);
406 	}
407 
408 	return LEAVE_PAGE;
409 }
410 
411 //------------------------------------------------------------------------
412 
PointChanged(Window * pWindow,RECT_POINT eRP)413 void SvxAngleTabPage::PointChanged(Window* pWindow, RECT_POINT eRP)
414 {
415 	if(pWindow == &aCtlRect)
416 	{
417 		switch(eRP)
418 		{
419 			case RP_LT:
420 			{
421 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getMinX()), FUNIT_NONE );
422 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getMinY()), FUNIT_NONE );
423 				break;
424 			}
425 			case RP_MT:
426 			{
427 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getCenter().getX()), FUNIT_NONE );
428 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getMinY()), FUNIT_NONE );
429 				break;
430 			}
431 			case RP_RT:
432 			{
433 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getMaxX()), FUNIT_NONE );
434 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getMinY()), FUNIT_NONE );
435 				break;
436 			}
437 			case RP_LM:
438 			{
439 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getMinX()), FUNIT_NONE );
440 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getCenter().getY()), FUNIT_NONE );
441 				break;
442 			}
443 			case RP_MM:
444 			{
445 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getCenter().getX()), FUNIT_NONE );
446 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getCenter().getY()), FUNIT_NONE );
447 				break;
448 			}
449 			case RP_RM:
450 			{
451 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getMaxX()), FUNIT_NONE );
452 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getCenter().getY()), FUNIT_NONE );
453 				break;
454 			}
455 			case RP_LB:
456 			{
457 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getMinX()), FUNIT_NONE );
458 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getMaxY()), FUNIT_NONE );
459 				break;
460 			}
461 			case RP_MB:
462 			{
463 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getCenter().getX()), FUNIT_NONE );
464 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getMaxY()), FUNIT_NONE );
465 				break;
466 			}
467 			case RP_RB:
468 			{
469 				aMtrPosX.SetUserValue( basegfx::fround64(maRange.getMaxX()), FUNIT_NONE );
470 				aMtrPosY.SetUserValue( basegfx::fround64(maRange.getMaxY()), FUNIT_NONE );
471 				break;
472 			}
473 		}
474 	}
475 	else if(pWindow == &aCtlAngle)
476 	{
477 		switch( eRP )
478 		{
479 			case RP_LT: aMtrAngle.SetUserValue( 13500, FUNIT_NONE ); break;
480 			case RP_MT: aMtrAngle.SetUserValue(  9000, FUNIT_NONE ); break;
481 			case RP_RT: aMtrAngle.SetUserValue(  4500, FUNIT_NONE ); break;
482 			case RP_LM: aMtrAngle.SetUserValue( 18000, FUNIT_NONE ); break;
483 			case RP_RM: aMtrAngle.SetUserValue(     0, FUNIT_NONE ); break;
484 			case RP_LB: aMtrAngle.SetUserValue( 22500, FUNIT_NONE ); break;
485 			case RP_MB: aMtrAngle.SetUserValue( 27000, FUNIT_NONE ); break;
486 			case RP_RB: aMtrAngle.SetUserValue( 31500, FUNIT_NONE ); break;
487             case RP_MM: break;
488         }
489 	}
490 }
491 
492 //------------------------------------------------------------------------
493 
IMPL_LINK(SvxAngleTabPage,ModifiedHdl,void *,EMPTYARG)494 IMPL_LINK( SvxAngleTabPage, ModifiedHdl, void *, EMPTYARG )
495 {
496 	switch(aMtrAngle.GetValue())
497 	{
498 		case 13500: aCtlAngle.SetActualRP( RP_LT ); break;
499 		case  9000: aCtlAngle.SetActualRP( RP_MT ); break;
500 		case  4500: aCtlAngle.SetActualRP( RP_RT ); break;
501 		case 18000: aCtlAngle.SetActualRP( RP_LM ); break;
502 		case     0: aCtlAngle.SetActualRP( RP_RM ); break;
503 		case 22500: aCtlAngle.SetActualRP( RP_LB ); break;
504 		case 27000: aCtlAngle.SetActualRP( RP_MB ); break;
505 		case 31500: aCtlAngle.SetActualRP( RP_RB ); break;
506 		default:    aCtlAngle.SetActualRP( RP_MM ); break;
507 	}
508 
509 	return( 0L );
510 }
511 
512 /*************************************************************************
513 |*
514 |*      Dialog zum Aendern des Eckenradius und zum Schraegstellen
515 |*
516 \************************************************************************/
517 
SvxSlantTabPage(Window * pParent,const SfxItemSet & rInAttrs)518 SvxSlantTabPage::SvxSlantTabPage( Window* pParent, const SfxItemSet& rInAttrs  ) :
519 	SvxTabPage              ( pParent, CUI_RES( RID_SVXPAGE_SLANT ), rInAttrs ),
520 
521 	aFlRadius               ( this, CUI_RES( FL_RADIUS ) ),
522 	aFtRadius               ( this, CUI_RES( FT_RADIUS ) ),
523 	aMtrRadius              ( this, CUI_RES( MTR_FLD_RADIUS ) ),
524 	aFlAngle                ( this, CUI_RES( FL_SLANT ) ),
525 	aFtAngle                ( this, CUI_RES( FT_ANGLE ) ),
526 	aMtrAngle               ( this, CUI_RES( MTR_FLD_ANGLE ) ),
527 	rOutAttrs               ( rInAttrs )
528 {
529 	FreeResource();
530 
531 	// this page needs ExchangeSupport
532 	SetExchangeSupport();
533 
534 	// evaluate PoolUnit
535 	SfxItemPool* pPool = rOutAttrs.GetPool();
536 	DBG_ASSERT( pPool, "no pool (!)" );
537 	ePoolUnit = pPool->GetMetric( SID_ATTR_TRANSFORM_POS_X );
538 }
539 
540 // -----------------------------------------------------------------------
541 
Construct()542 void SvxSlantTabPage::Construct()
543 {
544 	// get the range
545 	DBG_ASSERT(pView, "no valid view (!)");
546 	eDlgUnit = GetModuleFieldUnit(GetItemSet());
547 	SetFieldUnit(aMtrRadius, eDlgUnit, sal_True);
548 
549 	{ // #i75273#
550 		Rectangle aTempRect(pView->GetAllMarkedRect());
551 		pView->GetSdrPageView()->LogicToPagePos(aTempRect);
552 		maRange = basegfx::B2DRange(aTempRect.Left(), aTempRect.Top(), aTempRect.Right(), aTempRect.Bottom());
553 	}
554 }
555 
556 // -----------------------------------------------------------------------
557 
FillItemSet(SfxItemSet & rAttrs)558 sal_Bool SvxSlantTabPage::FillItemSet(SfxItemSet& rAttrs)
559 {
560 	sal_Bool  bModified = sal_False;
561 	sal_Int32 nValue = 0L;
562 	String aStr = aMtrRadius.GetText();
563 
564 	if( aStr != aMtrRadius.GetSavedValue() )
565 	{
566 		Fraction aUIScale = pView->GetModel()->GetUIScale();
567 		long nTmp = GetCoreValue( aMtrRadius, ePoolUnit );
568 		nTmp = Fraction( nTmp ) * aUIScale;
569 
570 		rAttrs.Put( SdrEckenradiusItem( nTmp ) );
571 		bModified = sal_True;
572 	}
573 
574 	aStr = aMtrAngle.GetText();
575 
576 	if( aStr != aMtrAngle.GetSavedValue() )
577 	{
578 		nValue = static_cast<sal_Int32>(aMtrAngle.GetValue());
579 		rAttrs.Put( SfxInt32Item( SID_ATTR_TRANSFORM_SHEAR, nValue ) );
580 		bModified = sal_True;
581 	}
582 
583 	if( bModified )
584 	{
585 		// Referenzpunkt setzen
586 		// #75897#
587 		Rectangle aObjectRect(pView->GetAllMarkedRect());
588 		pView->GetSdrPageView()->LogicToPagePos(aObjectRect);
589 		Point aPt = aObjectRect.Center();
590 
591 		rAttrs.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_X, aPt.X()));
592 		rAttrs.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_Y, aPt.Y()));
593 		rAttrs.Put( SfxBoolItem( SID_ATTR_TRANSFORM_SHEAR_VERTICAL, sal_False ) );
594 	}
595 
596 	return( bModified );
597 }
598 
599 // -----------------------------------------------------------------------
600 
Reset(const SfxItemSet & rAttrs)601 void SvxSlantTabPage::Reset(const SfxItemSet& rAttrs)
602 {
603 	// if the view has selected objects, items with SFX_ITEM_DEFAULT need to be disabled
604 	const SfxPoolItem* pItem;
605 
606 	// Eckenradius
607 	if(!pView->IsEdgeRadiusAllowed())
608 	{
609 		aFlRadius.Disable();
610 		aFtRadius.Disable();
611 		aMtrRadius.Disable();
612 		aMtrRadius.SetText( String() );
613 	}
614 	else
615 	{
616 		pItem = GetItem( rAttrs, SDRATTR_ECKENRADIUS );
617 
618 		if( pItem )
619 		{
620 			const double fUIScale(double(pView->GetModel()->GetUIScale()));
621 			const double fTmp((double)((const SdrEckenradiusItem*)pItem)->GetValue() / fUIScale);
622 			SetMetricValue(aMtrRadius, basegfx::fround(fTmp), ePoolUnit);
623 		}
624 		else
625 		{
626 			aMtrRadius.SetText( String() );
627 		}
628 	}
629 
630 	aMtrRadius.SaveValue();
631 
632 	// Schraegstellen: Winkel
633 	if( !pView->IsShearAllowed() )
634 	{
635 		aFlAngle.Disable();
636 		aFtAngle.Disable();
637 		aMtrAngle.Disable();
638 		aMtrAngle.SetText( String() );
639 	}
640 	else
641 	{
642 		pItem = GetItem( rAttrs, SID_ATTR_TRANSFORM_SHEAR );
643 
644 		if( pItem )
645 		{
646 			aMtrAngle.SetValue( ( (const SfxInt32Item*)pItem )->GetValue() );
647 		}
648 		else
649 		{
650 			aMtrAngle.SetText( String() );
651 		}
652 	}
653 
654 	aMtrAngle.SaveValue();
655 }
656 
657 // -----------------------------------------------------------------------
658 
Create(Window * pWindow,const SfxItemSet & rOutAttrs)659 SfxTabPage* SvxSlantTabPage::Create( Window* pWindow, const SfxItemSet& rOutAttrs )
660 {
661 	return( new SvxSlantTabPage( pWindow, rOutAttrs ) );
662 }
663 
664 //------------------------------------------------------------------------
665 
GetRanges()666 sal_uInt16* SvxSlantTabPage::GetRanges()
667 {
668 	return( pSlantRanges );
669 }
670 
671 // -----------------------------------------------------------------------
672 
ActivatePage(const SfxItemSet & rSet)673 void SvxSlantTabPage::ActivatePage( const SfxItemSet& rSet )
674 {
675 	SfxRectangleItem* pRectItem = NULL;
676 
677 	if( SFX_ITEM_SET == rSet.GetItemState( GetWhich( SID_ATTR_TRANSFORM_INTERN ) , sal_False, (const SfxPoolItem**) &pRectItem ) )
678 	{
679 		const Rectangle aTempRect(pRectItem->GetValue());
680 		maRange = basegfx::B2DRange(aTempRect.Left(), aTempRect.Top(), aTempRect.Right(), aTempRect.Bottom());
681 	}
682 }
683 
684 // -----------------------------------------------------------------------
685 
DeactivatePage(SfxItemSet * _pSet)686 int SvxSlantTabPage::DeactivatePage( SfxItemSet* _pSet )
687 {
688     if(_pSet)
689 	{
690         FillItemSet(*_pSet);
691 	}
692 
693 	return LEAVE_PAGE;
694 }
695 
696 //------------------------------------------------------------------------
697 
PointChanged(Window *,RECT_POINT)698 void SvxSlantTabPage::PointChanged( Window* , RECT_POINT  )
699 {
700 }
701 
702 /*************************************************************************
703 |*
704 |*      Dialog for changing position and size of graphic objects
705 |*
706 \************************************************************************/
707 
SvxPositionSizeTabPage(Window * pParent,const SfxItemSet & rInAttrs)708 SvxPositionSizeTabPage::SvxPositionSizeTabPage( Window* pParent, const SfxItemSet& rInAttrs  ) :
709 	SvxTabPage      ( pParent, CUI_RES( RID_SVXPAGE_POSITION_SIZE ), rInAttrs ),
710 	maFlPosition		( this, CUI_RES( FL_POSITION ) ),
711 	maFtPosX			( this, CUI_RES( FT_POS_X ) ),
712 	maMtrPosX			( this, CUI_RES( MTR_FLD_POS_X ) ),
713 	maFtPosY			( this, CUI_RES( FT_POS_Y ) ),
714 	maMtrPosY			( this, CUI_RES( MTR_FLD_POS_Y ) ),
715     maFtPosReference    ( this, CUI_RES( FT_POSREFERENCE ) ),
716     maCtlPos            ( this, CUI_RES( CTL_POSRECT ), RP_LT ),
717 
718     maFlSize                         ( this, CUI_RES( FL_SIZE ) ),
719 	maFtWidth                        ( this, CUI_RES( FT_WIDTH ) ),
720 	maMtrWidth                       ( this, CUI_RES( MTR_FLD_WIDTH ) ),
721 	maFtHeight                       ( this, CUI_RES( FT_HEIGHT ) ),
722 	maMtrHeight                      ( this, CUI_RES( MTR_FLD_HEIGHT ) ),
723 	maCbxScale                       ( this, CUI_RES( CBX_SCALE ) ),
724     maFtSizeReference                ( this, CUI_RES( FT_SIZEREFERENCE) ),
725     maCtlSize                        ( this, CUI_RES( CTL_SIZERECT ), RP_LT ),
726 
727     maFlProtect         ( this, CUI_RES( FL_PROTECT) ),
728     maTsbPosProtect     ( this, CUI_RES( TSB_POSPROTECT ) ),
729     maTsbSizeProtect                 ( this, CUI_RES( TSB_SIZEPROTECT ) ),
730 
731 
732     maFlAdjust                       ( this, CUI_RES( FL_ADJUST ) ),
733 	maTsbAutoGrowWidth				( this, CUI_RES( TSB_AUTOGROW_WIDTH ) ),
734 	maTsbAutoGrowHeight				( this, CUI_RES( TSB_AUTOGROW_HEIGHT ) ),
735 
736 	maFlDivider						(this, CUI_RES( FL_DIVIDER ) ),
737 
738     mrOutAttrs       ( rInAttrs ),
739     mnProtectSizeState( STATE_NOCHECK ),
740     mbPageDisabled   ( sal_False ),
741     mbProtectDisabled( false ),
742     mbSizeDisabled( false ),
743     mbAdjustDisabled( true )
744 {
745 	FreeResource();
746 
747 	// this pege needs ExchangeSupport
748 	SetExchangeSupport();
749 
750 	// evaluate PoolUnit
751 	SfxItemPool* pPool = mrOutAttrs.GetPool();
752 	DBG_ASSERT( pPool, "no pool (!)" );
753 	mePoolUnit = pPool->GetMetric( SID_ATTR_TRANSFORM_POS_X );
754 
755 	meRP = RP_LT; // s.o.
756 
757 	maMtrWidth.SetModifyHdl( LINK( this, SvxPositionSizeTabPage, ChangeWidthHdl ) );
758 	maMtrHeight.SetModifyHdl( LINK( this, SvxPositionSizeTabPage, ChangeHeightHdl ) );
759 	maCbxScale.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ClickAutoHdl ) );
760 
761 	maTsbAutoGrowWidth.Disable();
762 	maTsbAutoGrowHeight.Disable();
763 	maFlAdjust.Disable();
764 
765 	// #i2379# disable controls when protected
766 	maTsbPosProtect.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ChangePosProtectHdl ) );
767 	maTsbSizeProtect.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ChangeSizeProtectHdl ) );
768 
769 	maCtlPos.SetAccessibleRelationMemberOf( &maFlPosition );
770 	maCtlSize.SetAccessibleRelationMemberOf( &maFlSize );
771     maCtlPos.SetAccessibleRelationLabeledBy( &maFtPosReference );
772 	maCtlSize.SetAccessibleRelationLabeledBy( &maFtSizeReference );
773 }
774 
775 // -----------------------------------------------------------------------
776 
Construct()777 void SvxPositionSizeTabPage::Construct()
778 {
779 	// get range and work area
780 	DBG_ASSERT( mpView, "no valid view (!)" );
781 	meDlgUnit = GetModuleFieldUnit( GetItemSet() );
782 	SetFieldUnit( maMtrPosX, meDlgUnit, sal_True );
783 	SetFieldUnit( maMtrPosY, meDlgUnit, sal_True );
784 	SetFieldUnit( maMtrWidth, meDlgUnit, sal_True );
785 	SetFieldUnit( maMtrHeight, meDlgUnit, sal_True );
786 
787 	if(FUNIT_MILE == meDlgUnit || FUNIT_KM == meDlgUnit)
788 	{
789 		maMtrPosX.SetDecimalDigits( 3 );
790 		maMtrPosY.SetDecimalDigits( 3 );
791 		maMtrWidth.SetDecimalDigits( 3 );
792 		maMtrHeight.SetDecimalDigits( 3 );
793 	}
794 
795 	{ // #i75273#
796 		Rectangle aTempRect(mpView->GetAllMarkedRect());
797 		mpView->GetSdrPageView()->LogicToPagePos(aTempRect);
798 		maRange = basegfx::B2DRange(aTempRect.Left(), aTempRect.Top(), aTempRect.Right(), aTempRect.Bottom());
799 	}
800 
801 	{ // #i75273#
802 		Rectangle aTempRect(mpView->GetWorkArea());
803 		mpView->GetSdrPageView()->LogicToPagePos(aTempRect);
804 		maWorkRange = basegfx::B2DRange(aTempRect.Left(), aTempRect.Top(), aTempRect.Right(), aTempRect.Bottom());
805 	}
806 
807 	// take anchor into account (Writer)
808 	const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
809 
810 	if(rMarkList.GetMarkCount())
811 	{
812 		const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
813 		maAnchor = basegfx::B2DPoint(pObj->GetAnchorPos().X(), pObj->GetAnchorPos().Y());
814 
815 		if(!maAnchor.equalZero()) // -> Writer
816 		{
817 			for(sal_uInt16 i(1); i < rMarkList.GetMarkCount(); i++)
818 			{
819 				pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
820 
821 				if(maAnchor != basegfx::B2DPoint(pObj->GetAnchorPos().X(), pObj->GetAnchorPos().Y()))
822 				{
823 					// different anchor positions
824 					maMtrPosX.SetText( String() );
825 					maMtrPosY.SetText( String() );
826 					mbPageDisabled = sal_True;
827 					return;
828 				}
829 			}
830 
831 			// translate ranges about anchor
832 			maRange = basegfx::B2DRange(maRange.getMinimum() - maAnchor, maRange.getMaximum() - maAnchor);
833 			maWorkRange = basegfx::B2DRange(maWorkRange.getMinimum() - maAnchor, maWorkRange.getMaximum() - maAnchor);
834 		}
835 	}
836 
837 	// this should happen via SID_ATTR_TRANSFORM_AUTOSIZE
838 	if(1 == rMarkList.GetMarkCount())
839 	{
840 		const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
841 		const SdrObjKind eKind((SdrObjKind)pObj->GetObjIdentifier());
842 
843 		if((pObj->GetObjInventor() == SdrInventor) &&
844             (OBJ_TEXT == eKind || OBJ_TITLETEXT == eKind || OBJ_OUTLINETEXT == eKind) &&
845             pObj->HasText())
846 		{
847 			mbAdjustDisabled = false;
848 			maFlAdjust.Enable();
849 			maTsbAutoGrowWidth.Enable();
850 			maTsbAutoGrowHeight.Enable();
851 			maTsbAutoGrowWidth.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ClickSizeProtectHdl ) );
852 			maTsbAutoGrowHeight.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ClickSizeProtectHdl ) );
853 
854 			// is used as flag to evaluate if its selectable
855 			maTsbAutoGrowWidth.EnableTriState( sal_False );
856 			maTsbAutoGrowHeight.EnableTriState( sal_False );
857 		}
858 	}
859 
860 	// take scale into account
861 	const Fraction aUIScale(mpView->GetModel()->GetUIScale());
862 	lcl_ScaleRect( maWorkRange, aUIScale );
863 	lcl_ScaleRect( maRange, aUIScale );
864 
865 	// take UI units into account
866 	const sal_uInt16 nDigits(maMtrPosX.GetDecimalDigits());
867 	lcl_ConvertRect( maWorkRange, nDigits, (MapUnit) mePoolUnit, meDlgUnit );
868 	lcl_ConvertRect( maRange, nDigits, (MapUnit) mePoolUnit, meDlgUnit );
869 
870 	SetMinMaxPosition();
871 }
872 
873 // -----------------------------------------------------------------------
874 
FillItemSet(SfxItemSet & rOutAttrs)875 sal_Bool SvxPositionSizeTabPage::FillItemSet( SfxItemSet& rOutAttrs )
876 {
877 	sal_Bool bModified(sal_False);
878 
879 	if ( maMtrWidth.HasFocus() )
880 	{
881 		ChangeWidthHdl( this );
882 	}
883 
884 	if ( maMtrHeight.HasFocus() )
885 	{
886 		ChangeHeightHdl( this );
887 	}
888 
889 	if( !mbPageDisabled )
890 	{
891 		if ( maMtrPosX.IsValueModified() || maMtrPosY.IsValueModified() )
892 		{
893 			const double fUIScale(double(mpView->GetModel()->GetUIScale()));
894 			double fX((GetCoreValue( maMtrPosX, mePoolUnit ) + maAnchor.getX()) * fUIScale);
895 			double fY((GetCoreValue( maMtrPosY, mePoolUnit ) + maAnchor.getY()) * fUIScale);
896 
897 			{ // #i75273#
898 				Rectangle aTempRect(mpView->GetAllMarkedRect());
899 				mpView->GetSdrPageView()->LogicToPagePos(aTempRect);
900 				maRange = basegfx::B2DRange(aTempRect.Left(), aTempRect.Top(), aTempRect.Right(), aTempRect.Bottom());
901 			}
902 
903 			// #101581# GetTopLeftPosition(...) needs coordinates after UI scaling, in real PagePositions
904 			GetTopLeftPosition(fX, fY, maRange);
905 
906 			rOutAttrs.Put(SfxInt32Item(GetWhich(SID_ATTR_TRANSFORM_POS_X), basegfx::fround(fX)));
907 			rOutAttrs.Put(SfxInt32Item(GetWhich(SID_ATTR_TRANSFORM_POS_Y), basegfx::fround(fY)));
908 
909 			bModified |= sal_True;
910 		}
911 
912 		if ( maTsbPosProtect.GetState() != maTsbPosProtect.GetSavedValue() )
913 		{
914 			if( maTsbPosProtect.GetState() == STATE_DONTKNOW )
915 			{
916 				rOutAttrs.InvalidateItem( SID_ATTR_TRANSFORM_PROTECT_POS );
917 			}
918 			else
919 			{
920 				rOutAttrs.Put(
921 					SfxBoolItem( GetWhich( SID_ATTR_TRANSFORM_PROTECT_POS ),
922 					maTsbPosProtect.GetState() == STATE_CHECK ? sal_True : sal_False ) );
923 			}
924 
925 			bModified |= sal_True;
926 		}
927 	}
928 
929 	if ( maMtrWidth.IsValueModified() || maMtrHeight.IsValueModified() )
930 	{
931 		Fraction aUIScale = mpView->GetModel()->GetUIScale();
932 
933 		// get Width
934 		double nWidth = static_cast<double>(maMtrWidth.GetValue( meDlgUnit ));
935 		nWidth = MetricField::ConvertDoubleValue( nWidth, maMtrWidth.GetBaseValue(), maMtrWidth.GetDecimalDigits(), meDlgUnit, FUNIT_100TH_MM );
936         long lWidth = long(nWidth * (double)aUIScale);
937 		lWidth = OutputDevice::LogicToLogic( lWidth, MAP_100TH_MM, (MapUnit)mePoolUnit );
938 		lWidth = static_cast<long>(maMtrWidth.Denormalize( lWidth ));
939 
940 		// get Height
941 		double nHeight = static_cast<double>(maMtrHeight.GetValue( meDlgUnit ));
942 		nHeight = MetricField::ConvertDoubleValue( nHeight, maMtrHeight.GetBaseValue(), maMtrHeight.GetDecimalDigits(), meDlgUnit, FUNIT_100TH_MM );
943         long lHeight = long(nHeight * (double)aUIScale);
944 		lHeight = OutputDevice::LogicToLogic( lHeight, MAP_100TH_MM, (MapUnit)mePoolUnit );
945 		lHeight = static_cast<long>(maMtrWidth.Denormalize( lHeight ));
946 
947 		// put Width & Height to itemset
948 		rOutAttrs.Put( SfxUInt32Item( GetWhich( SID_ATTR_TRANSFORM_WIDTH ),
949 						(sal_uInt32) lWidth ) );
950 		rOutAttrs.Put( SfxUInt32Item( GetWhich( SID_ATTR_TRANSFORM_HEIGHT ),
951 						(sal_uInt32) lHeight ) );
952 		rOutAttrs.Put( SfxAllEnumItem( GetWhich( SID_ATTR_TRANSFORM_SIZE_POINT ), sal::static_int_cast< sal_uInt16 >( meRP ) ) );
953 		bModified |= sal_True;
954 	}
955 
956 	if ( maTsbSizeProtect.GetState() != maTsbSizeProtect.GetSavedValue() )
957 	{
958 		if ( maTsbSizeProtect.GetState() == STATE_DONTKNOW )
959 			rOutAttrs.InvalidateItem( SID_ATTR_TRANSFORM_PROTECT_SIZE );
960 		else
961 			rOutAttrs.Put(
962 				SfxBoolItem( GetWhich( SID_ATTR_TRANSFORM_PROTECT_SIZE ),
963 				maTsbSizeProtect.GetState() == STATE_CHECK ? sal_True : sal_False ) );
964 		bModified |= sal_True;
965 	}
966 
967 	if ( maTsbAutoGrowWidth.GetState() != maTsbAutoGrowWidth.GetSavedValue() )
968 	{
969 		if ( !maTsbAutoGrowWidth.IsTriStateEnabled() )
970 		{
971 			if( maTsbAutoGrowWidth.GetState() == STATE_DONTKNOW )
972 				rOutAttrs.InvalidateItem( SID_ATTR_TRANSFORM_AUTOWIDTH );
973 			else
974 				rOutAttrs.Put(
975 					SfxBoolItem( GetWhich( SID_ATTR_TRANSFORM_AUTOWIDTH ),
976 					maTsbAutoGrowWidth.GetState() == STATE_CHECK ? sal_True : sal_False ) );
977 		}
978 		bModified |= sal_True;
979 	}
980 
981 	if ( maTsbAutoGrowHeight.GetState() != maTsbAutoGrowHeight.GetSavedValue() )
982 	{
983 		if ( !maTsbAutoGrowHeight.IsTriStateEnabled() )
984 		{
985 			if( maTsbAutoGrowHeight.GetState() == STATE_DONTKNOW )
986 				rOutAttrs.InvalidateItem( SID_ATTR_TRANSFORM_AUTOHEIGHT );
987 			else
988 				rOutAttrs.Put(
989 					SfxBoolItem( GetWhich( SID_ATTR_TRANSFORM_AUTOHEIGHT ),
990 					maTsbAutoGrowHeight.GetState() == STATE_CHECK ? sal_True : sal_False ) );
991 		}
992 		bModified |= sal_True;
993 	}
994 
995 
996 	return bModified;
997 }
998 
999 // -----------------------------------------------------------------------
1000 
Reset(const SfxItemSet &)1001 void SvxPositionSizeTabPage::Reset( const SfxItemSet&  )
1002 {
1003 	const SfxPoolItem* pItem;
1004 	const double fUIScale(double(mpView->GetModel()->GetUIScale()));
1005 
1006 	if ( !mbPageDisabled )
1007 	{
1008 		pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_POS_X );
1009 		if ( pItem )
1010 		{
1011 			const double fTmp((((const SfxInt32Item*)pItem)->GetValue() - maAnchor.getX()) / fUIScale);
1012 			SetMetricValue(maMtrPosX, basegfx::fround(fTmp), mePoolUnit);
1013 		}
1014 
1015 		pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_POS_Y );
1016 		if ( pItem )
1017 		{
1018 			const double fTmp((((const SfxInt32Item*)pItem)->GetValue() - maAnchor.getY()) / fUIScale);
1019 			SetMetricValue(maMtrPosY, basegfx::fround(fTmp), mePoolUnit);
1020 		}
1021 
1022 		pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_PROTECT_POS );
1023 		if ( pItem )
1024 		{
1025 			sal_Bool bProtected = ( ( const SfxBoolItem* )pItem )->GetValue();
1026 			maTsbPosProtect.SetState( bProtected ? STATE_CHECK : STATE_NOCHECK );
1027 			maTsbPosProtect.EnableTriState( sal_False );
1028 		}
1029 		else
1030 		{
1031 			maTsbPosProtect.SetState( STATE_DONTKNOW );
1032 		}
1033 
1034 		maTsbPosProtect.SaveValue();
1035 		maCtlPos.Reset();
1036 
1037         // #i2379# Disable controls for protected objects
1038         ChangePosProtectHdl( this );
1039 	}
1040 
1041 	{ // #i75273# set width
1042 		pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_WIDTH );
1043 		mfOldWidth = std::max( pItem ? (double)((const SfxUInt32Item*)pItem)->GetValue() : 0.0, 1.0 );
1044 		double fTmpWidth((OutputDevice::LogicToLogic(static_cast<sal_Int32>(mfOldWidth), (MapUnit)mePoolUnit, MAP_100TH_MM)) / fUIScale);
1045 
1046 		if(maMtrWidth.GetDecimalDigits())
1047 			fTmpWidth *= pow(10.0, maMtrWidth.GetDecimalDigits());
1048 
1049 		fTmpWidth = MetricField::ConvertDoubleValue(fTmpWidth, maMtrWidth.GetBaseValue(), maMtrWidth.GetDecimalDigits(), FUNIT_100TH_MM, meDlgUnit);
1050 		maMtrWidth.SetValue(static_cast<sal_Int64>(fTmpWidth), meDlgUnit);
1051 	}
1052 
1053 	{ // #i75273# set height
1054 		pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_HEIGHT );
1055 		mfOldHeight = std::max( pItem ? (double)((const SfxUInt32Item*)pItem)->GetValue() : 0.0, 1.0 );
1056 		double fTmpHeight((OutputDevice::LogicToLogic(static_cast<sal_Int32>(mfOldHeight), (MapUnit)mePoolUnit, MAP_100TH_MM)) / fUIScale);
1057 
1058 		if(maMtrHeight.GetDecimalDigits())
1059 			fTmpHeight *= pow(10.0, maMtrHeight.GetDecimalDigits());
1060 
1061 		fTmpHeight = MetricField::ConvertDoubleValue(fTmpHeight, maMtrHeight.GetBaseValue(), maMtrHeight.GetDecimalDigits(), FUNIT_100TH_MM, meDlgUnit);
1062 		maMtrHeight.SetValue(static_cast<sal_Int64>(fTmpHeight), meDlgUnit);
1063 	}
1064 
1065 	pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_PROTECT_SIZE );
1066 	if ( pItem )
1067 	{
1068 		maTsbSizeProtect.SetState( ( (const SfxBoolItem*)pItem )->GetValue()
1069 							  ? STATE_CHECK : STATE_NOCHECK );
1070 		maTsbSizeProtect.EnableTriState( sal_False );
1071 	}
1072 	else
1073 		maTsbSizeProtect.SetState( STATE_DONTKNOW );
1074 
1075 	pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_AUTOWIDTH );
1076 	if ( pItem )
1077 	{
1078 		maTsbAutoGrowWidth.SetState( ( ( const SfxBoolItem* )pItem )->GetValue()
1079 						   ? STATE_CHECK : STATE_NOCHECK );
1080 	}
1081 	else
1082 		maTsbAutoGrowWidth.SetState( STATE_DONTKNOW );
1083 
1084 	pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_AUTOHEIGHT );
1085 	if ( pItem )
1086 	{
1087 		maTsbAutoGrowHeight.SetState( ( ( const SfxBoolItem* )pItem )->GetValue()
1088 						   ? STATE_CHECK : STATE_NOCHECK );
1089 	}
1090 	else
1091 		maTsbAutoGrowHeight.SetState( STATE_DONTKNOW );
1092 
1093 	// Ist Abgleich gesetzt?
1094 	String aStr = GetUserData();
1095 	maCbxScale.Check( (sal_Bool)aStr.ToInt32() );
1096 
1097 	maTsbSizeProtect.SaveValue();
1098 	maTsbAutoGrowWidth.SaveValue();
1099 	maTsbAutoGrowHeight.SaveValue();
1100 	ClickSizeProtectHdl( NULL );
1101 
1102     // #i2379# Disable controls for protected objects
1103     ChangeSizeProtectHdl( this );
1104 }
1105 
1106 // -----------------------------------------------------------------------
1107 
Create(Window * pWindow,const SfxItemSet & rOutAttrs)1108 SfxTabPage* SvxPositionSizeTabPage::Create( Window* pWindow, const SfxItemSet& rOutAttrs )
1109 {
1110 	return( new SvxPositionSizeTabPage( pWindow, rOutAttrs ) );
1111 }
1112 
1113 //------------------------------------------------------------------------
1114 
GetRanges()1115 sal_uInt16* SvxPositionSizeTabPage::GetRanges()
1116 {
1117 	return( pPosSizeRanges );
1118 }
1119 
1120 // -----------------------------------------------------------------------
1121 
ActivatePage(const SfxItemSet & rSet)1122 void SvxPositionSizeTabPage::ActivatePage( const SfxItemSet& rSet )
1123 {
1124 	SfxRectangleItem* pRectItem = NULL;
1125 
1126 	if( SFX_ITEM_SET == rSet.GetItemState( GetWhich( SID_ATTR_TRANSFORM_INTERN ) , sal_False, (const SfxPoolItem**) &pRectItem ) )
1127 	{
1128 		{ // #i75273#
1129 			const Rectangle aTempRect(pRectItem->GetValue());
1130 			maRange = basegfx::B2DRange(aTempRect.Left(), aTempRect.Top(), aTempRect.Right(), aTempRect.Bottom());
1131 		}
1132 
1133 		SetMinMaxPosition();
1134 	}
1135 }
1136 
1137 // -----------------------------------------------------------------------
1138 
DeactivatePage(SfxItemSet * _pSet)1139 int SvxPositionSizeTabPage::DeactivatePage( SfxItemSet* _pSet )
1140 {
1141     if( _pSet )
1142 	{
1143 		double fX((double)maMtrPosX.GetValue());
1144 		double fY((double)maMtrPosY.GetValue());
1145 
1146 		GetTopLeftPosition(fX, fY, maRange);
1147 		const Rectangle aOutRectangle(
1148 			basegfx::fround(fX), basegfx::fround(fY),
1149 			basegfx::fround(fX + maRange.getWidth()), basegfx::fround(fY + maRange.getHeight()));
1150         _pSet->Put(SfxRectangleItem(SID_ATTR_TRANSFORM_INTERN, aOutRectangle));
1151 
1152         FillItemSet(*_pSet);
1153 	}
1154 
1155 	return LEAVE_PAGE;
1156 }
1157 
1158 //------------------------------------------------------------------------
1159 
IMPL_LINK(SvxPositionSizeTabPage,ChangePosProtectHdl,void *,EMPTYARG)1160 IMPL_LINK( SvxPositionSizeTabPage, ChangePosProtectHdl, void *, EMPTYARG )
1161 {
1162     // #106572# Remember user's last choice
1163 	maTsbSizeProtect.SetState( maTsbPosProtect.GetState() == STATE_CHECK ?  STATE_CHECK : mnProtectSizeState );
1164     UpdateControlStates();
1165 	return( 0L );
1166 }
1167 
1168 //------------------------------------------------------------------------
1169 
UpdateControlStates()1170 void SvxPositionSizeTabPage::UpdateControlStates()
1171 {
1172 	const bool bPosProtect =  maTsbPosProtect.GetState() == STATE_CHECK;
1173 	const bool bSizeProtect = maTsbSizeProtect.GetState() == STATE_CHECK;
1174 	const bool bHeightChecked = !maTsbAutoGrowHeight.IsTriStateEnabled() && (maTsbAutoGrowHeight.GetState() == STATE_CHECK);
1175 	const bool bWidthChecked = !maTsbAutoGrowWidth.IsTriStateEnabled() && (maTsbAutoGrowWidth.GetState() == STATE_CHECK);
1176 
1177 	maFlPosition.Enable( !bPosProtect && !mbPageDisabled );
1178 	maFtPosX.Enable( !bPosProtect && !mbPageDisabled );
1179 	maMtrPosX.Enable( !bPosProtect && !mbPageDisabled );
1180 	maFtPosY.Enable( !bPosProtect && !mbPageDisabled );
1181 	maMtrPosY.Enable( !bPosProtect && !mbPageDisabled );
1182 	maFtPosReference.Enable( !bPosProtect && !mbPageDisabled );
1183 	maCtlPos.Enable( !bPosProtect );
1184 	maTsbPosProtect.Enable( !mbProtectDisabled && !mbPageDisabled );
1185 
1186 	maFlSize.Enable( !mbSizeDisabled && !bSizeProtect );
1187 	maCtlSize.Enable( !mbSizeDisabled && !bSizeProtect && (!bHeightChecked || !bWidthChecked) );
1188 	maFtWidth.Enable( !mbSizeDisabled && !bSizeProtect && !bWidthChecked );
1189 	maMtrWidth.Enable( !mbSizeDisabled && !bSizeProtect && !bWidthChecked );
1190 	maFtHeight.Enable( !mbSizeDisabled && !bSizeProtect && !bHeightChecked );
1191 	maMtrHeight.Enable( !mbSizeDisabled && !bSizeProtect && !bHeightChecked );
1192 	maCbxScale.Enable( !mbSizeDisabled && !bSizeProtect && !bHeightChecked && !bWidthChecked );
1193 	maFtSizeReference.Enable( !mbSizeDisabled && !bSizeProtect );
1194 	maFlProtect.Enable( !mbProtectDisabled );
1195 	maTsbSizeProtect.Enable( !mbProtectDisabled && !bPosProtect );
1196 
1197 	maFlAdjust.Enable( !mbSizeDisabled && !bSizeProtect && !mbAdjustDisabled );
1198 	maTsbAutoGrowWidth.Enable( !mbSizeDisabled && !bSizeProtect && !mbAdjustDisabled );
1199 	maTsbAutoGrowHeight.Enable( !mbSizeDisabled && !bSizeProtect && !mbAdjustDisabled );
1200 
1201 	maCtlSize.Invalidate();
1202 	maCtlPos.Invalidate();
1203 
1204 }
1205 
1206 //------------------------------------------------------------------------
1207 
IMPL_LINK(SvxPositionSizeTabPage,ChangeSizeProtectHdl,void *,EMPTYARG)1208 IMPL_LINK( SvxPositionSizeTabPage, ChangeSizeProtectHdl, void *, EMPTYARG )
1209 {
1210 	if( maTsbSizeProtect.IsEnabled() )
1211 	{
1212         // #106572# Remember user's last choice
1213 
1214         // Note: this works only as long as the dialog is open.  When
1215         // the user closes the dialog, there is no way to remember
1216         // whether size was enabled or disabled befor pos protect was
1217         // clicked. Thus, if pos protect is selected, the dialog is
1218         // closed and reopened again, unchecking pos protect will
1219         // always uncheck size protect, too. That's life.
1220         mnProtectSizeState = maTsbSizeProtect.GetState();
1221     }
1222 
1223     UpdateControlStates();
1224 
1225 	return( 0L );
1226 }
1227 
1228 //------------------------------------------------------------------------
1229 
IMPL_LINK_INLINE_START(SvxPositionSizeTabPage,ChangePosXHdl,void *,EMPTYARG)1230 IMPL_LINK_INLINE_START( SvxPositionSizeTabPage, ChangePosXHdl, void *, EMPTYARG )
1231 {
1232 	return( 0L );
1233 }
IMPL_LINK_INLINE_END(SvxPositionSizeTabPage,ChangePosXHdl,void *,EMPTYARG)1234 IMPL_LINK_INLINE_END( SvxPositionSizeTabPage, ChangePosXHdl, void *, EMPTYARG )
1235 
1236 //------------------------------------------------------------------------
1237 
1238 IMPL_LINK_INLINE_START( SvxPositionSizeTabPage, ChangePosYHdl, void *, EMPTYARG )
1239 {
1240 	return( 0L );
1241 }
IMPL_LINK_INLINE_END(SvxPositionSizeTabPage,ChangePosYHdl,void *,EMPTYARG)1242 IMPL_LINK_INLINE_END( SvxPositionSizeTabPage, ChangePosYHdl, void *, EMPTYARG )
1243 
1244 //------------------------------------------------------------------------
1245 
1246 void SvxPositionSizeTabPage::SetMinMaxPosition()
1247 {
1248 	// position
1249 	double fLeft(maWorkRange.getMinX());
1250 	double fTop(maWorkRange.getMinY());
1251 	double fRight(maWorkRange.getMaxX());
1252 	double fBottom(maWorkRange.getMaxY());
1253 
1254 	switch ( maCtlPos.GetActualRP() )
1255 	{
1256 		case RP_LT:
1257 		{
1258 			fRight  -= maRange.getWidth();
1259 			fBottom -= maRange.getHeight();
1260 			break;
1261 		}
1262 		case RP_MT:
1263 		{
1264 			fLeft   += maRange.getWidth() / 2.0;
1265 			fRight  -= maRange.getWidth() / 2.0;
1266 			fBottom -= maRange.getHeight();
1267 			break;
1268 		}
1269 		case RP_RT:
1270 		{
1271 			fLeft   += maRange.getWidth();
1272 			fBottom -= maRange.getHeight();
1273 			break;
1274 		}
1275 		case RP_LM:
1276 		{
1277 			fRight  -= maRange.getWidth();
1278 			fTop    += maRange.getHeight() / 2.0;
1279 			fBottom -= maRange.getHeight() / 2.0;
1280 			break;
1281 		}
1282 		case RP_MM:
1283 		{
1284 			fLeft   += maRange.getWidth() / 2.0;
1285 			fRight  -= maRange.getWidth() / 2.0;
1286 			fTop    += maRange.getHeight() / 2.0;
1287 			fBottom -= maRange.getHeight() / 2.0;
1288 			break;
1289 		}
1290 		case RP_RM:
1291 		{
1292 			fLeft   += maRange.getWidth();
1293 			fTop    += maRange.getHeight() / 2.0;
1294 			fBottom -= maRange.getHeight() / 2.0;
1295 			break;
1296 		}
1297 		case RP_LB:
1298 		{
1299 			fRight  -= maRange.getWidth();
1300 			fTop    += maRange.getHeight();
1301 			break;
1302 		}
1303 		case RP_MB:
1304 		{
1305 			fLeft   += maRange.getWidth() / 2.0;
1306 			fRight  -= maRange.getWidth() / 2.0;
1307 			fTop    += maRange.getHeight();
1308 			break;
1309 		}
1310 		case RP_RB:
1311 		{
1312 			fLeft   += maRange.getWidth();
1313 			fTop    += maRange.getHeight();
1314 			break;
1315 		}
1316 	}
1317 
1318 	const double fMaxLong((double)(MetricField::ConvertValue( LONG_MAX, 0, MAP_100TH_MM, meDlgUnit ) - 1L));
1319 	fLeft = (fLeft > fMaxLong) ? fMaxLong : (fLeft < -fMaxLong) ? -fMaxLong : fLeft;
1320 	fRight = (fRight > fMaxLong) ? fMaxLong : (fRight < -fMaxLong) ? -fMaxLong : fRight;
1321 	fTop = (fTop > fMaxLong) ? fMaxLong : (fTop < -fMaxLong) ? -fMaxLong : fTop;
1322 	fBottom = (fBottom > fMaxLong) ? fMaxLong : (fBottom < -fMaxLong) ? -fMaxLong : fBottom;
1323 
1324 	// #i75273# normalizing when setting the min/max values was wrong, removed
1325 	maMtrPosX.SetMin(basegfx::fround64(fLeft));
1326 	maMtrPosX.SetFirst(basegfx::fround64(fLeft));
1327     maMtrPosX.SetMax(basegfx::fround64(fRight));
1328 	maMtrPosX.SetLast(basegfx::fround64(fRight));
1329     maMtrPosY.SetMin(basegfx::fround64(fTop));
1330 	maMtrPosY.SetFirst(basegfx::fround64(fTop));
1331     maMtrPosY.SetMax(basegfx::fround64(fBottom));
1332 	maMtrPosY.SetLast(basegfx::fround64(fBottom));
1333 
1334 	// size
1335 	fLeft = maWorkRange.getMinX();
1336 	fTop = maWorkRange.getMinY();
1337 	fRight = maWorkRange.getMaxX();
1338 	fBottom = maWorkRange.getMaxY();
1339 	double fNewX(0);
1340 	double fNewY(0);
1341 
1342 	switch ( maCtlSize.GetActualRP() )
1343 	{
1344 		case RP_LT:
1345 		{
1346 			fNewX = maWorkRange.getWidth() - ( maRange.getMinX() - fLeft );
1347 			fNewY = maWorkRange.getHeight() - ( maRange.getMinY() - fTop );
1348 			break;
1349 		}
1350 		case RP_MT:
1351 		{
1352 			fNewX = std::min( maRange.getCenter().getX() - fLeft, fRight - maRange.getCenter().getX() ) * 2.0;
1353 			fNewY = maWorkRange.getHeight() - ( maRange.getMinY() - fTop );
1354 			break;
1355 		}
1356 		case RP_RT:
1357 		{
1358 			fNewX = maWorkRange.getWidth() - ( fRight - maRange.getMaxX() );
1359 			fNewY = maWorkRange.getHeight() - ( maRange.getMinY() - fTop );
1360 			break;
1361 		}
1362 		case RP_LM:
1363 		{
1364 			fNewX = maWorkRange.getWidth() - ( maRange.getMinX() - fLeft );
1365 			fNewY = std::min( maRange.getCenter().getY() - fTop, fBottom - maRange.getCenter().getY() ) * 2.0;
1366 			break;
1367 		}
1368 		case RP_MM:
1369 		{
1370 			const double f1(maRange.getCenter().getX() - fLeft);
1371 			const double f2(fRight - maRange.getCenter().getX());
1372 			const double f3(std::min(f1, f2));
1373 			const double f4(maRange.getCenter().getY() - fTop);
1374 			const double f5(fBottom - maRange.getCenter().getY());
1375 			const double f6(std::min(f4, f5));
1376 
1377 			fNewX = f3 * 2.0;
1378 			fNewY = f6 * 3.0;
1379 
1380 			break;
1381 		}
1382 		case RP_RM:
1383 		{
1384 			fNewX = maWorkRange.getWidth() - ( fRight - maRange.getMaxX() );
1385 			fNewY = std::min( maRange.getCenter().getY() - fTop, fBottom - maRange.getCenter().getY() ) * 2.0;
1386 			break;
1387 		}
1388 		case RP_LB:
1389 		{
1390 			fNewX = maWorkRange.getWidth() - ( maRange.getMinX() - fLeft );
1391 			fNewY = maWorkRange.getHeight() - ( fBottom - maRange.getMaxY() );
1392 			break;
1393 		}
1394 		case RP_MB:
1395 		{
1396 			fNewX = std::min( maRange.getCenter().getX() - fLeft, fRight - maRange.getCenter().getX() ) * 2.0;
1397 			fNewY = maWorkRange.getHeight() - ( maRange.getMaxY() - fBottom );
1398 			break;
1399 		}
1400 		case RP_RB:
1401 		{
1402 			fNewX = maWorkRange.getWidth() - ( fRight - maRange.getMaxX() );
1403 			fNewY = maWorkRange.getHeight() - ( fBottom - maRange.getMaxY() );
1404 			break;
1405 		}
1406 	}
1407 
1408 	// #i75273# normalizing when setting the min/max values was wrong, removed
1409     maMtrWidth.SetMax(basegfx::fround64(fNewX));
1410 	maMtrWidth.SetLast(basegfx::fround64(fNewX));
1411     maMtrHeight.SetMax(basegfx::fround64(fNewY));
1412 	maMtrHeight.SetLast(basegfx::fround64(fNewY));
1413 }
1414 
1415 //------------------------------------------------------------------------
1416 
GetTopLeftPosition(double & rfX,double & rfY,const basegfx::B2DRange & rRange)1417 void SvxPositionSizeTabPage::GetTopLeftPosition(double& rfX, double& rfY, const basegfx::B2DRange& rRange)
1418 {
1419 	switch (maCtlPos.GetActualRP())
1420 	{
1421 		case RP_LT:
1422 		{
1423 			break;
1424 		}
1425 		case RP_MT:
1426 		{
1427 			rfX -= rRange.getCenter().getX() - rRange.getMinX();
1428 			break;
1429 		}
1430 		case RP_RT:
1431 		{
1432 			rfX -= rRange.getWidth();
1433 			break;
1434 		}
1435 		case RP_LM:
1436 		{
1437 			rfY -= rRange.getCenter().getY() - rRange.getMinY();
1438 			break;
1439 		}
1440 		case RP_MM:
1441 		{
1442 			rfX -= rRange.getCenter().getX() - rRange.getMinX();
1443 			rfY -= rRange.getCenter().getY() - rRange.getMinY();
1444 			break;
1445 		}
1446 		case RP_RM:
1447 		{
1448 			rfX -= rRange.getWidth();
1449 			rfY -= rRange.getCenter().getY() - rRange.getMinY();
1450 			break;
1451 		}
1452 		case RP_LB:
1453 		{
1454 			rfY -= rRange.getHeight();
1455 			break;
1456 		}
1457 		case RP_MB:
1458 		{
1459 			rfX -= rRange.getCenter().getX() - rRange.getMinX();
1460 			rfY -= rRange.getHeight();
1461 			break;
1462 		}
1463 		case RP_RB:
1464 		{
1465 			rfX -= rRange.getWidth();
1466 			rfY -= rRange.getHeight();
1467 			break;
1468 		}
1469 	}
1470 }
1471 
1472 //------------------------------------------------------------------------
1473 
PointChanged(Window * pWindow,RECT_POINT eRP)1474 void SvxPositionSizeTabPage::PointChanged( Window* pWindow, RECT_POINT eRP )
1475 {
1476 	if( pWindow == &maCtlPos )
1477 	{
1478 		SetMinMaxPosition();
1479 		switch( eRP )
1480 		{
1481 			case RP_LT:
1482 			{
1483 				maMtrPosX.SetValue( basegfx::fround64(maRange.getMinX()) );
1484 				maMtrPosY.SetValue( basegfx::fround64(maRange.getMinY()) );
1485 				break;
1486 			}
1487 			case RP_MT:
1488 			{
1489 				maMtrPosX.SetValue( basegfx::fround64(maRange.getCenter().getX()) );
1490 				maMtrPosY.SetValue( basegfx::fround64(maRange.getMinY()) );
1491 				break;
1492 			}
1493 			case RP_RT:
1494 			{
1495 				maMtrPosX.SetValue( basegfx::fround64(maRange.getMaxX()) );
1496 				maMtrPosY.SetValue( basegfx::fround64(maRange.getMinY()) );
1497 				break;
1498 			}
1499 			case RP_LM:
1500 			{
1501 				maMtrPosX.SetValue( basegfx::fround64(maRange.getMinX()) );
1502 				maMtrPosY.SetValue( basegfx::fround64(maRange.getCenter().getY()) );
1503 				break;
1504 			}
1505 			case RP_MM:
1506 			{
1507 				maMtrPosX.SetValue( basegfx::fround64(maRange.getCenter().getX()) );
1508 				maMtrPosY.SetValue( basegfx::fround64(maRange.getCenter().getY()) );
1509 				break;
1510 			}
1511 			case RP_RM:
1512 			{
1513 				maMtrPosX.SetValue( basegfx::fround64(maRange.getMaxX()) );
1514 				maMtrPosY.SetValue( basegfx::fround64(maRange.getCenter().getY()) );
1515 				break;
1516 			}
1517 			case RP_LB:
1518 			{
1519 				maMtrPosX.SetValue( basegfx::fround64(maRange.getMinX()) );
1520 				maMtrPosY.SetValue( basegfx::fround64(maRange.getMaxY()) );
1521 				break;
1522 			}
1523 			case RP_MB:
1524 			{
1525 				maMtrPosX.SetValue( basegfx::fround64(maRange.getCenter().getX()) );
1526 				maMtrPosY.SetValue( basegfx::fround64(maRange.getMaxY()) );
1527 				break;
1528 			}
1529 			case RP_RB:
1530 			{
1531 				maMtrPosX.SetValue( basegfx::fround64(maRange.getMaxX()) );
1532 				maMtrPosY.SetValue( basegfx::fround64(maRange.getMaxY()) );
1533 				break;
1534 			}
1535 		}
1536 	}
1537 	else
1538 	{
1539 		meRP = eRP;
1540 
1541 		Rectangle aTmpRect( GetRect() );
1542 		SetMinMaxPosition();
1543 	}
1544 }
1545 
1546 //------------------------------------------------------------------------
1547 
DisableResize()1548 void SvxPositionSizeTabPage::DisableResize()
1549 {
1550 	mbSizeDisabled = true;
1551 }
1552 
1553 //------------------------------------------------------------------------
1554 
DisableProtect()1555 void SvxPositionSizeTabPage::DisableProtect()
1556 {
1557 	mbProtectDisabled = true;
1558 }
1559 
1560 //------------------------------------------------------------------------
1561 
GetRect()1562 Rectangle SvxPositionSizeTabPage::GetRect()
1563 {
1564 	double fLeft(maRange.getMinX());
1565 	double fTop(maRange.getMinY());
1566 	double fRight(fLeft + (double)maMtrWidth.GetValue());
1567 	double fBottom(fTop + (double)maMtrHeight.GetValue());
1568 
1569 	switch ( maCtlSize.GetActualRP() )
1570 	{
1571 		case RP_LT:
1572 		{
1573 			break;
1574 		}
1575 		case RP_MT:
1576 		{
1577 			fLeft = maRange.getMinX() - ( fRight - maRange.getMaxX() ) / 2.0;
1578 			break;
1579 		}
1580 		case RP_RT:
1581 		{
1582 			fLeft = maRange.getMinX() - ( fRight - maRange.getMaxX() );
1583 			break;
1584 		}
1585 		case RP_LM:
1586 		{
1587 			fTop = maRange.getMinY() - ( fBottom - maRange.getMaxY() ) / 2.0;
1588 			break;
1589 		}
1590 		case RP_MM:
1591 		{
1592 			fLeft = maRange.getMinX() - ( fRight - maRange.getMaxX() ) / 2.0;
1593 			fTop = maRange.getMinY() - ( fBottom - maRange.getMaxY() ) / 2.0;
1594 			break;
1595 		}
1596 		case RP_RM:
1597 		{
1598 			fLeft = maRange.getMinX() - ( fRight - maRange.getMaxX() );
1599 			fTop = maRange.getMinY() - ( fBottom - maRange.getMaxY() ) / 2.0;
1600 			break;
1601 		}
1602 		case RP_LB:
1603 		{
1604 			fTop = maRange.getMinY() - ( fBottom - maRange.getMaxY() );
1605 			break;
1606 		}
1607 		case RP_MB:
1608 		{
1609 			fLeft = maRange.getMinX() - ( fRight - maRange.getMaxX() ) / 2.0;
1610 			fTop = maRange.getMinY() - ( fBottom - maRange.getMaxY() );
1611 			break;
1612 		}
1613 		case RP_RB:
1614 		{
1615 			fLeft = maRange.getMinX() - ( fRight - maRange.getMaxX() );
1616 			fTop = maRange.getMinY() - ( fBottom - maRange.getMaxY() );
1617 			break;
1618 		}
1619 	}
1620 
1621 	return Rectangle(basegfx::fround(fLeft), basegfx::fround(fTop), basegfx::fround(fRight), basegfx::fround(fBottom));
1622 }
1623 
1624 //------------------------------------------------------------------------
1625 
IMPL_LINK(SvxPositionSizeTabPage,ChangeWidthHdl,void *,EMPTYARG)1626 IMPL_LINK( SvxPositionSizeTabPage, ChangeWidthHdl, void *, EMPTYARG )
1627 {
1628 	if( maCbxScale.IsChecked() && maCbxScale.IsEnabled() )
1629 	{
1630 		sal_Int64 nHeight(basegfx::fround64((mfOldHeight * (double)maMtrWidth.GetValue()) / mfOldWidth));
1631 
1632 		if(nHeight <= maMtrHeight.GetMax(FUNIT_NONE))
1633 		{
1634 			maMtrHeight.SetUserValue(nHeight, FUNIT_NONE);
1635 		}
1636 		else
1637 		{
1638 			nHeight = maMtrHeight.GetMax(FUNIT_NONE);
1639 			maMtrHeight.SetUserValue(nHeight);
1640 
1641 			const sal_Int64 nWidth(basegfx::fround64((mfOldWidth * (double)nHeight) / mfOldHeight));
1642 			maMtrWidth.SetUserValue(nWidth, FUNIT_NONE);
1643 		}
1644 	}
1645 
1646 	return( 0L );
1647 }
1648 
1649 //------------------------------------------------------------------------
1650 
IMPL_LINK(SvxPositionSizeTabPage,ChangeHeightHdl,void *,EMPTYARG)1651 IMPL_LINK( SvxPositionSizeTabPage, ChangeHeightHdl, void *, EMPTYARG )
1652 {
1653 	if( maCbxScale.IsChecked() && maCbxScale.IsEnabled() )
1654 	{
1655 		sal_Int64 nWidth(basegfx::fround64((mfOldWidth * (double)maMtrHeight.GetValue()) / mfOldHeight));
1656 
1657 		if(nWidth <= maMtrWidth.GetMax(FUNIT_NONE))
1658 		{
1659 			maMtrWidth.SetUserValue(nWidth, FUNIT_NONE);
1660 		}
1661 		else
1662 		{
1663 			nWidth = maMtrWidth.GetMax(FUNIT_NONE);
1664 			maMtrWidth.SetUserValue(nWidth);
1665 
1666 			const sal_Int64 nHeight(basegfx::fround64((mfOldHeight * (double)nWidth) / mfOldWidth));
1667 			maMtrHeight.SetUserValue(nHeight, FUNIT_NONE);
1668 		}
1669 	}
1670 
1671 	return( 0L );
1672 }
1673 
1674 //------------------------------------------------------------------------
1675 
IMPL_LINK(SvxPositionSizeTabPage,ClickSizeProtectHdl,void *,EMPTYARG)1676 IMPL_LINK( SvxPositionSizeTabPage, ClickSizeProtectHdl, void *, EMPTYARG )
1677 {
1678 	UpdateControlStates();
1679 	return( 0L );
1680 }
1681 
1682 //------------------------------------------------------------------------
1683 
IMPL_LINK(SvxPositionSizeTabPage,ClickAutoHdl,void *,EMPTYARG)1684 IMPL_LINK( SvxPositionSizeTabPage, ClickAutoHdl, void *, EMPTYARG )
1685 {
1686 	if( maCbxScale.IsChecked() )
1687 	{
1688 		mfOldWidth  = std::max( (double)GetCoreValue( maMtrWidth,  mePoolUnit ), 1.0 );
1689 		mfOldHeight = std::max( (double)GetCoreValue( maMtrHeight, mePoolUnit ), 1.0 );
1690 	}
1691 
1692 	return( 0L );
1693 }
1694 
1695 //------------------------------------------------------------------------
1696 
FillUserData()1697 void SvxPositionSizeTabPage::FillUserData()
1698 {
1699 	// Abgleich wird in der Ini-Datei festgehalten
1700 	UniString aStr = UniString::CreateFromInt32( (sal_Int32) maCbxScale.IsChecked() );
1701 	SetUserData( aStr );
1702 }
1703 
1704 // eof
1705