svx/source/tbxctrls/itemwin.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: itemwin.cxx,v $
  10  * $Revision: 1.28 $
  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 // include ---------------------------------------------------------------
  35 #include <tools/shl.hxx>
  36 #include <sfx2/dispatch.hxx>
  37 #include <sfx2/objsh.hxx>
  38 #include <sfx2/viewsh.hxx>
  39 #include <sfx2/module.hxx>
  40 #include <tools/urlobj.hxx>
  41
  42 #define _SVX_ITEMWIN_CXX
  43
  44 #include <vcl/svapp.hxx>
  45
  46 #include <svx/dialogs.hrc>
  47
  48 #define DELAY_TIMEOUT                   100
  49
  50 #include <svx/xlnclit.hxx>
  51 #include <svx/xlnwtit.hxx>
  52 #include <svx/xlineit0.hxx>
  53 #include <svx/xlndsit.hxx>
  54 #include <svx/xtable.hxx>
  55 #include "drawitem.hxx"
  56 #include <svx/dialmgr.hxx>
  57 #include "dlgutil.hxx"
  58 #include <svx/itemwin.hxx>
  59 #include "linectrl.hxx"
  60 #include <svtools/colorcfg.hxx>
  61
  62 #include "linectrl.hrc"
  63
  64 using namespace ::com::sun::star::uno;
  65 using namespace ::com::sun::star::frame;
  66 using namespace ::com::sun::star::util;
  67 using namespace ::com::sun::star::lang;
  68 using namespace ::com::sun::star::beans;
  69
  70 #define LOGICAL_EDIT_HEIGHT         12
  71 //========================================================================
  72 // SvxLineBox
  73 //========================================================================
  74
  75 SvxLineBox::SvxLineBox( Window* pParent, const Reference< XFrame >& rFrame, WinBits nBits ) :
  76     LineLB( pParent, nBits ),
  77     meBmpMode   ( GetDisplayBackground().GetColor().IsDark() ? BMP_COLOR_HIGHCONTRAST : BMP_COLOR_NORMAL ),
  78     nCurPos             ( 0 ),
  79     aLogicalSize(40,140),
  80     bRelease    ( TRUE ),
  81     mpSh                ( NULL ),
  82     mxFrame     ( rFrame )
  83 {
  84     SetSizePixel( LogicToPixel( aLogicalSize, MAP_APPFONT ));
  85     Show();
  86
  87     aDelayTimer.SetTimeout( DELAY_TIMEOUT );
  88     aDelayTimer.SetTimeoutHdl( LINK( this, SvxLineBox, DelayHdl_Impl ) );
  89     aDelayTimer.Start();
  90 }
  91
  92 // -----------------------------------------------------------------------
  93
  94 SvxLineBox::~SvxLineBox()
  95 {
  96 }
  97
  98 // -----------------------------------------------------------------------
  99
 100 IMPL_LINK( SvxLineBox, DelayHdl_Impl, Timer *, EMPTYARG )
 101 {
 102     if ( GetEntryCount() == 0 )
 103     {
 104         mpSh = SfxObjectShell::Current();
 105         FillControl();
 106     }
 107     return 0;
 108 }
 109
 110 // -----------------------------------------------------------------------
 111
 112 void SvxLineBox::Select()
 113 {
 114     // Call the parent's Select() member to trigger accessibility events.
 115     LineLB::Select();
 116
 117     if ( !IsTravelSelect() )
 118     {
 119         XLineStyle eXLS;
 120         USHORT nPos = GetSelectEntryPos();
 121 //              SfxDispatcher* pDisp = rBindings.GetDispatcher();
 122         //DBG_ASSERT( pDisp, "invalid Dispatcher" );
 123
 124         switch ( nPos )
 125         {
 126             case 0:
 127                 eXLS = XLINE_NONE;
 128                 break;
 129
 130             case 1:
 131                 eXLS = XLINE_SOLID;
 132                 break;
 133
 134             default:
 135             {
 136                 eXLS = XLINE_DASH;
 137
 138                 if ( nPos != LISTBOX_ENTRY_NOTFOUND &&
 139                      SfxObjectShell::Current()  &&
 140                      SfxObjectShell::Current()->GetItem( SID_DASH_LIST ) )
 141                 {
 142                     // LineDashItem wird nur geschickt, wenn es auch einen Dash besitzt.
 143                     // Notify k"ummert sich darum!
 144                     SvxDashListItem aItem( *(const SvxDashListItem*)(
 145                         SfxObjectShell::Current()->GetItem( SID_DASH_LIST ) ) );
 146                     XLineDashItem aLineDashItem( GetSelectEntry(),
 147                         aItem.GetDashList()->GetDash( nPos - 2 )->GetDash() );
 148
 149                     Any a;
 150                     Sequence< PropertyValue > aArgs( 1 );
 151                     aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LineDash" ));
 152                     aLineDashItem.QueryValue ( a );
 153                     aArgs[0].Value = a;
 154                     SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
 155                                                  ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:LineDash" )),
 156                                                  aArgs );
 157 //                    pDisp->Execute( SID_ATTR_LINE_DASH, SFX_CALLMODE_RECORD, &aLineDashItem, 0L );
 158                 }
 159             }
 160             break;
 161         }
 162
 163         XLineStyleItem aLineStyleItem( eXLS );
 164         Any a;
 165         Sequence< PropertyValue > aArgs( 1 );
 166         aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "XLineStyle" ));
 167         aLineStyleItem.QueryValue ( a );
 168         aArgs[0].Value = a;
 169         SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
 170                                      ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:XLineStyle" )),
 171                                      aArgs );
 172 //              pDisp->Execute( SID_ATTR_LINE_STYLE, SFX_CALLMODE_RECORD, &aLineStyleItem, 0L );
 173
 174         nCurPos = GetSelectEntryPos();
 175         ReleaseFocus_Impl();
 176     }
 177 }
 178
 179 // -----------------------------------------------------------------------
 180
 181 long SvxLineBox::PreNotify( NotifyEvent& rNEvt )
 182 {
 183     USHORT nType = rNEvt.GetType();
 184
 185     switch(nType)
 186     {
 187         case EVENT_MOUSEBUTTONDOWN:
 188         case EVENT_GETFOCUS:
 189             nCurPos = GetSelectEntryPos();
 190         break;
 191         case EVENT_LOSEFOCUS:
 192             SelectEntryPos(nCurPos);
 193         break;
 194         case EVENT_KEYINPUT:
 195         {
 196             const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 197             if( pKEvt->GetKeyCode().GetCode() == KEY_TAB)
 198             {
 199                 bRelease = FALSE;
 200                 Select();
 201             }
 202         }
 203         break;
 204     }
 205     return LineLB::PreNotify( rNEvt );
 206 }
 207
 208 // -----------------------------------------------------------------------
 209
 210 long SvxLineBox::Notify( NotifyEvent& rNEvt )
 211 {
 212     long nHandled = LineLB::Notify( rNEvt );
 213
 214     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 215     {
 216         const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 217
 218         switch ( pKEvt->GetKeyCode().GetCode() )
 219         {
 220             case KEY_RETURN:
 221                 Select();
 222                 nHandled = 1;
 223                 break;
 224
 225             case KEY_ESCAPE:
 226                 SelectEntryPos( nCurPos );
 227                 ReleaseFocus_Impl();
 228                 nHandled = 1;
 229                 break;
 230         }
 231     }
 232     return nHandled;
 233 }
 234
 235 // -----------------------------------------------------------------------
 236
 237 void SvxLineBox::ReleaseFocus_Impl()
 238 {
 239     if(!bRelease)
 240     {
 241         bRelease = TRUE;
 242         return;
 243     }
 244
 245     if( SfxViewShell::Current() )
 246     {
 247         Window* pShellWnd = SfxViewShell::Current()->GetWindow();
 248
 249         if ( pShellWnd )
 250             pShellWnd->GrabFocus();
 251     }
 252 }
 253 /* -----------------------------08.03.2002 15:39------------------------------
 254
 255  ---------------------------------------------------------------------------*/
 256 void SvxLineBox::DataChanged( const DataChangedEvent& rDCEvt )
 257 {
 258     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 259          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 260     {
 261         SetSizePixel(LogicToPixel(aLogicalSize, MAP_APPFONT));
 262         Size aDropSize( aLogicalSize.Width(), LOGICAL_EDIT_HEIGHT);
 263         SetDropDownSizePixel(LogicToPixel(aDropSize, MAP_APPFONT));
 264    }
 265
 266     LineLB::DataChanged( rDCEvt );
 267
 268     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 269          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 270     {
 271         BmpColorMode eMode = GetDisplayBackground().GetColor().IsDark() ? BMP_COLOR_HIGHCONTRAST : BMP_COLOR_NORMAL;
 272         if( eMode != meBmpMode )
 273         {
 274             meBmpMode = eMode;
 275             FillControl();
 276         }
 277      }
 278 }
 279
 280 void SvxLineBox::FillControl()
 281 {
 282     Clear();
 283
 284     InsertEntry( SVX_RESSTR(RID_SVXSTR_INVISIBLE) );
 285
 286     Bitmap aBitmap ( SVX_RES ( RID_SVXCTRL_LINECTRL ) );
 287
 288     ::Color aSourceColors[2];
 289     ::Color aDestColors[2];
 290
 291     aSourceColors[0] = ::Color( COL_WHITE );
 292     aSourceColors[1] = ::Color( COL_BLACK );
 293
 294     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 295     aDestColors[0] = rStyles.GetFieldColor();
 296     aDestColors[1] = rStyles.GetFieldTextColor();
 297
 298     aBitmap.Replace ( aSourceColors, aDestColors, 2 );
 299     Image aSolidLine ( aBitmap );
 300     InsertEntry( SVX_RESSTR(RID_SVXSTR_SOLID), aSolidLine );
 301
 302     if ( !mpSh )
 303         mpSh = SfxObjectShell::Current();
 304
 305     if( mpSh )
 306     {
 307         const SvxDashListItem* pItem = (const SvxDashListItem*)( mpSh->GetItem( SID_DASH_LIST ) );
 308         if ( pItem )
 309             Fill( pItem->GetDashList() );
 310     }
 311
 312 //      rBindings.Invalidate( SID_ATTR_LINE_DASH );
 313 }
 314 //========================================================================
 315 // SvxColorBox
 316 //========================================================================
 317
 318 SvxColorBox::SvxColorBox(
 319     Window* pParent,
 320     const ::rtl::OUString& rCommand,
 321     const Reference< XFrame >& rFrame,
 322     WinBits nBits ) :
 323     ColorLB( pParent, nBits ),
 324     nCurPos             ( 0 ),
 325     aLogicalSize(45,80),
 326     bRelease    ( TRUE ),
 327     maCommand   ( rCommand ),
 328     mxFrame     ( rFrame )
 329 {
 330     SetSizePixel( LogicToPixel( aLogicalSize , MAP_APPFONT));
 331     Show();
 332
 333     SfxObjectShell* pSh = SfxObjectShell::Current();
 334
 335     if ( pSh )
 336     {
 337         const SvxColorTableItem* pItem =
 338             (const SvxColorTableItem*)( pSh->GetItem( SID_COLOR_TABLE ) );
 339         if(pItem)
 340             Fill( pItem->GetColorTable() );
 341     }
 342 }
 343
 344 // -----------------------------------------------------------------------
 345
 346 IMPL_LINK( SvxColorBox, DelayHdl_Impl, Timer *, EMPTYARG )
 347 {
 348     SfxObjectShell* pSh = SfxObjectShell::Current();
 349
 350     if ( pSh )
 351     {
 352         const SvxColorTableItem* pItem = (const SvxColorTableItem*)( pSh->GetItem( SID_COLOR_TABLE ) );
 353         if ( pItem )
 354             Fill( pItem->GetColorTable() );
 355 //              rBindings.Invalidate( nId );
 356     }
 357     return 0;
 358 }
 359
 360 // -----------------------------------------------------------------------
 361
 362 SvxColorBox::~SvxColorBox()
 363 {
 364 }
 365
 366 // -----------------------------------------------------------------------
 367
 368 void SvxColorBox::Update( const XLineColorItem* pItem )
 369 {
 370     if ( pItem )
 371         SelectEntry( pItem->GetColorValue() );
 372     else
 373         SetNoSelection();
 374 }
 375
 376 // -----------------------------------------------------------------------
 377
 378 void SvxColorBox::Select()
 379 {
 380     // OJ: base class call needed here because otherwise no event is send for accessibility
 381     ColorLB::Select();
 382     if ( !IsTravelSelect() )
 383     {
 384         XLineColorItem aLineColorItem( GetSelectEntry(), GetSelectEntryColor() );
 385
 386         INetURLObject aObj( maCommand );
 387
 388         Any a;
 389         Sequence< PropertyValue > aArgs( 1 );
 390         aArgs[0].Name = aObj.GetURLPath();
 391         aLineColorItem.QueryValue( a );
 392         aArgs[0].Value = a;
 393         SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
 394                                      maCommand,
 395                                      aArgs );
 396 //        rBindings.GetDispatcher()->Execute( nId, SFX_CALLMODE_RECORD, &aLineColorItem, 0L );
 397
 398         nCurPos = GetSelectEntryPos();
 399         ReleaseFocus_Impl();
 400     }
 401 }
 402
 403 // -----------------------------------------------------------------------
 404
 405 long SvxColorBox::PreNotify( NotifyEvent& rNEvt )
 406 {
 407     USHORT nType = rNEvt.GetType();
 408
 409     switch(nType)
 410     {
 411         case  EVENT_MOUSEBUTTONDOWN:
 412         case EVENT_GETFOCUS:
 413             nCurPos = GetSelectEntryPos();
 414         break;
 415         case EVENT_LOSEFOCUS:
 416             SelectEntryPos(nCurPos);
 417         break;
 418         case EVENT_KEYINPUT:
 419         {
 420             const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 421
 422             if( pKEvt->GetKeyCode().GetCode() == KEY_TAB)
 423             {
 424                 bRelease = FALSE;
 425                 Select();
 426             }
 427         }
 428     }
 429
 430     return ColorLB::PreNotify( rNEvt );
 431 }
 432
 433 // -----------------------------------------------------------------------
 434
 435 long SvxColorBox::Notify( NotifyEvent& rNEvt )
 436 {
 437     long nHandled = ColorLB::Notify( rNEvt );
 438
 439     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 440     {
 441         const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 442
 443         switch ( pKEvt->GetKeyCode().GetCode() )
 444         {
 445             case KEY_RETURN:
 446                 Select();
 447                 nHandled = 1;
 448                 break;
 449
 450             case KEY_ESCAPE:
 451                 SelectEntryPos( nCurPos );
 452                 ReleaseFocus_Impl();
 453                 nHandled = 1;
 454                 break;
 455         }
 456     }
 457     return nHandled;
 458 }
 459 /* -----------------------------08.03.2002 15:35------------------------------
 460
 461  ---------------------------------------------------------------------------*/
 462 void SvxColorBox::DataChanged( const DataChangedEvent& rDCEvt )
 463 {
 464     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 465          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 466     {
 467         SetSizePixel(LogicToPixel(aLogicalSize, MAP_APPFONT));
 468         Size aDropSize( aLogicalSize.Width(), LOGICAL_EDIT_HEIGHT);
 469         SetDropDownSizePixel(LogicToPixel(aDropSize, MAP_APPFONT));
 470     }
 471
 472     ColorLB::DataChanged( rDCEvt );
 473 }
 474 // -----------------------------------------------------------------------
 475
 476 void SvxColorBox::ReleaseFocus_Impl()
 477 {
 478     if(!bRelease)
 479     {
 480         bRelease = TRUE;
 481         return;
 482     }
 483
 484     if( SfxViewShell::Current() )
 485     {
 486         Window* pShellWnd = SfxViewShell::Current()->GetWindow();
 487
 488         if ( pShellWnd )
 489             pShellWnd->GrabFocus();
 490     }
 491 }
 492
 493 //========================================================================
 494 // SvxMetricField
 495 //========================================================================
 496
 497 SvxMetricField::SvxMetricField(
 498     Window* pParent, const Reference< XFrame >& rFrame, WinBits nBits ) :
 499     MetricField( pParent, nBits ),
 500     aCurTxt( String() ),
 501     mxFrame( rFrame )
 502 {
 503     Size aSize = Size(GetTextWidth( String::CreateFromAscii("99,99mm") ),GetTextHeight());
 504     aSize.Width() += 20;
 505     aSize.Height() += 6;
 506     SetSizePixel( aSize );
 507     aLogicalSize = PixelToLogic(aSize, MAP_APPFONT);
 508     SetUnit( FUNIT_MM );
 509     SetDecimalDigits( 2 );
 510     SetMax( 5000 );
 511     SetMin( 0 );
 512     SetLast( 5000 );
 513     SetFirst( 0 );
 514
 515     eDlgUnit = GetModuleFieldUnit( NULL );
 516     SetFieldUnit( *this, eDlgUnit, FALSE );
 517     Show();
 518 }
 519
 520 // -----------------------------------------------------------------------
 521
 522 SvxMetricField::~SvxMetricField()
 523 {
 524 }
 525
 526 // -----------------------------------------------------------------------
 527
 528 void SvxMetricField::Update( const XLineWidthItem* pItem )
 529 {
 530     if ( pItem )
 531     {
 532         if ( pItem->GetValue() != GetCoreValue( *this, ePoolUnit ) )
 533             SetMetricValue( *this, pItem->GetValue(), ePoolUnit );
 534     }
 535     else
 536         SetText( String() );
 537 }
 538
 539 // -----------------------------------------------------------------------
 540
 541 void SvxMetricField::Modify()
 542 {
 543     MetricField::Modify();
 544     long nTmp = GetCoreValue( *this, ePoolUnit );
 545     XLineWidthItem aLineWidthItem( nTmp );
 546
 547     Any a;
 548     Sequence< PropertyValue > aArgs( 1 );
 549     aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LineWidth" ));
 550     aLineWidthItem.QueryValue( a );
 551     aArgs[0].Value = a;
 552     SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
 553                                  ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:LineWidth" )),
 554                                  aArgs );
 555 //      rBindings.GetDispatcher()->Execute( SID_ATTR_LINE_WIDTH, SFX_CALLMODE_RECORD, &aLineWidthItem, 0L );
 556 }
 557
 558 // -----------------------------------------------------------------------
 559
 560 void SvxMetricField::ReleaseFocus_Impl()
 561 {
 562     if( SfxViewShell::Current() )
 563     {
 564         Window* pShellWnd = SfxViewShell::Current()->GetWindow();
 565         if ( pShellWnd )
 566             pShellWnd->GrabFocus();
 567     }
 568 }
 569
 570 // -----------------------------------------------------------------------
 571
 572 void SvxMetricField::Down()
 573 {
 574     sal_Int64 nValue = GetValue();
 575     nValue -= GetSpinSize();
 576
 577     // Um unter OS/2 einen Sprung auf Max zu verhindern
 578     if ( nValue >= GetMin() )
 579         MetricField::Down();
 580 }
 581
 582 // -----------------------------------------------------------------------
 583
 584 void SvxMetricField::Up()
 585 {
 586     MetricField::Up();
 587 }
 588
 589 // -----------------------------------------------------------------------
 590
 591 void SvxMetricField::SetCoreUnit( SfxMapUnit eUnit )
 592 {
 593     ePoolUnit = eUnit;
 594 }
 595
 596 // -----------------------------------------------------------------------
 597
 598 void SvxMetricField::RefreshDlgUnit()
 599 {
 600     FieldUnit eTmpUnit = GetModuleFieldUnit( NULL );
 601
 602     if ( eDlgUnit != eTmpUnit )
 603     {
 604         eDlgUnit = eTmpUnit;
 605         SetFieldUnit( *this, eDlgUnit, FALSE );
 606     }
 607 }
 608
 609 // -----------------------------------------------------------------------
 610
 611 long SvxMetricField::PreNotify( NotifyEvent& rNEvt )
 612 {
 613     USHORT nType = rNEvt.GetType();
 614
 615     if ( EVENT_MOUSEBUTTONDOWN == nType || EVENT_GETFOCUS == nType )
 616         aCurTxt = GetText();
 617
 618     return MetricField::PreNotify( rNEvt );
 619 }
 620
 621 // -----------------------------------------------------------------------
 622
 623 long SvxMetricField::Notify( NotifyEvent& rNEvt )
 624 {
 625     long nHandled = MetricField::Notify( rNEvt );
 626
 627     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 628     {
 629         const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 630         const KeyCode& rKey = pKEvt->GetKeyCode();
 631         SfxViewShell* pSh = SfxViewShell::Current();
 632
 633         if ( rKey.GetModifier() && rKey.GetGroup() != KEYGROUP_CURSOR && pSh )
 634             pSh->KeyInput( *pKEvt );
 635         else
 636         {
 637             FASTBOOL bHandled = FALSE;
 638
 639             switch ( rKey.GetCode() )
 640             {
 641                 case KEY_RETURN:
 642                     Reformat();
 643                     bHandled = TRUE;
 644                     break;
 645
 646                 case KEY_ESCAPE:
 647                     SetText( aCurTxt );
 648                     bHandled = TRUE;
 649                     break;
 650             }
 651
 652             if ( bHandled )
 653             {
 654                 nHandled = 1;
 655                 Modify();
 656                 ReleaseFocus_Impl();
 657             }
 658         }
 659     }
 660     return nHandled;
 661 }
 662 /* -----------------------------08.03.2002 15:32------------------------------
 663
 664  ---------------------------------------------------------------------------*/
 665 void SvxMetricField::DataChanged( const DataChangedEvent& rDCEvt )
 666 {
 667     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 668          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 669     {
 670         SetSizePixel(LogicToPixel(aLogicalSize, MAP_APPFONT));
 671     }
 672
 673     MetricField::DataChanged( rDCEvt );
 674 }
 675
 676 //========================================================================
 677 // SvxFillTypeBox
 678 //========================================================================
 679
 680 SvxFillTypeBox::SvxFillTypeBox( Window* pParent, WinBits nBits ) :
 681     FillTypeLB( pParent, nBits | WB_TABSTOP ),
 682     nCurPos     ( 0 ),
 683     bSelect ( FALSE ),
 684     bRelease(TRUE)
 685 {
 686     SetSizePixel( LogicToPixel( Size(40, 40 ),MAP_APPFONT ));
 687     Fill();
 688     SelectEntryPos( XFILL_SOLID );
 689     Show();
 690 }
 691
 692 // -----------------------------------------------------------------------
 693
 694 SvxFillTypeBox::~SvxFillTypeBox()
 695 {
 696 }
 697
 698 // -----------------------------------------------------------------------
 699
 700 long SvxFillTypeBox::PreNotify( NotifyEvent& rNEvt )
 701 {
 702     USHORT nType = rNEvt.GetType();
 703
 704     if ( EVENT_MOUSEBUTTONDOWN == nType || EVENT_GETFOCUS == nType )
 705         nCurPos = GetSelectEntryPos();
 706     else if ( EVENT_LOSEFOCUS == nType
 707         && Application::GetFocusWindow()
 708         && !IsWindowOrChild( Application::GetFocusWindow(), TRUE ) )
 709     {
 710         if ( !bSelect )
 711             SelectEntryPos( nCurPos );
 712         else
 713             bSelect = FALSE;
 714     }
 715
 716     return FillTypeLB::PreNotify( rNEvt );
 717 }
 718
 719 // -----------------------------------------------------------------------
 720
 721 long SvxFillTypeBox::Notify( NotifyEvent& rNEvt )
 722 {
 723     long nHandled = FillTypeLB::Notify( rNEvt );
 724
 725     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 726     {
 727         const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 728         switch ( pKEvt->GetKeyCode().GetCode() )
 729         {
 730             case KEY_RETURN:
 731                 nHandled = 1;
 732                 ( (Link&)GetSelectHdl() ).Call( this );
 733             break;
 734             case KEY_TAB:
 735                 bRelease = FALSE;
 736                 ( (Link&)GetSelectHdl() ).Call( this );
 737                 bRelease = TRUE;
 738                 break;
 739
 740             case KEY_ESCAPE:
 741                 SelectEntryPos( nCurPos );
 742                 ReleaseFocus_Impl();
 743                 nHandled = 1;
 744                 break;
 745         }
 746     }
 747     return nHandled;
 748 }
 749
 750 // -----------------------------------------------------------------------
 751
 752 void SvxFillTypeBox::ReleaseFocus_Impl()
 753 {
 754     if( SfxViewShell::Current() )
 755     {
 756         Window* pShellWnd = SfxViewShell::Current()->GetWindow();
 757
 758         if ( pShellWnd )
 759             pShellWnd->GrabFocus();
 760     }
 761 }
 762
 763 //========================================================================
 764 // SvxFillAttrBox
 765 //========================================================================
 766
 767 SvxFillAttrBox::SvxFillAttrBox( Window* pParent, WinBits nBits ) :
 768
 769     FillAttrLB( pParent, nBits | WB_TABSTOP ),
 770
 771     nCurPos( 0 ),
 772     bRelease( TRUE )
 773
 774 {
 775     SetPosPixel( Point( 90, 0 ) );
 776     SetSizePixel( LogicToPixel( Size(50, 80 ), MAP_APPFONT ));
 777     Show();
 778 }
 779
 780 // -----------------------------------------------------------------------
 781
 782 SvxFillAttrBox::~SvxFillAttrBox()
 783 {
 784 }
 785
 786 // -----------------------------------------------------------------------
 787
 788 long SvxFillAttrBox::PreNotify( NotifyEvent& rNEvt )
 789 {
 790     USHORT nType = rNEvt.GetType();
 791
 792     if ( EVENT_MOUSEBUTTONDOWN == nType || EVENT_GETFOCUS == nType )
 793         nCurPos = GetSelectEntryPos();
 794
 795     return FillAttrLB::PreNotify( rNEvt );
 796 }
 797
 798 // -----------------------------------------------------------------------
 799
 800 long SvxFillAttrBox::Notify( NotifyEvent& rNEvt )
 801 {
 802     long nHandled = FillAttrLB::Notify( rNEvt );
 803
 804     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 805     {
 806         const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 807
 808         switch ( pKEvt->GetKeyCode().GetCode() )
 809         {
 810             case KEY_RETURN:
 811                 ( (Link&)GetSelectHdl() ).Call( this );
 812                 nHandled = 1;
 813             break;
 814             case KEY_TAB:
 815                 bRelease = FALSE;
 816                 GetSelectHdl().Call( this );
 817                 bRelease = TRUE;
 818             break;
 819             case KEY_ESCAPE:
 820                 SelectEntryPos( nCurPos );
 821                 ReleaseFocus_Impl();
 822                 nHandled = 1;
 823                 break;
 824         }
 825     }
 826     return nHandled;
 827 }
 828
 829 // -----------------------------------------------------------------------
 830
 831 void SvxFillAttrBox::Select()
 832 {
 833     FillAttrLB::Select();
 834 }
 835
 836 // -----------------------------------------------------------------------
 837
 838 void SvxFillAttrBox::ReleaseFocus_Impl()
 839 {
 840     if( SfxViewShell::Current() )
 841     {
 842         Window* pShellWnd = SfxViewShell::Current()->GetWindow();
 843
 844         if ( pShellWnd )
 845             pShellWnd->GrabFocus();
 846     }
 847 }