cui/source/tabpages/measure.cxx

   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 <cuires.hrc>
  21 #include <dialmgr.hxx>
  22 #include <sfx2/app.hxx>
  23 #include <sfx2/module.hxx>
  24 #include <sfx2/request.hxx>
  25 #include <vcl/settings.hxx>
  26
  27 #include <svx/dialmgr.hxx>
  28 #include <svx/dialogs.hrc>
  29 #include <svx/dlgutil.hxx>
  30 #include <svx/measctrl.hxx>
  31 #include <svx/ofaitem.hxx>
  32 #include <svx/strarray.hxx>
  33 #include <svx/svdattr.hxx>
  34 #include <svx/svdomeas.hxx>
  35 #include <svx/svdview.hxx>
  36 #include <svx/sxekitm.hxx>
  37 #include <svx/sxelditm.hxx>
  38 #include <svx/sxenditm.hxx>
  39 #include <svx/sxmbritm.hxx>
  40 #include <svx/sxmfsitm.hxx>
  41 #include <svx/sxmlhitm.hxx>
  42 #include <svx/sxmsuitm.hxx>
  43 #include <svx/sxmtfitm.hxx>
  44 #include <svx/sxmtpitm.hxx>
  45 #include <svx/sxmtritm.hxx>
  46 #include <svx/sxmuitm.hxx>
  47
  48 #include "measure.hxx"
  49
  50 const sal_uInt16 SvxMeasurePage::pRanges[] =
  51 {
  52     SDRATTR_MEASURE_FIRST,
  53     SDRATTR_MEASURE_LAST,
  54     0
  55 };
  56
  57 /*************************************************************************
  58 |*
  59 |* Dialog to change measure-attributes
  60 |*
  61 \************************************************************************/
  62
  63 SvxMeasureDialog::SvxMeasureDialog( vcl::Window* pParent, const SfxItemSet& rInAttrs,
  64                                 const SdrView* pSdrView )
  65     : SfxSingleTabDialog(pParent, rInAttrs)
  66 {
  67     VclPtrInstance<SvxMeasurePage> _pPage( get_content_area(), rInAttrs );
  68
  69     _pPage->SetView( pSdrView );
  70     _pPage->Construct();
  71
  72     SetTabPage(_pPage );
  73     SetText(CUI_RESSTR(RID_SVXSTR_DIMENSION_LINE));
  74 }
  75
  76 /*************************************************************************
  77 |*
  78 |* Tabpage for changing measure-attributes
  79 |*
  80 \************************************************************************/
  81
  82 SvxMeasurePage::SvxMeasurePage( vcl::Window* pWindow, const SfxItemSet& rInAttrs ) :
  83                 SvxTabPage      ( pWindow
  84                                  ,"DimensionLinesTabPage"
  85                                  ,"cui/ui/dimensionlinestabpage.ui"
  86                                  ,rInAttrs ),
  87         rOutAttrs               ( rInAttrs ),
  88         aAttrSet                ( *rInAttrs.GetPool() ),
  89         pView( 0 ),
  90         eUnit( SFX_MAPUNIT_100TH_MM ),
  91         bPositionModified       ( false )
  92 {
  93     get(m_pMtrFldLineDist, "MTR_LINE_DIST");
  94     get(m_pMtrFldHelplineOverhang, "MTR_FLD_HELPLINE_OVERHANG");
  95     get(m_pMtrFldHelplineDist, "MTR_FLD_HELPLINE_DIST");
  96     get(m_pMtrFldHelpline1Len, "MTR_FLD_HELPLINE1_LEN");
  97     get(m_pMtrFldHelpline2Len, "MTR_FLD_HELPLINE2_LEN");
  98     get(m_pTsbBelowRefEdge, "TSB_BELOW_REF_EDGE");
  99     get(m_pMtrFldDecimalPlaces, "MTR_FLD_DECIMALPLACES");
 100
 101     get(m_pCtlPosition, "CTL_POSITION");
 102     get(m_pTsbAutoPosV, "TSB_AUTOPOSV");
 103     get(m_pTsbAutoPosH, "TSB_AUTOPOSH");
 104     get(m_pTsbShowUnit, "TSB_SHOW_UNIT");
 105     get(m_pLbUnit, "LB_UNIT");
 106     get(m_pTsbParallel, "TSB_PARALLEL");
 107
 108     get(m_pCtlPreview, "CTL_PREVIEW");
 109     m_pCtlPreview->SetAttributes(rInAttrs);
 110
 111     get(m_pFtAutomatic,"STR_MEASURE_AUTOMATIC");
 112
 113     FillUnitLB();
 114
 115     const FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs );
 116     SetFieldUnit( *m_pMtrFldLineDist, eFUnit );
 117     SetFieldUnit( *m_pMtrFldHelplineOverhang, eFUnit );
 118     SetFieldUnit( *m_pMtrFldHelplineDist, eFUnit );
 119     SetFieldUnit( *m_pMtrFldHelpline1Len, eFUnit );
 120     SetFieldUnit( *m_pMtrFldHelpline2Len, eFUnit );
 121     if( eFUnit == FUNIT_MM )
 122     {
 123         m_pMtrFldLineDist->SetSpinSize( 50 );
 124         m_pMtrFldHelplineOverhang->SetSpinSize( 50 );
 125         m_pMtrFldHelplineDist->SetSpinSize( 50 );
 126         m_pMtrFldHelpline1Len->SetSpinSize( 50 );
 127         m_pMtrFldHelpline2Len->SetSpinSize( 50 );
 128     }
 129
 130     m_pTsbAutoPosV->SetClickHdl( LINK( this, SvxMeasurePage, ClickAutoPosHdl_Impl ) );
 131     m_pTsbAutoPosH->SetClickHdl( LINK( this, SvxMeasurePage, ClickAutoPosHdl_Impl ) );
 132
 133     // set background and border of iconchoicectrl
 134     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 135     m_pCtlPreview->SetBackground ( rStyles.GetWindowColor() );
 136     m_pCtlPreview->SetBorderStyle(WindowBorderStyle::MONO);
 137
 138     Link<> aLink( LINK( this, SvxMeasurePage, ChangeAttrHdl_Impl ) );
 139     m_pMtrFldLineDist->SetModifyHdl( aLink );
 140     m_pMtrFldHelplineOverhang->SetModifyHdl( aLink );
 141     m_pMtrFldHelplineDist->SetModifyHdl( aLink );
 142     m_pMtrFldHelpline1Len->SetModifyHdl( aLink );
 143     m_pMtrFldHelpline2Len->SetModifyHdl( aLink );
 144     m_pMtrFldDecimalPlaces->SetModifyHdl( aLink );
 145     m_pTsbBelowRefEdge->SetClickHdl( aLink );
 146     m_pTsbParallel->SetClickHdl( aLink );
 147     m_pTsbShowUnit->SetClickHdl( aLink );
 148     m_pLbUnit->SetSelectHdl( aLink );
 149 }
 150
 151 SvxMeasurePage::~SvxMeasurePage()
 152 {
 153     disposeOnce();
 154 }
 155
 156 void SvxMeasurePage::dispose()
 157 {
 158     m_pMtrFldLineDist.clear();
 159     m_pMtrFldHelplineOverhang.clear();
 160     m_pMtrFldHelplineDist.clear();
 161     m_pMtrFldHelpline1Len.clear();
 162     m_pMtrFldHelpline2Len.clear();
 163     m_pTsbBelowRefEdge.clear();
 164     m_pMtrFldDecimalPlaces.clear();
 165     m_pCtlPosition.clear();
 166     m_pTsbAutoPosV.clear();
 167     m_pTsbAutoPosH.clear();
 168     m_pTsbShowUnit.clear();
 169     m_pLbUnit.clear();
 170     m_pTsbParallel.clear();
 171     m_pFtAutomatic.clear();
 172     m_pCtlPreview.clear();
 173     SvxTabPage::dispose();
 174 }
 175
 176 /*************************************************************************
 177 |*
 178 |* read the delivered Item-Set
 179 |*
 180 \************************************************************************/
 181
 182 void SvxMeasurePage::Reset( const SfxItemSet* rAttrs )
 183 {
 184     SfxItemPool* pPool = rAttrs->GetPool();
 185     DBG_ASSERT( pPool, "Wo ist der Pool" );
 186     eUnit = pPool->GetMetric( SDRATTR_MEASURELINEDIST );
 187
 188     const SfxPoolItem* pItem = GetItem( *rAttrs, SDRATTR_MEASURELINEDIST );
 189
 190     // SdrMeasureLineDistItem
 191     if( pItem == NULL )
 192         pItem = &pPool->GetDefaultItem( SDRATTR_MEASURELINEDIST );
 193     if( pItem )
 194     {
 195         long nValue = static_cast<const SdrMetricItem*>( pItem )->GetValue();
 196         SetMetricValue( *m_pMtrFldLineDist, nValue, eUnit );
 197     }
 198     else
 199     {
 200         m_pMtrFldLineDist->SetText( OUString() );
 201     }
 202     m_pMtrFldLineDist->SaveValue();
 203
 204     // SdrMeasureHelplineOverhangItem
 205     pItem = GetItem( *rAttrs, SDRATTR_MEASUREHELPLINEOVERHANG );
 206     if( pItem == NULL )
 207         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINEOVERHANG );
 208     if( pItem )
 209     {
 210         long nValue = static_cast<const SdrMetricItem*>( pItem )->GetValue();
 211         SetMetricValue( *m_pMtrFldHelplineOverhang, nValue, eUnit );
 212     }
 213     else
 214     {
 215         m_pMtrFldHelplineOverhang->SetText( OUString() );
 216     }
 217     m_pMtrFldHelplineOverhang->SaveValue();
 218
 219     // SdrMeasureHelplineDistItem
 220     pItem = GetItem( *rAttrs, SDRATTR_MEASUREHELPLINEDIST );
 221     if( pItem == NULL )
 222         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINEDIST );
 223     if( pItem )
 224     {
 225         long nValue = static_cast<const SdrMetricItem*>( pItem )->GetValue();
 226         SetMetricValue( *m_pMtrFldHelplineDist, nValue, eUnit );
 227     }
 228     else
 229     {
 230         m_pMtrFldHelplineDist->SetText( OUString() );
 231     }
 232     m_pMtrFldHelplineDist->SaveValue();
 233
 234     // SdrMeasureHelpline1LenItem
 235     pItem = GetItem( *rAttrs, SDRATTR_MEASUREHELPLINE1LEN );
 236     if( pItem == NULL )
 237         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINE1LEN );
 238     if( pItem )
 239     {
 240         long nValue = static_cast<const SdrMetricItem*>( pItem )->GetValue();
 241         SetMetricValue( *m_pMtrFldHelpline1Len, nValue, eUnit );
 242     }
 243     else
 244     {
 245         m_pMtrFldHelpline1Len->SetText( OUString() );
 246     }
 247     m_pMtrFldHelpline1Len->SaveValue();
 248
 249     // SdrMeasureHelpline2LenItem
 250     pItem = GetItem( *rAttrs, SDRATTR_MEASUREHELPLINE2LEN );
 251     if( pItem == NULL )
 252         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINE2LEN );
 253     if( pItem )
 254     {
 255         long nValue = static_cast<const SdrMetricItem*>( pItem )->GetValue();
 256         SetMetricValue( *m_pMtrFldHelpline2Len, nValue, eUnit );
 257     }
 258     else
 259     {
 260         m_pMtrFldHelpline2Len->SetText( OUString() );
 261     }
 262     m_pMtrFldHelpline2Len->SaveValue();
 263
 264     // SdrMeasureBelowRefEdgeItem
 265     if( rAttrs->GetItemState( SDRATTR_MEASUREBELOWREFEDGE ) != SfxItemState::DONTCARE )
 266     {
 267         m_pTsbBelowRefEdge->SetState( static_cast<const SdrMeasureBelowRefEdgeItem&>( rAttrs->Get( SDRATTR_MEASUREBELOWREFEDGE ) ).
 268                         GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE );
 269         m_pTsbBelowRefEdge->EnableTriState( false );
 270     }
 271     else
 272     {
 273         m_pTsbBelowRefEdge->SetState( TRISTATE_INDET );
 274     }
 275     m_pTsbBelowRefEdge->SaveValue();
 276
 277     // SdrMeasureDecimalPlacesItem
 278     pItem = GetItem( *rAttrs, SDRATTR_MEASUREDECIMALPLACES );
 279     if( pItem == NULL )
 280         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREDECIMALPLACES );
 281     if( pItem )
 282     {
 283         sal_Int16 nValue = static_cast<const SdrMeasureDecimalPlacesItem*>( pItem )->GetValue();
 284         m_pMtrFldDecimalPlaces->SetValue( nValue );
 285     }
 286     else
 287     {
 288         m_pMtrFldDecimalPlaces->SetText( OUString() );
 289     }
 290     m_pMtrFldDecimalPlaces->SaveValue();
 291
 292     // SdrMeasureTextRota90Item
 293     // Attention: negate !
 294     if( rAttrs->GetItemState( SDRATTR_MEASURETEXTROTA90 ) != SfxItemState::DONTCARE )
 295     {
 296         m_pTsbParallel->SetState( static_cast<const SdrMeasureTextRota90Item&>( rAttrs->Get( SDRATTR_MEASURETEXTROTA90 ) ).
 297                         GetValue() ? TRISTATE_FALSE : TRISTATE_TRUE );
 298         m_pTsbParallel->EnableTriState( false );
 299     }
 300     else
 301     {
 302         m_pTsbParallel->SetState( TRISTATE_INDET );
 303     }
 304     m_pTsbParallel->SaveValue();
 305
 306     // SdrMeasureShowUnitItem
 307     if( rAttrs->GetItemState( SDRATTR_MEASURESHOWUNIT ) != SfxItemState::DONTCARE )
 308     {
 309         m_pTsbShowUnit->SetState( static_cast<const SdrYesNoItem&>( rAttrs->Get( SDRATTR_MEASURESHOWUNIT ) ).
 310                         GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE );
 311         m_pTsbShowUnit->EnableTriState( false );
 312     }
 313     else
 314     {
 315         m_pTsbShowUnit->SetState( TRISTATE_INDET );
 316     }
 317     m_pTsbShowUnit->SaveValue();
 318
 319     // SdrMeasureUnitItem
 320     if( rAttrs->GetItemState( SDRATTR_MEASUREUNIT ) != SfxItemState::DONTCARE )
 321     {
 322         long nFieldUnit = (long) static_cast<const SdrMeasureUnitItem&>( rAttrs->
 323                                     Get( SDRATTR_MEASUREUNIT ) ).GetValue();
 324
 325         for( sal_Int32 i = 0; i < m_pLbUnit->GetEntryCount(); ++i )
 326         {
 327             if ( reinterpret_cast<sal_IntPtr>(m_pLbUnit->GetEntryData( i )) == nFieldUnit )
 328             {
 329                 m_pLbUnit->SelectEntryPos( i );
 330                 break;
 331             }
 332         }
 333     }
 334     else
 335     {
 336         m_pLbUnit->SetNoSelection();
 337     }
 338     m_pLbUnit->SaveValue();
 339
 340     // Position
 341     if ( rAttrs->GetItemState( SDRATTR_MEASURETEXTVPOS ) != SfxItemState::DONTCARE )
 342     {
 343         SdrMeasureTextVPos eVPos = (SdrMeasureTextVPos)
 344                     static_cast<const SdrMeasureTextVPosItem&>( rAttrs->Get( SDRATTR_MEASURETEXTVPOS ) ).GetValue();
 345         {
 346             if ( rAttrs->GetItemState( SDRATTR_MEASURETEXTHPOS ) != SfxItemState::DONTCARE )
 347             {
 348                 m_pTsbAutoPosV->EnableTriState( false );
 349                 m_pTsbAutoPosH->EnableTriState( false );
 350
 351                 SdrMeasureTextHPos eHPos = (SdrMeasureTextHPos)
 352                             static_cast<const SdrMeasureTextHPosItem&>( rAttrs->Get( SDRATTR_MEASURETEXTHPOS ) ).GetValue();
 353                 RECT_POINT eRP = RP_MM;
 354                 switch( eVPos )
 355                 {
 356                 case SDRMEASURE_ABOVE:
 357                     switch( eHPos )
 358                     {
 359                     case SDRMEASURE_TEXTLEFTOUTSIDE:    eRP = RP_LT; break;
 360                     case SDRMEASURE_TEXTINSIDE:         eRP = RP_MT; break;
 361                     case SDRMEASURE_TEXTRIGHTOUTSIDE:   eRP = RP_RT; break;
 362                     case SDRMEASURE_TEXTHAUTO:          eRP = RP_MT; break;
 363                     }
 364                     break;
 365                 case SDRMEASURETEXT_VERTICALCENTERED:
 366                     switch( eHPos )
 367                     {
 368                     case SDRMEASURE_TEXTLEFTOUTSIDE:    eRP = RP_LM; break;
 369                     case SDRMEASURE_TEXTINSIDE:         eRP = RP_MM; break;
 370                     case SDRMEASURE_TEXTRIGHTOUTSIDE:   eRP = RP_RM; break;
 371                     case SDRMEASURE_TEXTHAUTO:          eRP = RP_MM; break;
 372                     }
 373                     break;
 374                 case SDRMEASURE_BELOW:
 375                     switch( eHPos )
 376                     {
 377                     case SDRMEASURE_TEXTLEFTOUTSIDE:    eRP = RP_LB; break;
 378                     case SDRMEASURE_TEXTINSIDE:         eRP = RP_MB; break;
 379                     case SDRMEASURE_TEXTRIGHTOUTSIDE:   eRP = RP_RB; break;
 380                     case SDRMEASURE_TEXTHAUTO:          eRP = RP_MB; break;
 381                     }
 382                     break;
 383                 case SDRMEASURE_TEXTVAUTO:
 384                     switch( eHPos )
 385                     {
 386                     case SDRMEASURE_TEXTLEFTOUTSIDE:    eRP = RP_LM; break;
 387                     case SDRMEASURE_TEXTINSIDE:         eRP = RP_MM; break;
 388                     case SDRMEASURE_TEXTRIGHTOUTSIDE:   eRP = RP_RM; break;
 389                     case SDRMEASURE_TEXTHAUTO:          eRP = RP_MM; break;
 390                     }
 391                     break;
 392                  default: ;//prevent warning
 393                 }
 394
 395                 CTL_STATE nState = CTL_STATE::NONE;
 396
 397                 if( eHPos == SDRMEASURE_TEXTHAUTO )
 398                 {
 399                     m_pTsbAutoPosH->SetState( TRISTATE_TRUE );
 400                     nState = CTL_STATE::NOHORZ;
 401                 }
 402
 403                 if( eVPos == SDRMEASURE_TEXTVAUTO )
 404                 {
 405                     m_pTsbAutoPosV->SetState( TRISTATE_TRUE );
 406                     nState |= CTL_STATE::NOVERT;
 407                 }
 408
 409                 m_pCtlPosition->SetState( nState );
 410                 m_pCtlPosition->SetActualRP( eRP );
 411             }
 412         }
 413     }
 414     else
 415     {
 416         m_pCtlPosition->Reset();
 417         m_pTsbAutoPosV->SetState( TRISTATE_INDET );
 418         m_pTsbAutoPosH->SetState( TRISTATE_INDET );
 419     }
 420
 421     // put the attributes to the preview-control,
 422     // otherwise the control don't know about
 423     // the settings of the dialog (#67930)
 424     ChangeAttrHdl_Impl( m_pTsbShowUnit );
 425     m_pCtlPreview->SetAttributes( *rAttrs );
 426
 427     bPositionModified = false;
 428 }
 429
 430 /*************************************************************************
 431 |*
 432 |* Fill the delivered Item-Set with dialogbox-attributes
 433 |*
 434 \************************************************************************/
 435
 436 bool SvxMeasurePage::FillItemSet( SfxItemSet* rAttrs)
 437 {
 438     bool     bModified = false;
 439     sal_Int32    nValue;
 440     TriState eState;
 441
 442     if( m_pMtrFldLineDist->IsValueChangedFromSaved() )
 443     {
 444         nValue = GetCoreValue( *m_pMtrFldLineDist, eUnit );
 445         rAttrs->Put( makeSdrMeasureLineDistItem( nValue ) );
 446         bModified = true;
 447     }
 448
 449     if( m_pMtrFldHelplineOverhang->IsValueChangedFromSaved() )
 450     {
 451         nValue = GetCoreValue( *m_pMtrFldHelplineOverhang, eUnit );
 452         rAttrs->Put( makeSdrMeasureHelplineOverhangItem( nValue ) );
 453         bModified = true;
 454     }
 455
 456     if( m_pMtrFldHelplineDist->IsValueChangedFromSaved() )
 457     {
 458         nValue = GetCoreValue( *m_pMtrFldHelplineDist, eUnit );
 459         rAttrs->Put( makeSdrMeasureHelplineDistItem( nValue ) );
 460         bModified = true;
 461     }
 462
 463     if( m_pMtrFldHelpline1Len->IsValueChangedFromSaved() )
 464     {
 465         nValue = GetCoreValue( *m_pMtrFldHelpline1Len, eUnit );
 466         rAttrs->Put( makeSdrMeasureHelpline1LenItem( nValue ) );
 467         bModified = true;
 468     }
 469
 470     if( m_pMtrFldHelpline2Len->IsValueChangedFromSaved() )
 471     {
 472         nValue = GetCoreValue( *m_pMtrFldHelpline2Len, eUnit );
 473         rAttrs->Put( makeSdrMeasureHelpline2LenItem( nValue ) );
 474         bModified = true;
 475     }
 476
 477     eState = m_pTsbBelowRefEdge->GetState();
 478     if( m_pTsbBelowRefEdge->IsValueChangedFromSaved() )
 479     {
 480         rAttrs->Put( SdrMeasureBelowRefEdgeItem( TRISTATE_TRUE == eState ) );
 481         bModified = true;
 482     }
 483
 484     if( m_pMtrFldDecimalPlaces->IsValueChangedFromSaved() )
 485     {
 486         nValue = static_cast<sal_Int32>(m_pMtrFldDecimalPlaces->GetValue());
 487         rAttrs->Put(
 488             SdrMeasureDecimalPlacesItem(
 489                 sal::static_int_cast< sal_Int16 >( nValue ) ) );
 490         bModified = true;
 491     }
 492
 493     eState = m_pTsbParallel->GetState();
 494     if( m_pTsbParallel->IsValueChangedFromSaved() )
 495     {
 496         rAttrs->Put( SdrMeasureTextRota90Item( TRISTATE_FALSE == eState ) );
 497         bModified = true;
 498     }
 499
 500     eState = m_pTsbShowUnit->GetState();
 501     if( m_pTsbShowUnit->IsValueChangedFromSaved() )
 502     {
 503         rAttrs->Put( makeSdrMeasureShowUnitItem( TRISTATE_TRUE == eState ) );
 504         bModified = true;
 505     }
 506
 507     sal_Int32 nPos = m_pLbUnit->GetSelectEntryPos();
 508     if( m_pLbUnit->IsValueChangedFromSaved() )
 509     {
 510         if( nPos != LISTBOX_ENTRY_NOTFOUND )
 511         {
 512             sal_uInt16 nFieldUnit = (sal_uInt16)reinterpret_cast<sal_IntPtr>(m_pLbUnit->GetEntryData( nPos ));
 513             FieldUnit _eUnit = (FieldUnit) nFieldUnit;
 514             rAttrs->Put( SdrMeasureUnitItem( _eUnit ) );
 515             bModified = true;
 516         }
 517     }
 518
 519     if( bPositionModified )
 520     {
 521         // Position
 522         SdrMeasureTextVPos eVPos, eOldVPos;
 523         SdrMeasureTextHPos eHPos, eOldHPos;
 524
 525         RECT_POINT eRP = m_pCtlPosition->GetActualRP();
 526         switch( eRP )
 527         {
 528             default:
 529             case RP_LT: eVPos = SDRMEASURE_ABOVE;
 530                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 531             case RP_LM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 532                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 533             case RP_LB: eVPos = SDRMEASURE_BELOW;
 534                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 535             case RP_MT: eVPos = SDRMEASURE_ABOVE;
 536                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 537             case RP_MM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 538                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 539             case RP_MB: eVPos = SDRMEASURE_BELOW;
 540                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 541             case RP_RT: eVPos = SDRMEASURE_ABOVE;
 542                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 543             case RP_RM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 544                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 545             case RP_RB: eVPos = SDRMEASURE_BELOW;
 546                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 547         }
 548         if( m_pTsbAutoPosH->GetState() == TRISTATE_TRUE )
 549             eHPos = SDRMEASURE_TEXTHAUTO;
 550
 551         if( m_pTsbAutoPosV->GetState() == TRISTATE_TRUE )
 552             eVPos = SDRMEASURE_TEXTVAUTO;
 553
 554         if ( rAttrs->GetItemState( SDRATTR_MEASURETEXTVPOS ) != SfxItemState::DONTCARE )
 555         {
 556             eOldVPos = (SdrMeasureTextVPos)
 557                         static_cast<const SdrMeasureTextVPosItem&>( rOutAttrs.Get( SDRATTR_MEASURETEXTVPOS ) ).GetValue();
 558             if( eOldVPos != eVPos )
 559             {
 560                 rAttrs->Put( SdrMeasureTextVPosItem( eVPos ) );
 561                 bModified = true;
 562             }
 563         }
 564         else
 565         {
 566             rAttrs->Put( SdrMeasureTextVPosItem( eVPos ) );
 567             bModified = true;
 568         }
 569
 570         if ( rAttrs->GetItemState( SDRATTR_MEASURETEXTHPOS ) != SfxItemState::DONTCARE )
 571         {
 572             eOldHPos = (SdrMeasureTextHPos)
 573                         static_cast<const SdrMeasureTextHPosItem&>( rOutAttrs.Get( SDRATTR_MEASURETEXTHPOS ) ).GetValue();
 574             if( eOldHPos != eHPos )
 575             {
 576                 rAttrs->Put( SdrMeasureTextHPosItem( eHPos ) );
 577                 bModified = true;
 578             }
 579         }
 580         else
 581         {
 582             rAttrs->Put( SdrMeasureTextHPosItem( eHPos ) );
 583             bModified = true;
 584         }
 585     }
 586
 587     return bModified;
 588 }
 589
 590 /*************************************************************************
 591 |*
 592 |* The View have to set at the measure-object to be able to notify
 593 |* unit and floatingpoint-values
 594 |*
 595 \************************************************************************/
 596
 597 void SvxMeasurePage::Construct()
 598 {
 599     DBG_ASSERT( pView, "Keine gueltige View Uebergeben!" );
 600
 601     m_pCtlPreview->pMeasureObj->SetModel( pView->GetModel() );
 602     m_pCtlPreview->Invalidate();
 603 }
 604
 605 VclPtr<SfxTabPage> SvxMeasurePage::Create( vcl::Window* pWindow,
 606                                            const SfxItemSet* rAttrs )
 607 {
 608     return VclPtr<SvxMeasurePage>::Create( pWindow, *rAttrs );
 609 }
 610
 611 void SvxMeasurePage::PointChanged( vcl::Window* pWindow, RECT_POINT /*eRP*/ )
 612 {
 613     ChangeAttrHdl_Impl( pWindow );
 614 }
 615
 616 IMPL_LINK( SvxMeasurePage, ClickAutoPosHdl_Impl, void *, p )
 617 {
 618     if( m_pTsbAutoPosH->GetState() == TRISTATE_TRUE )
 619     {
 620         switch( m_pCtlPosition->GetActualRP() )
 621         {
 622             case RP_LT:
 623             case RP_RT:
 624                 m_pCtlPosition->SetActualRP( RP_MT );
 625             break;
 626
 627             case RP_LM:
 628             case RP_RM:
 629                 m_pCtlPosition->SetActualRP( RP_MM );
 630             break;
 631
 632             case RP_LB:
 633             case RP_RB:
 634                 m_pCtlPosition->SetActualRP( RP_MB );
 635             break;
 636             default: ;//prevent warning
 637         }
 638     }
 639     if( m_pTsbAutoPosV->GetState() == TRISTATE_TRUE )
 640     {
 641         switch( m_pCtlPosition->GetActualRP() )
 642         {
 643             case RP_LT:
 644             case RP_LB:
 645                 m_pCtlPosition->SetActualRP( RP_LM );
 646             break;
 647
 648             case RP_MT:
 649             case RP_MB:
 650                 m_pCtlPosition->SetActualRP( RP_MM );
 651             break;
 652
 653             case RP_RT:
 654             case RP_RB:
 655                 m_pCtlPosition->SetActualRP( RP_RM );
 656             break;
 657             default: ;//prevent warning
 658         }
 659     }
 660     ChangeAttrHdl_Impl( p );
 661
 662     return 0L;
 663 }
 664
 665 IMPL_LINK( SvxMeasurePage, ChangeAttrHdl_Impl, void *, p )
 666 {
 667
 668     if( p == m_pMtrFldLineDist )
 669     {
 670         sal_Int32 nValue = GetCoreValue( *m_pMtrFldLineDist, eUnit );
 671         aAttrSet.Put( makeSdrMeasureLineDistItem( nValue ) );
 672     }
 673
 674     if( p == m_pMtrFldHelplineOverhang )
 675     {
 676         sal_Int32 nValue = GetCoreValue( *m_pMtrFldHelplineOverhang, eUnit );
 677         aAttrSet.Put( makeSdrMeasureHelplineOverhangItem( nValue) );
 678     }
 679
 680     if( p == m_pMtrFldHelplineDist )
 681     {
 682         sal_Int32 nValue = GetCoreValue( *m_pMtrFldHelplineDist, eUnit );
 683         aAttrSet.Put( makeSdrMeasureHelplineDistItem( nValue) );
 684     }
 685
 686     if( p == m_pMtrFldHelpline1Len )
 687     {
 688         sal_Int32 nValue = GetCoreValue( *m_pMtrFldHelpline1Len, eUnit );
 689         aAttrSet.Put( makeSdrMeasureHelpline1LenItem( nValue ) );
 690     }
 691
 692     if( p == m_pMtrFldHelpline2Len )
 693     {
 694         sal_Int32 nValue = GetCoreValue( *m_pMtrFldHelpline2Len, eUnit );
 695         aAttrSet.Put( makeSdrMeasureHelpline2LenItem( nValue ) );
 696     }
 697
 698     if( p == m_pTsbBelowRefEdge )
 699     {
 700         TriState eState = m_pTsbBelowRefEdge->GetState();
 701         if( eState != TRISTATE_INDET )
 702             aAttrSet.Put( SdrMeasureBelowRefEdgeItem( TRISTATE_TRUE == eState ) );
 703     }
 704
 705     if( p == m_pMtrFldDecimalPlaces )
 706     {
 707         sal_Int16 nValue = sal::static_int_cast< sal_Int16 >(
 708             m_pMtrFldDecimalPlaces->GetValue() );
 709         aAttrSet.Put( SdrMeasureDecimalPlacesItem( nValue ) );
 710     }
 711
 712     if( p == m_pTsbParallel )
 713     {
 714         TriState eState = m_pTsbParallel->GetState();
 715         if( eState != TRISTATE_INDET )
 716             aAttrSet.Put( SdrMeasureTextRota90Item( TRISTATE_FALSE == eState ) );
 717     }
 718
 719     if( p == m_pTsbShowUnit )
 720     {
 721         TriState eState = m_pTsbShowUnit->GetState();
 722         if( eState != TRISTATE_INDET )
 723             aAttrSet.Put( makeSdrMeasureShowUnitItem( TRISTATE_TRUE == eState ) );
 724     }
 725
 726     if( p == m_pLbUnit )
 727     {
 728         sal_Int32 nPos = m_pLbUnit->GetSelectEntryPos();
 729         if( nPos != LISTBOX_ENTRY_NOTFOUND )
 730         {
 731             sal_uInt16 nFieldUnit = (sal_uInt16)reinterpret_cast<sal_IntPtr>(m_pLbUnit->GetEntryData( nPos ));
 732             FieldUnit _eUnit = (FieldUnit) nFieldUnit;
 733             aAttrSet.Put( SdrMeasureUnitItem( _eUnit ) );
 734         }
 735     }
 736
 737     if( p == m_pTsbAutoPosV || p == m_pTsbAutoPosH || p == m_pCtlPosition )
 738     {
 739         bPositionModified = true;
 740
 741         // Position
 742         RECT_POINT eRP = m_pCtlPosition->GetActualRP();
 743         SdrMeasureTextVPos eVPos;
 744         SdrMeasureTextHPos eHPos;
 745
 746         switch( eRP )
 747         {
 748             default:
 749             case RP_LT: eVPos = SDRMEASURE_ABOVE;
 750                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 751             case RP_LM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 752                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 753             case RP_LB: eVPos = SDRMEASURE_BELOW;
 754                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 755             case RP_MT: eVPos = SDRMEASURE_ABOVE;
 756                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 757             case RP_MM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 758                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 759             case RP_MB: eVPos = SDRMEASURE_BELOW;
 760                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 761             case RP_RT: eVPos = SDRMEASURE_ABOVE;
 762                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 763             case RP_RM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 764                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 765             case RP_RB: eVPos = SDRMEASURE_BELOW;
 766                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 767         }
 768
 769         CTL_STATE nState = CTL_STATE::NONE;
 770
 771         if( m_pTsbAutoPosH->GetState() == TRISTATE_TRUE )
 772         {
 773             eHPos = SDRMEASURE_TEXTHAUTO;
 774             nState = CTL_STATE::NOHORZ;
 775         }
 776
 777         if( m_pTsbAutoPosV->GetState() == TRISTATE_TRUE )
 778         {
 779             eVPos = SDRMEASURE_TEXTVAUTO;
 780             nState |= CTL_STATE::NOVERT;
 781         }
 782
 783         if( p == m_pTsbAutoPosV || p == m_pTsbAutoPosH )
 784             m_pCtlPosition->SetState( nState );
 785
 786         aAttrSet.Put( SdrMeasureTextVPosItem( eVPos ) );
 787         aAttrSet.Put( SdrMeasureTextHPosItem( eHPos ) );
 788     }
 789
 790     m_pCtlPreview->SetAttributes( aAttrSet );
 791     m_pCtlPreview->Invalidate();
 792
 793     return 0L;
 794 }
 795
 796 void SvxMeasurePage::FillUnitLB()
 797 {
 798     // fill ListBox with metrics
 799     SvxStringArray aMetricArr( SVX_RES( RID_SVXSTR_FIELDUNIT_TABLE ) );
 800
 801     sal_IntPtr nUnit = FUNIT_NONE;
 802     OUString aStrMetric( m_pFtAutomatic->GetText());
 803     sal_Int32 nPos = m_pLbUnit->InsertEntry( aStrMetric );
 804     m_pLbUnit->SetEntryData( nPos, reinterpret_cast<void*>(nUnit) );
 805
 806     for( sal_uInt32 i = 0; i < aMetricArr.Count(); ++i )
 807     {
 808         aStrMetric = aMetricArr.GetStringByPos( i );
 809         nUnit = aMetricArr.GetValue( i );
 810         nPos = m_pLbUnit->InsertEntry( aStrMetric );
 811         m_pLbUnit->SetEntryData( nPos, reinterpret_cast<void*>(nUnit) );
 812     }
 813 }
 814 void SvxMeasurePage::PageCreated(const SfxAllItemSet& aSet)
 815 {
 816     SFX_ITEMSET_ARG (&aSet,pOfaPtrItem,OfaPtrItem,SID_OBJECT_LIST,false);
 817
 818     if (pOfaPtrItem)
 819         SetView( static_cast<SdrView *>(pOfaPtrItem->GetValue()));
 820
 821     Construct();
 822 }
 823
 824 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */