svx/source/cui/measure.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: measure.cxx,v $
  10  * $Revision: 1.18 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #ifdef SVX_DLLIMPLEMENTATION
  35 #undef SVX_DLLIMPLEMENTATION
  36 #endif
  37
  38
  39 // include ---------------------------------------------------------------
  40 #include <sfx2/app.hxx>
  41 #include <sfx2/module.hxx>
  42 #include <tools/shl.hxx>
  43
  44 #include <svx/dialogs.hrc>
  45
  46 #define _SVX_MEASURE_CXX
  47
  48 #include <svx/svdomeas.hxx>
  49 #include <svx/svdattr.hxx>
  50 #include <svx/svdattrx.hxx>
  51 #include <svx/svdview.hxx>
  52
  53 #include "measctrl.hxx"
  54 #include "measure.hxx"
  55 #include "measure.hrc"
  56 #include <svx/dialmgr.hxx>
  57 #include "dlgutil.hxx"
  58 #include <svx/strarray.hxx>
  59 #include <sfx2/request.hxx> //add CHINA001
  60 #include "ofaitem.hxx" //add CHINA001
  61
  62 static USHORT pRanges[] =
  63 {
  64     SDRATTR_MEASURE_FIRST,
  65     SDRATTR_MEASURE_LAST,
  66     0
  67 };
  68
  69 /*************************************************************************
  70 |*
  71 |* Dialog to change measure-attributes
  72 |*
  73 \************************************************************************/
  74
  75 SvxMeasureDialog::SvxMeasureDialog( Window* pParent, const SfxItemSet& rInAttrs,
  76                                 const SdrView* pSdrView ) :
  77         SfxSingleTabDialog( pParent, rInAttrs, RID_SVXPAGE_MEASURE )
  78 {
  79     SvxMeasurePage* _pPage = new SvxMeasurePage( this, rInAttrs );
  80
  81     _pPage->SetView( pSdrView );
  82     _pPage->Construct();
  83
  84     SetTabPage( _pPage );
  85     SetText( _pPage->GetText() );
  86 }
  87
  88 /*************************************************************************
  89 |*
  90 |* Dtor
  91 |*
  92 \************************************************************************/
  93
  94 SvxMeasureDialog::~SvxMeasureDialog()
  95 {
  96 }
  97
  98 /*************************************************************************
  99 |*
 100 |* Tabpage for changing measure-attributes
 101 |*
 102 \************************************************************************/
 103
 104 SvxMeasurePage::SvxMeasurePage( Window* pWindow, const SfxItemSet& rInAttrs ) :
 105                 SvxTabPage              ( pWindow, SVX_RES( RID_SVXPAGE_MEASURE ),
 106                                   rInAttrs ),
 107
 108         aFlLine                 ( this, SVX_RES( FL_LINE ) ),
 109         aFtLineDist                             ( this, SVX_RES( FT_LINE_DIST ) ),
 110         aMtrFldLineDist                 ( this, SVX_RES( MTR_LINE_DIST ) ),
 111         aFtHelplineOverhang             ( this, SVX_RES( FT_HELPLINE_OVERHANG ) ),
 112         aMtrFldHelplineOverhang ( this, SVX_RES( MTR_FLD_HELPLINE_OVERHANG ) ),
 113         aFtHelplineDist                 ( this, SVX_RES( FT_HELPLINE_DIST ) ),
 114         aMtrFldHelplineDist             ( this, SVX_RES( MTR_FLD_HELPLINE_DIST ) ),
 115         aFtHelpline1Len                 ( this, SVX_RES( FT_HELPLINE1_LEN ) ),
 116         aMtrFldHelpline1Len             ( this, SVX_RES( MTR_FLD_HELPLINE1_LEN ) ),
 117         aFtHelpline2Len                 ( this, SVX_RES( FT_HELPLINE2_LEN ) ),
 118         aMtrFldHelpline2Len             ( this, SVX_RES( MTR_FLD_HELPLINE2_LEN ) ),
 119         aTsbBelowRefEdge                ( this, SVX_RES( TSB_BELOW_REF_EDGE ) ),
 120         aFtDecimalPlaces                ( this, SVX_RES( FT_DECIMALPLACES ) ),
 121         aMtrFldDecimalPlaces    ( this, SVX_RES( MTR_FLD_DECIMALPLACES ) ),
 122
 123         aFlLabel                        ( this, SVX_RES( FL_LABEL ) ),
 124         aFtPosition             ( this, SVX_RES( FT_POSITION ) ),
 125         aCtlPosition            ( this, SVX_RES( CTL_POSITION ) ),
 126         aTsbAutoPosV            ( this, SVX_RES( TSB_AUTOPOSV ) ),
 127         aTsbAutoPosH            ( this, SVX_RES( TSB_AUTOPOSH ) ),
 128         aTsbShowUnit            ( this, SVX_RES( TSB_SHOW_UNIT ) ),
 129         aLbUnit                 ( this, SVX_RES( LB_UNIT ) ),
 130         aTsbParallel            ( this, SVX_RES( TSB_PARALLEL ) ),
 131         aCtlPreview             ( this, SVX_RES( CTL_PREVIEW ), rInAttrs ),
 132
 133         aFlVert                 ( this, SVX_RES( FL_VERT ) ),
 134         rOutAttrs               ( rInAttrs ),
 135         aAttrSet                ( *rInAttrs.GetPool() ),
 136         pView( 0 ),
 137
 138         bPositionModified       ( FALSE )
 139 {
 140     FillUnitLB();
 141
 142     FreeResource();
 143
 144     const FieldUnit eFUnit = GetModuleFieldUnit( &rInAttrs );
 145     SetFieldUnit( aMtrFldLineDist, eFUnit );
 146     SetFieldUnit( aMtrFldHelplineOverhang, eFUnit );
 147     SetFieldUnit( aMtrFldHelplineDist, eFUnit );
 148     SetFieldUnit( aMtrFldHelpline1Len, eFUnit );
 149     SetFieldUnit( aMtrFldHelpline2Len, eFUnit );
 150     if( eFUnit == FUNIT_MM )
 151     {
 152         aMtrFldLineDist.SetSpinSize( 50 );
 153         aMtrFldHelplineOverhang.SetSpinSize( 50 );
 154         aMtrFldHelplineDist.SetSpinSize( 50 );
 155         aMtrFldHelpline1Len.SetSpinSize( 50 );
 156         aMtrFldHelpline2Len.SetSpinSize( 50 );
 157     }
 158
 159     aTsbAutoPosV.SetClickHdl( LINK( this, SvxMeasurePage, ClickAutoPosHdl_Impl ) );
 160     aTsbAutoPosH.SetClickHdl( LINK( this, SvxMeasurePage, ClickAutoPosHdl_Impl ) );
 161
 162     // set background and border of iconchoicectrl
 163     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 164     aCtlPreview.SetBackground ( rStyles.GetWindowColor() );
 165     aCtlPreview.SetBorderStyle(WINDOW_BORDER_MONO);
 166
 167     Link aLink( LINK( this, SvxMeasurePage, ChangeAttrHdl_Impl ) );
 168     aMtrFldLineDist.SetModifyHdl( aLink );
 169     aMtrFldHelplineOverhang.SetModifyHdl( aLink );
 170     aMtrFldHelplineDist.SetModifyHdl( aLink );
 171     aMtrFldHelpline1Len.SetModifyHdl( aLink );
 172     aMtrFldHelpline2Len.SetModifyHdl( aLink );
 173     aMtrFldDecimalPlaces.SetModifyHdl( aLink );
 174     aTsbBelowRefEdge.SetClickHdl( aLink );
 175     aTsbParallel.SetClickHdl( aLink );
 176     aTsbShowUnit.SetClickHdl( aLink );
 177     aLbUnit.SetSelectHdl( aLink );
 178 }
 179
 180 /*************************************************************************
 181 |*
 182 |* Dtor
 183 |*
 184 \************************************************************************/
 185
 186 SvxMeasurePage::~SvxMeasurePage()
 187 {
 188 }
 189
 190 /*************************************************************************
 191 |*
 192 |* read the delivered Item-Set
 193 |*
 194 \************************************************************************/
 195
 196 void __EXPORT SvxMeasurePage::Reset( const SfxItemSet& rAttrs )
 197 {
 198     SfxItemPool* pPool = rAttrs.GetPool();
 199     DBG_ASSERT( pPool, "Wo ist der Pool" );
 200     eUnit = pPool->GetMetric( SDRATTR_MEASURELINEDIST );
 201
 202     const SfxPoolItem* pItem = GetItem( rAttrs, SDRATTR_MEASURELINEDIST );
 203
 204     // SdrMeasureLineDistItem
 205     if( pItem == NULL )
 206         pItem = &pPool->GetDefaultItem( SDRATTR_MEASURELINEDIST );
 207     if( pItem )
 208     {
 209         long nValue = ( ( const SdrMeasureLineDistItem* )pItem )->GetValue();
 210         SetMetricValue( aMtrFldLineDist, nValue, eUnit );
 211     }
 212     else
 213     {
 214         aMtrFldLineDist.SetText( String() );
 215     }
 216     aMtrFldLineDist.SaveValue();
 217
 218     // SdrMeasureHelplineOverhangItem
 219     pItem = GetItem( rAttrs, SDRATTR_MEASUREHELPLINEOVERHANG );
 220     if( pItem == NULL )
 221         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINEOVERHANG );
 222     if( pItem )
 223     {
 224         long nValue = ( ( const SdrMeasureHelplineOverhangItem* )pItem )->GetValue();
 225         SetMetricValue( aMtrFldHelplineOverhang, nValue, eUnit );
 226     }
 227     else
 228     {
 229         aMtrFldHelplineOverhang.SetText( String() );
 230     }
 231     aMtrFldHelplineOverhang.SaveValue();
 232
 233     // SdrMeasureHelplineDistItem
 234     pItem = GetItem( rAttrs, SDRATTR_MEASUREHELPLINEDIST );
 235     if( pItem == NULL )
 236         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINEDIST );
 237     if( pItem )
 238     {
 239         long nValue = ( ( const SdrMeasureHelplineDistItem* )pItem )->GetValue();
 240         SetMetricValue( aMtrFldHelplineDist, nValue, eUnit );
 241     }
 242     else
 243     {
 244         aMtrFldHelplineDist.SetText( String() );
 245     }
 246     aMtrFldHelplineDist.SaveValue();
 247
 248     // SdrMeasureHelpline1LenItem
 249     pItem = GetItem( rAttrs, SDRATTR_MEASUREHELPLINE1LEN );
 250     if( pItem == NULL )
 251         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINE1LEN );
 252     if( pItem )
 253     {
 254         long nValue = ( ( const SdrMeasureHelpline1LenItem* )pItem )->GetValue();
 255         SetMetricValue( aMtrFldHelpline1Len, nValue, eUnit );
 256     }
 257     else
 258     {
 259         aMtrFldHelpline1Len.SetText( String() );
 260     }
 261     aMtrFldHelpline1Len.SaveValue();
 262
 263     // SdrMeasureHelpline2LenItem
 264     pItem = GetItem( rAttrs, SDRATTR_MEASUREHELPLINE2LEN );
 265     if( pItem == NULL )
 266         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINE2LEN );
 267     if( pItem )
 268     {
 269         long nValue = ( ( const SdrMeasureHelpline2LenItem* )pItem )->GetValue();
 270         SetMetricValue( aMtrFldHelpline2Len, nValue, eUnit );
 271     }
 272     else
 273     {
 274         aMtrFldHelpline2Len.SetText( String() );
 275     }
 276     aMtrFldHelpline2Len.SaveValue();
 277
 278     // SdrMeasureBelowRefEdgeItem
 279     if( rAttrs.GetItemState( SDRATTR_MEASUREBELOWREFEDGE ) != SFX_ITEM_DONTCARE )
 280     {
 281         aTsbBelowRefEdge.SetState( ( ( const SdrMeasureBelowRefEdgeItem& )rAttrs.Get( SDRATTR_MEASUREBELOWREFEDGE ) ).
 282                         GetValue() ? STATE_CHECK : STATE_NOCHECK );
 283         aTsbBelowRefEdge.EnableTriState( FALSE );
 284     }
 285     else
 286     {
 287         aTsbBelowRefEdge.SetState( STATE_DONTKNOW );
 288     }
 289     aTsbBelowRefEdge.SaveValue();
 290
 291     // SdrMeasureDecimalPlacesItem
 292     pItem = GetItem( rAttrs, SDRATTR_MEASUREDECIMALPLACES );
 293     if( pItem == NULL )
 294         pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREDECIMALPLACES );
 295     if( pItem )
 296     {
 297         INT16 nValue = ( ( const SdrMeasureDecimalPlacesItem* )pItem )->GetValue();
 298         aMtrFldDecimalPlaces.SetValue( nValue );
 299     }
 300     else
 301     {
 302         aMtrFldDecimalPlaces.SetText( String() );
 303     }
 304     aMtrFldDecimalPlaces.SaveValue();
 305
 306     // SdrMeasureTextRota90Item
 307     // Attention: negate !
 308     if( rAttrs.GetItemState( SDRATTR_MEASURETEXTROTA90 ) != SFX_ITEM_DONTCARE )
 309     {
 310         aTsbParallel.SetState( ( ( const SdrMeasureTextRota90Item& )rAttrs.Get( SDRATTR_MEASURETEXTROTA90 ) ).
 311                         GetValue() ? STATE_NOCHECK : STATE_CHECK );
 312         aTsbParallel.EnableTriState( FALSE );
 313     }
 314     else
 315     {
 316         aTsbParallel.SetState( STATE_DONTKNOW );
 317     }
 318     aTsbParallel.SaveValue();
 319
 320     // SdrMeasureShowUnitItem
 321     if( rAttrs.GetItemState( SDRATTR_MEASURESHOWUNIT ) != SFX_ITEM_DONTCARE )
 322     {
 323         aTsbShowUnit.SetState( ( ( const SdrMeasureShowUnitItem& )rAttrs.Get( SDRATTR_MEASURESHOWUNIT ) ).
 324                         GetValue() ? STATE_CHECK : STATE_NOCHECK );
 325         aTsbShowUnit.EnableTriState( FALSE );
 326     }
 327     else
 328     {
 329         aTsbShowUnit.SetState( STATE_DONTKNOW );
 330     }
 331     aTsbShowUnit.SaveValue();
 332
 333     // SdrMeasureUnitItem
 334     if( rAttrs.GetItemState( SDRATTR_MEASUREUNIT ) != SFX_ITEM_DONTCARE )
 335     {
 336         long nFieldUnit = (long) ( ( const SdrMeasureUnitItem& )rAttrs.
 337                                     Get( SDRATTR_MEASUREUNIT ) ).GetValue();
 338
 339         for( USHORT i = 0; i < aLbUnit.GetEntryCount(); ++i )
 340         {
 341             if ( (long)aLbUnit.GetEntryData( i ) == nFieldUnit )
 342             {
 343                 aLbUnit.SelectEntryPos( i );
 344                 break;
 345             }
 346         }
 347     }
 348     else
 349     {
 350         aLbUnit.SetNoSelection();
 351     }
 352     aLbUnit.SaveValue();
 353
 354     // Position
 355     if ( rAttrs.GetItemState( SDRATTR_MEASURETEXTVPOS ) != SFX_ITEM_DONTCARE )
 356     {
 357         SdrMeasureTextVPos eVPos = (SdrMeasureTextVPos)
 358                     ( ( const SdrMeasureTextVPosItem& )rAttrs.Get( SDRATTR_MEASURETEXTVPOS ) ).GetValue();
 359         {
 360             if ( rAttrs.GetItemState( SDRATTR_MEASURETEXTHPOS ) != SFX_ITEM_DONTCARE )
 361             {
 362                 aTsbAutoPosV.EnableTriState( FALSE );
 363                 aTsbAutoPosH.EnableTriState( FALSE );
 364
 365                 SdrMeasureTextHPos eHPos = (SdrMeasureTextHPos)
 366                             ( ( const SdrMeasureTextHPosItem& )rAttrs.Get( SDRATTR_MEASURETEXTHPOS ) ).GetValue();
 367                 RECT_POINT eRP = RP_MM;
 368                 switch( eVPos )
 369                 {
 370                 case SDRMEASURE_ABOVE:
 371                     switch( eHPos )
 372                     {
 373                     case SDRMEASURE_TEXTLEFTOUTSIDE:    eRP = RP_LT; break;
 374                     case SDRMEASURE_TEXTINSIDE:                 eRP = RP_MT; break;
 375                     case SDRMEASURE_TEXTRIGHTOUTSIDE:   eRP = RP_RT; break;
 376                     case SDRMEASURE_TEXTHAUTO:                  eRP = RP_MT; break;
 377                     }
 378                     break;
 379                 case SDRMEASURETEXT_VERTICALCENTERED:
 380                     switch( eHPos )
 381                     {
 382                     case SDRMEASURE_TEXTLEFTOUTSIDE:    eRP = RP_LM; break;
 383                     case SDRMEASURE_TEXTINSIDE:                 eRP = RP_MM; break;
 384                     case SDRMEASURE_TEXTRIGHTOUTSIDE:   eRP = RP_RM; break;
 385                     case SDRMEASURE_TEXTHAUTO:                  eRP = RP_MM; break;
 386                     }
 387                     break;
 388                 case SDRMEASURE_BELOW:
 389                     switch( eHPos )
 390                     {
 391                     case SDRMEASURE_TEXTLEFTOUTSIDE:    eRP = RP_LB; break;
 392                     case SDRMEASURE_TEXTINSIDE:                 eRP = RP_MB; break;
 393                     case SDRMEASURE_TEXTRIGHTOUTSIDE:   eRP = RP_RB; break;
 394                     case SDRMEASURE_TEXTHAUTO:                  eRP = RP_MB; break;
 395                     }
 396                     break;
 397                 case SDRMEASURE_TEXTVAUTO:
 398                     switch( eHPos )
 399                     {
 400                     case SDRMEASURE_TEXTLEFTOUTSIDE:    eRP = RP_LM; break;
 401                     case SDRMEASURE_TEXTINSIDE:                 eRP = RP_MM; break;
 402                     case SDRMEASURE_TEXTRIGHTOUTSIDE:   eRP = RP_RM; break;
 403                     case SDRMEASURE_TEXTHAUTO:                  eRP = RP_MM; break;
 404                     }
 405                     break;
 406                  default: ;//prevent warning
 407                 }
 408
 409                 CTL_STATE nState = 0;
 410
 411                 if( eHPos == SDRMEASURE_TEXTHAUTO )
 412                 {
 413                     aTsbAutoPosH.SetState( STATE_CHECK );
 414                     nState = CS_NOHORZ;
 415                 }
 416
 417                 if( eVPos == SDRMEASURE_TEXTVAUTO )
 418                 {
 419                     aTsbAutoPosV.SetState( STATE_CHECK );
 420                     nState |= CS_NOVERT;
 421                 }
 422
 423                 aCtlPosition.SetState( nState );
 424                 aCtlPosition.SetActualRP( eRP );
 425             }
 426         }
 427     }
 428     else
 429     {
 430         aCtlPosition.Reset();
 431         aTsbAutoPosV.SetState( STATE_DONTKNOW );
 432         aTsbAutoPosH.SetState( STATE_DONTKNOW );
 433     }
 434
 435     // put the attributes to the preview-control,
 436     // otherwise the control don't know about
 437     // the settings of the dialog (#67930)
 438     ChangeAttrHdl_Impl( &aTsbShowUnit );
 439     aCtlPreview.SetAttributes( rAttrs );
 440
 441     bPositionModified = FALSE;
 442 }
 443
 444 /*************************************************************************
 445 |*
 446 |* Fill the delivered Item-Set with dialogbox-attributes
 447 |*
 448 \************************************************************************/
 449
 450 BOOL SvxMeasurePage::FillItemSet( SfxItemSet& rAttrs)
 451 {
 452     BOOL         bModified = FALSE;
 453     INT32        nValue;
 454     TriState eState;
 455
 456     if( aMtrFldLineDist.GetText() != aMtrFldLineDist.GetSavedValue() )
 457     {
 458         nValue = GetCoreValue( aMtrFldLineDist, eUnit );
 459         rAttrs.Put( SdrMeasureLineDistItem( nValue ) );
 460         bModified = TRUE;
 461     }
 462
 463     if( aMtrFldHelplineOverhang.GetText() != aMtrFldHelplineOverhang.GetSavedValue() )
 464     {
 465         nValue = GetCoreValue( aMtrFldHelplineOverhang, eUnit );
 466         rAttrs.Put( SdrMeasureHelplineOverhangItem( nValue ) );
 467         bModified = TRUE;
 468     }
 469
 470     if( aMtrFldHelplineDist.GetText() != aMtrFldHelplineDist.GetSavedValue() )
 471     {
 472         nValue = GetCoreValue( aMtrFldHelplineDist, eUnit );
 473         rAttrs.Put( SdrMeasureHelplineDistItem( nValue ) );
 474         bModified = TRUE;
 475     }
 476
 477     if( aMtrFldHelpline1Len.GetText() != aMtrFldHelpline1Len.GetSavedValue() )
 478     {
 479         nValue = GetCoreValue( aMtrFldHelpline1Len, eUnit );
 480         rAttrs.Put( SdrMeasureHelpline1LenItem( nValue ) );
 481         bModified = TRUE;
 482     }
 483
 484     if( aMtrFldHelpline2Len.GetText() != aMtrFldHelpline2Len.GetSavedValue() )
 485     {
 486         nValue = GetCoreValue( aMtrFldHelpline2Len, eUnit );
 487         rAttrs.Put( SdrMeasureHelpline2LenItem( nValue ) );
 488         bModified = TRUE;
 489     }
 490
 491     eState = aTsbBelowRefEdge.GetState();
 492     if( eState != aTsbBelowRefEdge.GetSavedValue() )
 493     {
 494         rAttrs.Put( SdrMeasureBelowRefEdgeItem( (BOOL) STATE_CHECK == eState ) );
 495         bModified = TRUE;
 496     }
 497
 498     if( aMtrFldDecimalPlaces.GetText() != aMtrFldDecimalPlaces.GetSavedValue() )
 499     {
 500         nValue = static_cast<INT32>(aMtrFldDecimalPlaces.GetValue());
 501         rAttrs.Put(
 502             SdrMeasureDecimalPlacesItem(
 503                 sal::static_int_cast< INT16 >( nValue ) ) );
 504         bModified = TRUE;
 505     }
 506
 507     eState = aTsbParallel.GetState();
 508     if( eState != aTsbParallel.GetSavedValue() )
 509     {
 510         rAttrs.Put( SdrMeasureTextRota90Item( (BOOL) STATE_NOCHECK == eState ) );
 511         bModified = TRUE;
 512     }
 513
 514     eState = aTsbShowUnit.GetState();
 515     if( eState != aTsbShowUnit.GetSavedValue() )
 516     {
 517         rAttrs.Put( SdrMeasureShowUnitItem( (BOOL) STATE_CHECK == eState ) );
 518         bModified = TRUE;
 519     }
 520
 521     USHORT nPos = aLbUnit.GetSelectEntryPos();
 522     if( nPos != aLbUnit.GetSavedValue() )
 523     {
 524         if( nPos != LISTBOX_ENTRY_NOTFOUND )
 525         {
 526             USHORT nFieldUnit = (USHORT)(long)aLbUnit.GetEntryData( nPos );
 527             FieldUnit _eUnit = (FieldUnit) nFieldUnit;
 528             rAttrs.Put( SdrMeasureUnitItem( _eUnit ) );
 529             bModified = TRUE;
 530         }
 531     }
 532
 533 //enum SdrMeasureTextHPos {SDRMEASURE_TEXTHAUTO,SDRMEASURE_TEXTLEFTOUTSIDE,SDRMEASURE_TEXTINSIDE,SDRMEASURE_TEXTRIGHTOUTSIDE};
 534 //enum SdrMeasureTextVPos {SDRMEASURE_TEXTVAUTO,SDRMEASURE_ABOVE,SDRMEASURETEXT_VERTICALCENTERED,SDRMEASURE_BELOW};
 535
 536     if( bPositionModified )
 537     {
 538         // Position
 539         SdrMeasureTextVPos eVPos, eOldVPos;
 540         SdrMeasureTextHPos eHPos, eOldHPos;
 541
 542         RECT_POINT eRP = aCtlPosition.GetActualRP();
 543         switch( eRP )
 544         {
 545             default:
 546             case RP_LT: eVPos = SDRMEASURE_ABOVE;
 547                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 548             case RP_LM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 549                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 550             case RP_LB: eVPos = SDRMEASURE_BELOW;
 551                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 552             case RP_MT: eVPos = SDRMEASURE_ABOVE;
 553                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 554             case RP_MM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 555                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 556             case RP_MB: eVPos = SDRMEASURE_BELOW;
 557                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 558             case RP_RT: eVPos = SDRMEASURE_ABOVE;
 559                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 560             case RP_RM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 561                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 562             case RP_RB: eVPos = SDRMEASURE_BELOW;
 563                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 564         }
 565         if( aTsbAutoPosH.GetState() == STATE_CHECK )
 566             eHPos = SDRMEASURE_TEXTHAUTO;
 567
 568         if( aTsbAutoPosV.GetState() == STATE_CHECK )
 569             eVPos = SDRMEASURE_TEXTVAUTO;
 570
 571         if ( rAttrs.GetItemState( SDRATTR_MEASURETEXTVPOS ) != SFX_ITEM_DONTCARE )
 572         {
 573             eOldVPos = (SdrMeasureTextVPos)
 574                         ( ( const SdrMeasureTextVPosItem& )rOutAttrs.Get( SDRATTR_MEASURETEXTVPOS ) ).GetValue();
 575             if( eOldVPos != eVPos )
 576             {
 577                 rAttrs.Put( SdrMeasureTextVPosItem( eVPos ) );
 578                 bModified = TRUE;
 579             }
 580         }
 581         else
 582         {
 583             rAttrs.Put( SdrMeasureTextVPosItem( eVPos ) );
 584             bModified = TRUE;
 585         }
 586
 587         if ( rAttrs.GetItemState( SDRATTR_MEASURETEXTHPOS ) != SFX_ITEM_DONTCARE )
 588         {
 589             eOldHPos = (SdrMeasureTextHPos)
 590                         ( ( const SdrMeasureTextHPosItem& )rOutAttrs.Get( SDRATTR_MEASURETEXTHPOS ) ).GetValue();
 591             if( eOldHPos != eHPos )
 592             {
 593                 rAttrs.Put( SdrMeasureTextHPosItem( eHPos ) );
 594                 bModified = TRUE;
 595             }
 596         }
 597         else
 598         {
 599             rAttrs.Put( SdrMeasureTextHPosItem( eHPos ) );
 600             bModified = TRUE;
 601         }
 602     }
 603
 604     return( bModified );
 605 }
 606
 607 /*************************************************************************
 608 |*
 609 |* The View have to set at the measure-object to be able to notify
 610 |* unit and floatingpoint-values
 611 |*
 612 \************************************************************************/
 613
 614 void SvxMeasurePage::Construct()
 615 {
 616     DBG_ASSERT( pView, "Keine gueltige View Uebergeben!" );
 617
 618     aCtlPreview.pMeasureObj->SetModel( pView->GetModel() );
 619     aCtlPreview.Invalidate();
 620 }
 621
 622 /*************************************************************************
 623 |*
 624 |* create the tabpage
 625 |*
 626 \************************************************************************/
 627
 628 SfxTabPage* SvxMeasurePage::Create( Window* pWindow,
 629                 const SfxItemSet& rAttrs )
 630 {
 631     return( new SvxMeasurePage( pWindow, rAttrs ) );
 632 }
 633
 634 /*************************************************************************
 635 |*
 636 |*
 637 |*
 638 \************************************************************************/
 639
 640 USHORT* SvxMeasurePage::GetRanges()
 641 {
 642     return( pRanges );
 643 }
 644
 645 /*************************************************************************
 646 |*
 647 |*
 648 |*
 649 \************************************************************************/
 650
 651 void SvxMeasurePage::PointChanged( Window* pWindow, RECT_POINT /*eRP*/ )
 652 {
 653     ChangeAttrHdl_Impl( pWindow );
 654 }
 655
 656 /*************************************************************************
 657 |*
 658 |*
 659 |*
 660 \************************************************************************/
 661
 662 IMPL_LINK( SvxMeasurePage, ClickAutoPosHdl_Impl, void *, p )
 663 {
 664     if( aTsbAutoPosH.GetState() == STATE_CHECK )
 665     {
 666         switch( aCtlPosition.GetActualRP() )
 667         {
 668             case RP_LT:
 669             case RP_RT:
 670                 aCtlPosition.SetActualRP( RP_MT );
 671             break;
 672
 673             case RP_LM:
 674             case RP_RM:
 675                 aCtlPosition.SetActualRP( RP_MM );
 676             break;
 677
 678             case RP_LB:
 679             case RP_RB:
 680                 aCtlPosition.SetActualRP( RP_MB );
 681             break;
 682             default: ;//prevent warning
 683         }
 684     }
 685     if( aTsbAutoPosV.GetState() == STATE_CHECK )
 686     {
 687         switch( aCtlPosition.GetActualRP() )
 688         {
 689             case RP_LT:
 690             case RP_LB:
 691                 aCtlPosition.SetActualRP( RP_LM );
 692             break;
 693
 694             case RP_MT:
 695             case RP_MB:
 696                 aCtlPosition.SetActualRP( RP_MM );
 697             break;
 698
 699             case RP_RT:
 700             case RP_RB:
 701                 aCtlPosition.SetActualRP( RP_RM );
 702             break;
 703             default: ;//prevent warning
 704         }
 705     }
 706     ChangeAttrHdl_Impl( p );
 707
 708     return( 0L );
 709 }
 710
 711 /*************************************************************************
 712 |*
 713 |*
 714 |*
 715 \************************************************************************/
 716
 717 IMPL_LINK( SvxMeasurePage, ChangeAttrHdl_Impl, void *, p )
 718 {
 719
 720     if( p == &aMtrFldLineDist )
 721     {
 722         INT32 nValue = GetCoreValue( aMtrFldLineDist, eUnit );
 723         aAttrSet.Put( SdrMeasureLineDistItem( nValue ) );
 724     }
 725
 726     if( p == &aMtrFldHelplineOverhang )
 727     {
 728         INT32 nValue = GetCoreValue( aMtrFldHelplineOverhang, eUnit );
 729         aAttrSet.Put( SdrMeasureHelplineOverhangItem( nValue) );
 730     }
 731
 732     if( p == &aMtrFldHelplineDist )
 733     {
 734         INT32 nValue = GetCoreValue( aMtrFldHelplineDist, eUnit );
 735         aAttrSet.Put( SdrMeasureHelplineDistItem( nValue) );
 736     }
 737
 738     if( p == &aMtrFldHelpline1Len )
 739     {
 740         INT32 nValue = GetCoreValue( aMtrFldHelpline1Len, eUnit );
 741         aAttrSet.Put( SdrMeasureHelpline1LenItem( nValue ) );
 742     }
 743
 744     if( p == &aMtrFldHelpline2Len )
 745     {
 746         INT32 nValue = GetCoreValue( aMtrFldHelpline2Len, eUnit );
 747         aAttrSet.Put( SdrMeasureHelpline2LenItem( nValue ) );
 748     }
 749
 750     if( p == &aTsbBelowRefEdge )
 751     {
 752         TriState eState = aTsbBelowRefEdge.GetState();
 753         if( eState != STATE_DONTKNOW )
 754             aAttrSet.Put( SdrMeasureBelowRefEdgeItem( (BOOL) STATE_CHECK == eState ) );
 755     }
 756
 757     if( p == &aMtrFldDecimalPlaces )
 758     {
 759         INT16 nValue = sal::static_int_cast< INT16 >(
 760             aMtrFldDecimalPlaces.GetValue() );
 761         aAttrSet.Put( SdrMeasureDecimalPlacesItem( nValue ) );
 762     }
 763
 764     if( p == &aTsbParallel )
 765     {
 766         TriState eState = aTsbParallel.GetState();
 767         if( eState != STATE_DONTKNOW )
 768             aAttrSet.Put( SdrMeasureTextRota90Item( (BOOL) !STATE_CHECK == eState ) );
 769     }
 770
 771     if( p == &aTsbShowUnit )
 772     {
 773         TriState eState = aTsbShowUnit.GetState();
 774         if( eState != STATE_DONTKNOW )
 775             aAttrSet.Put( SdrMeasureShowUnitItem( (BOOL) STATE_CHECK == eState ) );
 776     }
 777
 778     if( p == &aLbUnit )
 779     {
 780         USHORT nPos = aLbUnit.GetSelectEntryPos();
 781         if( nPos != LISTBOX_ENTRY_NOTFOUND )
 782         {
 783             USHORT nFieldUnit = (USHORT)(long)aLbUnit.GetEntryData( nPos );
 784             FieldUnit _eUnit = (FieldUnit) nFieldUnit;
 785             aAttrSet.Put( SdrMeasureUnitItem( _eUnit ) );
 786         }
 787     }
 788
 789     if( p == &aTsbAutoPosV || p == &aTsbAutoPosH || p == &aCtlPosition )
 790     {
 791         bPositionModified = TRUE;
 792
 793         // Position
 794         RECT_POINT eRP = aCtlPosition.GetActualRP();
 795         SdrMeasureTextVPos eVPos;
 796         SdrMeasureTextHPos eHPos;
 797
 798         switch( eRP )
 799         {
 800             default:
 801             case RP_LT: eVPos = SDRMEASURE_ABOVE;
 802                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 803             case RP_LM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 804                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 805             case RP_LB: eVPos = SDRMEASURE_BELOW;
 806                         eHPos = SDRMEASURE_TEXTLEFTOUTSIDE; break;
 807             case RP_MT: eVPos = SDRMEASURE_ABOVE;
 808                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 809             case RP_MM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 810                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 811             case RP_MB: eVPos = SDRMEASURE_BELOW;
 812                         eHPos = SDRMEASURE_TEXTINSIDE; break;
 813             case RP_RT: eVPos = SDRMEASURE_ABOVE;
 814                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 815             case RP_RM: eVPos = SDRMEASURETEXT_VERTICALCENTERED;
 816                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 817             case RP_RB: eVPos = SDRMEASURE_BELOW;
 818                         eHPos = SDRMEASURE_TEXTRIGHTOUTSIDE; break;
 819         }
 820
 821         CTL_STATE nState = 0;
 822
 823         if( aTsbAutoPosH.GetState() == STATE_CHECK )
 824         {
 825             eHPos = SDRMEASURE_TEXTHAUTO;
 826             nState = CS_NOHORZ;
 827         }
 828
 829         if( aTsbAutoPosV.GetState() == STATE_CHECK )
 830         {
 831             eVPos = SDRMEASURE_TEXTVAUTO;
 832             nState |= CS_NOVERT;
 833         }
 834
 835         if( p == &aTsbAutoPosV || p == &aTsbAutoPosH )
 836             aCtlPosition.SetState( nState );
 837
 838         aAttrSet.Put( SdrMeasureTextVPosItem( eVPos ) );
 839         aAttrSet.Put( SdrMeasureTextHPosItem( eHPos ) );
 840     }
 841
 842     aCtlPreview.SetAttributes( aAttrSet );
 843     aCtlPreview.Invalidate();
 844
 845     return( 0L );
 846 }
 847
 848 /*************************************************************************
 849 |*
 850 |*
 851 |*
 852 \************************************************************************/
 853
 854 void SvxMeasurePage::FillUnitLB()
 855 {
 856     // fill ListBox with metrics
 857     SvxStringArray aMetricArr( RID_SVXSTR_FIELDUNIT_TABLE );
 858
 859     long nUnit = FUNIT_NONE;
 860     String aStrMetric( SVX_RES( STR_MEASURE_AUTOMATIC ) );
 861     USHORT nPos = aLbUnit.InsertEntry( aStrMetric );
 862     aLbUnit.SetEntryData( nPos, (void*)nUnit );
 863
 864     for( USHORT i = 0; i < aMetricArr.Count(); ++i )
 865     {
 866         aStrMetric = aMetricArr.GetStringByPos( i );
 867         nUnit = aMetricArr.GetValue( i );
 868         nPos = aLbUnit.InsertEntry( aStrMetric );
 869         aLbUnit.SetEntryData( nPos, (void*)nUnit );
 870     }
 871 }
 872 void SvxMeasurePage::PageCreated (SfxAllItemSet aSet) //add CHINA001
 873 {
 874     SFX_ITEMSET_ARG (&aSet,pOfaPtrItem,OfaPtrItem,SID_OBJECT_LIST,sal_False);
 875
 876     if (pOfaPtrItem)
 877         SetView( static_cast<SdrView *>(pOfaPtrItem->GetValue()));
 878
 879     Construct();
 880 }
 881