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