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