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