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