LCOV - code coverage report
Current view: top level - svx/source/tbxctrls - linectrl.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 317 0.0 %
Date: 2014-04-14 Functions: 0 50 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <string>
      21             : 
      22             : #include <vcl/toolbox.hxx>
      23             : #include <sfx2/app.hxx>
      24             : #include <sfx2/dispatch.hxx>
      25             : #include <sfx2/objsh.hxx>
      26             : 
      27             : #include <svx/dialogs.hrc>
      28             : #include "helpid.hrc"
      29             : 
      30             : #include "svx/drawitem.hxx"
      31             : #include "svx/xattr.hxx"
      32             : #include <svx/xtable.hxx>
      33             : #include "svx/linectrl.hxx"
      34             : #include <svx/itemwin.hxx>
      35             : #include <svx/dialmgr.hxx>
      36             : #include <svx/unoapi.hxx>
      37             : 
      38             : using namespace ::com::sun::star::uno;
      39             : using namespace ::com::sun::star::beans;
      40             : using namespace ::com::sun::star::util;
      41             : using namespace ::com::sun::star::frame;
      42             : using namespace ::com::sun::star::lang;
      43             : 
      44             : // For End Line Controlleer
      45             : #define MAX_LINES 12
      46             : 
      47             : // STATIC DATA -----------------------------------------------------------
      48             : 
      49           0 : SFX_IMPL_TOOLBOX_CONTROL( SvxLineStyleToolBoxControl, XLineStyleItem );
      50           0 : SFX_IMPL_TOOLBOX_CONTROL( SvxLineWidthToolBoxControl, XLineWidthItem );
      51           0 : SFX_IMPL_TOOLBOX_CONTROL( SvxLineColorToolBoxControl, XLineColorItem );
      52           0 : SFX_IMPL_TOOLBOX_CONTROL( SvxLineEndToolBoxControl,   SfxBoolItem );
      53             : 
      54             : /*************************************************************************
      55             : |*
      56             : |* SvxLineStyleToolBoxControl
      57             : |*
      58             : \************************************************************************/
      59             : 
      60           0 : SvxLineStyleToolBoxControl::SvxLineStyleToolBoxControl( sal_uInt16 nSlotId,
      61             :                                                         sal_uInt16 nId,
      62             :                                                         ToolBox& rTbx ) :
      63             :     SfxToolBoxControl( nSlotId, nId, rTbx ),
      64             :     pStyleItem      ( NULL ),
      65             :     pDashItem       ( NULL ),
      66           0 :     bUpdate         ( false )
      67             : {
      68           0 :     addStatusListener( OUString( ".uno:LineDash" ));
      69           0 :     addStatusListener( OUString( ".uno:DashListState" ));
      70           0 : }
      71             : 
      72             : 
      73             : 
      74           0 : SvxLineStyleToolBoxControl::~SvxLineStyleToolBoxControl()
      75             : {
      76           0 :     delete pStyleItem;
      77           0 :     delete pDashItem;
      78           0 : }
      79             : 
      80             : 
      81             : 
      82           0 : void SvxLineStyleToolBoxControl::StateChanged (
      83             : 
      84             :     sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState )
      85             : 
      86             : {
      87           0 :     SvxLineBox* pBox = (SvxLineBox*)GetToolBox().GetItemWindow( GetId() );
      88             :     DBG_ASSERT( pBox, "Window not found!" );
      89             : 
      90           0 :     if( eState == SFX_ITEM_DISABLED )
      91             :     {
      92           0 :         pBox->Disable();
      93           0 :         pBox->SetNoSelection();
      94             :     }
      95             :     else
      96             :     {
      97           0 :         pBox->Enable();
      98             : 
      99           0 :         if ( eState == SFX_ITEM_AVAILABLE )
     100             :         {
     101           0 :             if( nSID == SID_ATTR_LINE_STYLE )
     102             :             {
     103           0 :                 delete pStyleItem;
     104           0 :                 pStyleItem = (XLineStyleItem*)pState->Clone();
     105             :             }
     106           0 :             else if( nSID == SID_ATTR_LINE_DASH )
     107             :             {
     108           0 :                 delete pDashItem;
     109           0 :                 pDashItem = (XLineDashItem*)pState->Clone();
     110             :             }
     111             : 
     112           0 :             bUpdate = true;
     113           0 :             Update( pState );
     114             :         }
     115           0 :         else if ( nSID != SID_DASH_LIST )
     116             :         {
     117             :             // no or ambiguous status
     118           0 :             pBox->SetNoSelection();
     119             :         }
     120             :     }
     121           0 : }
     122             : 
     123             : 
     124             : 
     125           0 : void SvxLineStyleToolBoxControl::Update( const SfxPoolItem* pState )
     126             : {
     127           0 :     if ( pState && bUpdate )
     128             :     {
     129           0 :         bUpdate = false;
     130             : 
     131           0 :         SvxLineBox* pBox = (SvxLineBox*)GetToolBox().GetItemWindow( GetId() );
     132             :         DBG_ASSERT( pBox, "Window not found!" );
     133             : 
     134             :         // Since the timer can strike unexpectedly, it may happen that
     135             :         // the LB is not yet filled. A ClearCache() on the control
     136             :         // in DelayHdl () was unsuccessful.
     137           0 :         if( pBox->GetEntryCount() == 0 )
     138           0 :             pBox->FillControl();
     139             : 
     140             :         XLineStyle eXLS;
     141             : 
     142           0 :         if ( pStyleItem )
     143           0 :             eXLS = ( XLineStyle )pStyleItem->GetValue();
     144             :         else
     145           0 :             eXLS = XLINE_NONE;
     146             : 
     147           0 :         switch( eXLS )
     148             :         {
     149             :             case XLINE_NONE:
     150           0 :                 pBox->SelectEntryPos( 0 );
     151           0 :                 break;
     152             : 
     153             :             case XLINE_SOLID:
     154           0 :                 pBox->SelectEntryPos( 1 );
     155           0 :                 break;
     156             : 
     157             :             case XLINE_DASH:
     158             :             {
     159           0 :                 if( pDashItem )
     160             :                 {
     161             :                     OUString aString = SvxUnogetInternalNameForItem(
     162           0 :                         XATTR_LINEDASH, pDashItem->GetName());
     163           0 :                     pBox->SelectEntry( aString );
     164             :                 }
     165             :                 else
     166           0 :                     pBox->SetNoSelection();
     167             :             }
     168           0 :             break;
     169             : 
     170             :             default:
     171             :                 OSL_FAIL( "Unsupported type of line" );
     172           0 :                 break;
     173             :         }
     174             :     }
     175             : 
     176           0 :     if ( pState && ( pState->ISA( SvxDashListItem ) ) )
     177             :     {
     178             :         // The list of line styles has changed
     179           0 :         SvxLineBox* pBox = (SvxLineBox*)GetToolBox().GetItemWindow( GetId() );
     180             :         DBG_ASSERT( pBox, "Window not found!" );
     181             : 
     182           0 :         OUString aString( pBox->GetSelectEntry() );
     183           0 :         pBox->Clear();
     184           0 :         pBox->InsertEntry( SVX_RESSTR(RID_SVXSTR_INVISIBLE) );
     185           0 :         pBox->InsertEntry( SVX_RESSTR(RID_SVXSTR_SOLID) );
     186           0 :         pBox->Fill( ((SvxDashListItem*)pState )->GetDashList() );
     187           0 :         pBox->SelectEntry( aString );
     188             :     }
     189           0 : }
     190             : 
     191             : 
     192             : 
     193           0 : Window* SvxLineStyleToolBoxControl::CreateItemWindow( Window *pParent )
     194             : {
     195           0 :     return new SvxLineBox( pParent, m_xFrame );
     196             : }
     197             : 
     198             : /*************************************************************************
     199             : |*
     200             : |* SvxLineWidthToolBoxControl
     201             : |*
     202             : \************************************************************************/
     203             : 
     204           0 : SvxLineWidthToolBoxControl::SvxLineWidthToolBoxControl(
     205             :     sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
     206           0 :     SfxToolBoxControl( nSlotId, nId, rTbx )
     207             : {
     208           0 :     addStatusListener( OUString( ".uno:MetricUnit" ));
     209           0 : }
     210             : 
     211             : 
     212             : 
     213           0 : SvxLineWidthToolBoxControl::~SvxLineWidthToolBoxControl()
     214             : {
     215           0 : }
     216             : 
     217             : 
     218             : 
     219           0 : void SvxLineWidthToolBoxControl::StateChanged(
     220             :     sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState )
     221             : {
     222             :     SvxMetricField* pFld = (SvxMetricField*)
     223           0 :                            GetToolBox().GetItemWindow( GetId() );
     224             :     DBG_ASSERT( pFld, "Window not found" );
     225             : 
     226           0 :     if ( nSID == SID_ATTR_METRIC )
     227             :     {
     228           0 :         pFld->RefreshDlgUnit();
     229             :     }
     230             :     else
     231             :     {
     232           0 :         if ( eState == SFX_ITEM_DISABLED )
     233             :         {
     234           0 :             pFld->Disable();
     235           0 :             pFld->SetText( "" );
     236             :         }
     237             :         else
     238             :         {
     239           0 :             pFld->Enable();
     240             : 
     241           0 :             if ( eState == SFX_ITEM_AVAILABLE )
     242             :             {
     243             :                 DBG_ASSERT( pState->ISA(XLineWidthItem), "wrong ItemType" );
     244             : 
     245             :                 // Core-Unit handed over to MetricField
     246             :                 // Should not happen in CreateItemWin ()!
     247           0 :                 SfxMapUnit eUnit = SFX_MAPUNIT_100TH_MM; // CD!!! GetCoreMetric();
     248           0 :                 pFld->SetCoreUnit( eUnit );
     249             : 
     250           0 :                 pFld->Update( (const XLineWidthItem*)pState );
     251             :             }
     252             :             else
     253           0 :                 pFld->Update( NULL );
     254             :         }
     255             :     }
     256           0 : }
     257             : 
     258             : 
     259             : 
     260           0 : Window* SvxLineWidthToolBoxControl::CreateItemWindow( Window *pParent )
     261             : {
     262           0 :     return( new SvxMetricField( pParent, m_xFrame ) );
     263             : }
     264             : 
     265             : /*************************************************************************
     266             : |*
     267             : |* SvxLineColorToolBoxControl
     268             : |*
     269             : \************************************************************************/
     270             : 
     271           0 : SvxLineColorToolBoxControl::SvxLineColorToolBoxControl(
     272             :     sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
     273           0 :     SfxToolBoxControl( nSlotId, nId, rTbx )
     274             : {
     275           0 :     addStatusListener( OUString( ".uno:ColorTableState" ));
     276           0 : }
     277             : 
     278             : 
     279             : 
     280           0 : SvxLineColorToolBoxControl::~SvxLineColorToolBoxControl()
     281             : {
     282           0 : }
     283             : 
     284             : 
     285             : 
     286           0 : void SvxLineColorToolBoxControl::StateChanged(
     287             : 
     288             :     sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState )
     289             : 
     290             : {
     291           0 :     SvxColorBox* pBox = (SvxColorBox*)GetToolBox().GetItemWindow( GetId() );
     292             :     DBG_ASSERT( pBox, "Window not found" );
     293             : 
     294           0 :     if ( nSID != SID_COLOR_TABLE )
     295             :     {
     296           0 :         if ( eState == SFX_ITEM_DISABLED )
     297             :         {
     298           0 :             pBox->Disable();
     299           0 :             pBox->SetNoSelection();
     300             :         }
     301             :         else
     302             :         {
     303           0 :             pBox->Enable();
     304             : 
     305           0 :             if ( eState == SFX_ITEM_AVAILABLE )
     306             :             {
     307             :                 DBG_ASSERT( pState->ISA(XLineColorItem), "wrong ItemType" );
     308           0 :                 pBox->Update( (const XLineColorItem*) pState );
     309             :             }
     310             :             else
     311           0 :                 pBox->Update( NULL );
     312             :         }
     313             :     }
     314             :     else
     315           0 :         Update( pState );
     316           0 : }
     317             : 
     318             : 
     319             : 
     320           0 : void SvxLineColorToolBoxControl::Update( const SfxPoolItem* pState )
     321             : {
     322           0 :     if ( pState && ( pState->ISA( SvxColorListItem ) ) )
     323             :     {
     324           0 :         SvxColorBox* pBox = (SvxColorBox*)GetToolBox().GetItemWindow( GetId() );
     325             : 
     326             :         DBG_ASSERT( pBox, "Window not found" );
     327             : 
     328             :         // The list of colors (ColorTable) has changed:
     329           0 :         ::Color aTmpColor( pBox->GetSelectEntryColor() );
     330           0 :         pBox->Clear();
     331           0 :         pBox->Fill( ( (SvxColorListItem*)pState )->GetColorList() );
     332           0 :         pBox->SelectEntry( aTmpColor );
     333             :     }
     334           0 : }
     335             : 
     336             : 
     337             : 
     338           0 : Window* SvxLineColorToolBoxControl::CreateItemWindow( Window *pParent )
     339             : {
     340           0 :     return new SvxColorBox( pParent, m_aCommandURL, m_xFrame );
     341             : }
     342             : 
     343             : /*************************************************************************
     344             : |*
     345             : |* SvxLineEndWindow
     346             : |*
     347             : \************************************************************************/
     348             : 
     349           0 : SvxLineEndWindow::SvxLineEndWindow(
     350             :     sal_uInt16 nSlotId,
     351             :     const Reference< XFrame >& rFrame,
     352             :     const OUString& rWndTitle ) :
     353             :     SfxPopupWindow( nSlotId,
     354             :                     rFrame,
     355             :                     WinBits( WB_STDPOPUP | WB_OWNERDRAWDECORATION ) ),
     356             :     aLineEndSet     ( this, WinBits( WB_ITEMBORDER | WB_3DLOOK | WB_NO_DIRECTSELECT ) ),
     357             :     nCols           ( 2 ),
     358             :     nLines          ( 12 ),
     359             :     nLineEndWidth   ( 400 ),
     360             :     bPopupMode      ( true ),
     361             :     mbInResize      ( false ),
     362           0 :     mxFrame         ( rFrame )
     363             : {
     364           0 :     SetText( rWndTitle );
     365           0 :     implInit();
     366           0 : }
     367             : 
     368           0 : SvxLineEndWindow::SvxLineEndWindow(
     369             :     sal_uInt16 nSlotId,
     370             :     const Reference< XFrame >& rFrame,
     371             :     Window* pParentWindow,
     372             :     const OUString& rWndTitle ) :
     373             :     SfxPopupWindow( nSlotId,
     374             :                     rFrame,
     375             :                     pParentWindow,
     376             :                     WinBits( WB_STDPOPUP | WB_OWNERDRAWDECORATION ) ),
     377             :     aLineEndSet     ( this, WinBits( WB_ITEMBORDER | WB_3DLOOK | WB_NO_DIRECTSELECT ) ),
     378             :     nCols           ( 2 ),
     379             :     nLines          ( 12 ),
     380             :     nLineEndWidth   ( 400 ),
     381             :     bPopupMode      ( true ),
     382             :     mbInResize      ( false ),
     383           0 :     mxFrame         ( rFrame )
     384             : {
     385           0 :     SetText( rWndTitle );
     386           0 :     implInit();
     387           0 : }
     388             : 
     389           0 : void SvxLineEndWindow::implInit()
     390             : {
     391           0 :     SfxObjectShell*     pDocSh  = SfxObjectShell::Current();
     392           0 :     const SfxPoolItem*  pItem   = NULL;
     393             : 
     394           0 :     SetHelpId( HID_POPUP_LINEEND );
     395           0 :     aLineEndSet.SetHelpId( HID_POPUP_LINEEND_CTRL );
     396             : 
     397           0 :     if ( pDocSh )
     398             :     {
     399           0 :         pItem = pDocSh->GetItem( SID_LINEEND_LIST );
     400           0 :         if( pItem )
     401           0 :             pLineEndList = ( (SvxLineEndListItem*) pItem )->GetLineEndList();
     402             : 
     403           0 :         pItem = pDocSh->GetItem( SID_ATTR_LINEEND_WIDTH_DEFAULT );
     404           0 :         if( pItem )
     405           0 :             nLineEndWidth = ( (SfxUInt16Item*) pItem )->GetValue();
     406             :     }
     407             :     DBG_ASSERT( pLineEndList.is(), "LineEndList not found" );
     408             : 
     409           0 :     aLineEndSet.SetSelectHdl( LINK( this, SvxLineEndWindow, SelectHdl ) );
     410           0 :     aLineEndSet.SetColCount( nCols );
     411             : 
     412             :     // ValueSet fill with entries of LineEndList
     413           0 :     FillValueSet();
     414             : 
     415           0 :     AddStatusListener( OUString( ".uno:LineEndListState" ));
     416             : 
     417             :     //ChangeHelpId( HID_POPUP_LINEENDSTYLE );
     418           0 :     aLineEndSet.Show();
     419           0 : }
     420             : 
     421           0 : SfxPopupWindow* SvxLineEndWindow::Clone() const
     422             : {
     423           0 :     return new SvxLineEndWindow( GetId(), mxFrame, GetText() );
     424             : }
     425             : 
     426             : 
     427             : 
     428           0 : SvxLineEndWindow::~SvxLineEndWindow()
     429             : {
     430           0 : }
     431             : 
     432             : 
     433             : 
     434           0 : IMPL_LINK_NOARG(SvxLineEndWindow, SelectHdl)
     435             : {
     436           0 :     XLineEndItem*           pLineEndItem = NULL;
     437           0 :     XLineStartItem*         pLineStartItem = NULL;
     438           0 :     sal_uInt16                  nId = aLineEndSet.GetSelectItemId();
     439             : 
     440           0 :     if( nId == 1 )
     441             :     {
     442           0 :         pLineStartItem  = new XLineStartItem();
     443             :     }
     444           0 :     else if( nId == 2 )
     445             :     {
     446           0 :         pLineEndItem    = new XLineEndItem();
     447             :     }
     448           0 :     else if( nId % 2 ) // beginning of line
     449             :     {
     450           0 :         XLineEndEntry* pEntry = pLineEndList->GetLineEnd( ( nId - 1 ) / 2 - 1 );
     451           0 :         pLineStartItem  = new XLineStartItem( pEntry->GetName(), pEntry->GetLineEnd() );
     452             :     }
     453             :     else // end of line
     454             :     {
     455           0 :         XLineEndEntry* pEntry = pLineEndList->GetLineEnd( nId / 2 - 2 );
     456           0 :         pLineEndItem    = new XLineEndItem( pEntry->GetName(), pEntry->GetLineEnd() );
     457             :     }
     458             : 
     459           0 :     if ( IsInPopupMode() )
     460           0 :         EndPopupMode();
     461             : 
     462           0 :     Sequence< PropertyValue > aArgs( 1 );
     463           0 :     Any a;
     464             : 
     465           0 :     if ( pLineStartItem )
     466             :     {
     467           0 :         aArgs[0].Name = "LineStart";
     468           0 :         pLineStartItem->QueryValue( a );
     469           0 :         aArgs[0].Value = a;
     470             :     }
     471             :     else
     472             :     {
     473           0 :         aArgs[0].Name = "LineEnd";
     474           0 :         pLineEndItem->QueryValue( a );
     475           0 :         aArgs[0].Value = a;
     476             :     }
     477             : 
     478             :     /*  #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
     479             :         This instance may be deleted in the meantime (i.e. when a dialog is opened
     480             :         while in Dispatch()), accessing members will crash in this case. */
     481           0 :     aLineEndSet.SetNoSelection();
     482             : 
     483           0 :     SfxToolBoxControl::Dispatch( Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
     484             :                                  OUString( ".uno:LineEndStyle" ),
     485           0 :                                  aArgs );
     486             : 
     487           0 :     delete pLineEndItem;
     488           0 :     delete pLineStartItem;
     489             : 
     490           0 :     return 0;
     491             : }
     492             : 
     493             : 
     494             : 
     495           0 : void SvxLineEndWindow::FillValueSet()
     496             : {
     497           0 :     if( pLineEndList.is() )
     498             :     {
     499           0 :         XLineEndEntry*      pEntry  = NULL;
     500           0 :         VirtualDevice       aVD;
     501             : 
     502           0 :         long nCount = pLineEndList->Count();
     503             : 
     504             :         // First entry: no line end.
     505             :         // An entry is temporarly added to get the UI bitmap
     506           0 :         basegfx::B2DPolyPolygon aNothing;
     507           0 :         pLineEndList->Insert( new XLineEndEntry( aNothing, SVX_RESSTR( RID_SVXSTR_NONE ) ) );
     508           0 :         pEntry = pLineEndList->GetLineEnd( nCount );
     509           0 :         Bitmap aBmp = pLineEndList->GetUiBitmap( nCount );
     510             :         OSL_ENSURE( !aBmp.IsEmpty(), "UI bitmap was not created" );
     511             : 
     512           0 :         aBmpSize = aBmp.GetSizePixel();
     513           0 :         aVD.SetOutputSizePixel( aBmpSize, false );
     514           0 :         aBmpSize.Width() = aBmpSize.Width() / 2;
     515           0 :         Point aPt0( 0, 0 );
     516           0 :         Point aPt1( aBmpSize.Width(), 0 );
     517             : 
     518           0 :         aVD.DrawBitmap( Point(), aBmp );
     519           0 :         aLineEndSet.InsertItem(1, Image(aVD.GetBitmap(aPt0, aBmpSize)), pEntry->GetName());
     520           0 :         aLineEndSet.InsertItem(2, Image(aVD.GetBitmap(aPt1, aBmpSize)), pEntry->GetName());
     521             : 
     522           0 :         delete pLineEndList->Remove( nCount );
     523             : 
     524           0 :         for( long i = 0; i < nCount; i++ )
     525             :         {
     526           0 :             pEntry = pLineEndList->GetLineEnd( i );
     527             :             DBG_ASSERT( pEntry, "Could not access LineEndEntry" );
     528           0 :             aBmp = pLineEndList->GetUiBitmap( i );
     529             :             OSL_ENSURE( !aBmp.IsEmpty(), "UI bitmap was not created" );
     530             : 
     531           0 :             aVD.DrawBitmap( aPt0, aBmp );
     532           0 :             aLineEndSet.InsertItem((sal_uInt16)((i+1L)*2L+1L),
     533           0 :                     Image(aVD.GetBitmap(aPt0, aBmpSize)), pEntry->GetName());
     534           0 :             aLineEndSet.InsertItem((sal_uInt16)((i+2L)*2L),
     535           0 :                     Image(aVD.GetBitmap(aPt1, aBmpSize)), pEntry->GetName());
     536             :         }
     537           0 :         nLines = std::min( (sal_uInt16)(nCount + 1), (sal_uInt16) MAX_LINES );
     538           0 :         aLineEndSet.SetLineCount( nLines );
     539             : 
     540           0 :         SetSize();
     541             :     }
     542           0 : }
     543             : 
     544             : 
     545             : 
     546           0 : void SvxLineEndWindow::Resize()
     547             : {
     548             :     // since we change the size inside this call, check if we
     549             :     // are called recursive
     550           0 :     if( !mbInResize )
     551             :     {
     552           0 :         mbInResize = true;
     553           0 :         if ( !IsRollUp() )
     554             :         {
     555           0 :             aLineEndSet.SetColCount( nCols );
     556           0 :             aLineEndSet.SetLineCount( nLines );
     557             : 
     558           0 :             SetSize();
     559             : 
     560           0 :             Size aSize = GetOutputSizePixel();
     561           0 :             aSize.Width()  -= 4;
     562           0 :             aSize.Height() -= 4;
     563           0 :             aLineEndSet.SetPosSizePixel( Point( 2, 2 ), aSize );
     564             :         }
     565             :         //SfxPopupWindow::Resize();
     566           0 :         mbInResize = false;
     567             :     }
     568           0 : }
     569             : 
     570             : 
     571             : 
     572           0 : void SvxLineEndWindow::Resizing( Size& rNewSize )
     573             : {
     574           0 :     Size aBitmapSize = aBmpSize; // -> Member
     575           0 :     aBitmapSize.Width()  += 6;
     576           0 :     aBitmapSize.Height() += 6;
     577             : 
     578           0 :     Size aItemSize = aLineEndSet.CalcItemSizePixel( aBitmapSize );  // -> Member
     579             :     //Size aOldSize = GetOutputSizePixel(); // for width
     580             : 
     581           0 :     sal_uInt16 nItemCount = aLineEndSet.GetItemCount(); // -> Member
     582             : 
     583             :     // identify columns
     584           0 :     long nItemW = aItemSize.Width();
     585           0 :     long nW = rNewSize.Width();
     586           0 :     nCols = (sal_uInt16) std::max( ( (sal_uIntPtr)(( nW + nItemW ) / ( nItemW * 2 ) )),
     587           0 :                                             (sal_uIntPtr) 1L );
     588           0 :     nCols *= 2;
     589             : 
     590             :     // identify lines
     591           0 :     long nItemH = aItemSize.Height();
     592           0 :     long nH = rNewSize.Height();
     593           0 :     nLines = (sal_uInt16) std::max( ( ( nH + nItemH / 2 ) / nItemH ), 1L );
     594             : 
     595           0 :     sal_uInt16 nMaxCols  = nItemCount / nLines;
     596           0 :     if( nItemCount % nLines )
     597           0 :         nMaxCols++;
     598           0 :     if( nCols > nMaxCols )
     599           0 :         nCols = nMaxCols;
     600           0 :     nW = nItemW * nCols;
     601             : 
     602             :     // No odd number of columns
     603           0 :     if( nCols % 2 )
     604           0 :         nCols--;
     605           0 :     nCols = std::max( nCols, (sal_uInt16) 2 );
     606             : 
     607           0 :     sal_uInt16 nMaxLines  = nItemCount / nCols;
     608           0 :     if( nItemCount % nCols )
     609           0 :         nMaxLines++;
     610           0 :     if( nLines > nMaxLines )
     611           0 :         nLines = nMaxLines;
     612           0 :     nH = nItemH * nLines;
     613             : 
     614           0 :     rNewSize.Width() = nW;
     615           0 :     rNewSize.Height() = nH;
     616           0 : }
     617             : 
     618             : 
     619           0 : void SvxLineEndWindow::StartSelection()
     620             : {
     621           0 :     aLineEndSet.StartSelection();
     622           0 : }
     623             : 
     624             : 
     625             : 
     626           0 : bool SvxLineEndWindow::Close()
     627             : {
     628           0 :     return SfxPopupWindow::Close();
     629             : }
     630             : 
     631             : 
     632             : 
     633           0 : void SvxLineEndWindow::StateChanged(
     634             :     sal_uInt16 nSID, SfxItemState, const SfxPoolItem* pState )
     635             : {
     636           0 :     if ( nSID == SID_LINEEND_LIST )
     637             :     {
     638             :         // The list of line ends (LineEndList) has changed
     639           0 :         if ( pState && pState->ISA( SvxLineEndListItem ))
     640             :         {
     641           0 :             pLineEndList = ((SvxLineEndListItem*)pState)->GetLineEndList();
     642             :             DBG_ASSERT( pLineEndList.is(), "LineEndList not found" );
     643             : 
     644           0 :             aLineEndSet.Clear();
     645           0 :             FillValueSet();
     646             : 
     647           0 :             Size aSize = GetOutputSizePixel();
     648           0 :             Resizing( aSize );
     649           0 :             Resize();
     650             :         }
     651             :     }
     652           0 : }
     653             : 
     654             : 
     655             : 
     656           0 : void SvxLineEndWindow::PopupModeEnd()
     657             : {
     658           0 :     if ( IsVisible() )
     659             :     {
     660           0 :         bPopupMode = false;
     661           0 :         SetSize();
     662             :     }
     663           0 :     SfxPopupWindow::PopupModeEnd();
     664           0 : }
     665             : 
     666             : 
     667             : 
     668           0 : void SvxLineEndWindow::SetSize()
     669             : {
     670             :     //if( !bPopupMode )
     671           0 :     if( !IsInPopupMode() )
     672             :     {
     673           0 :         sal_uInt16 nItemCount = aLineEndSet.GetItemCount(); // -> Member
     674           0 :         sal_uInt16 nMaxLines  = nItemCount / nCols; // -> Member ?
     675           0 :         if( nItemCount % nCols )
     676           0 :             nMaxLines++;
     677             : 
     678           0 :         WinBits nBits = aLineEndSet.GetStyle();
     679           0 :         if ( nLines == nMaxLines )
     680           0 :             nBits &= ~WB_VSCROLL;
     681             :         else
     682           0 :             nBits |= WB_VSCROLL;
     683           0 :         aLineEndSet.SetStyle( nBits );
     684             :     }
     685             : 
     686           0 :     Size aSize( aBmpSize );
     687           0 :     aSize.Width()  += 6;
     688           0 :     aSize.Height() += 6;
     689           0 :     aSize = aLineEndSet.CalcWindowSizePixel( aSize );
     690           0 :     aSize.Width()  += 4;
     691           0 :     aSize.Height() += 4;
     692           0 :     SetOutputSizePixel( aSize );
     693           0 :     aSize.Height() = aBmpSize.Height();
     694           0 :     aSize.Height() += 14;
     695             :     //SetMinOutputSizePixel( aSize );
     696           0 : }
     697             : 
     698           0 : void SvxLineEndWindow::GetFocus (void)
     699             : {
     700           0 :     SfxPopupWindow::GetFocus();
     701             :     // Grab the focus to the line ends value set so that it can be controlled
     702             :     // with the keyboard.
     703           0 :     aLineEndSet.GrabFocus();
     704           0 : }
     705             : 
     706             : /*************************************************************************
     707             : |*
     708             : |* SvxLineEndToolBoxControl
     709             : |*
     710             : \************************************************************************/
     711             : 
     712           0 : SvxLineEndToolBoxControl::SvxLineEndToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox &rTbx ) :
     713           0 :     SfxToolBoxControl( nSlotId, nId, rTbx )
     714             : {
     715           0 :     rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
     716           0 :     rTbx.Invalidate();
     717           0 : }
     718             : 
     719             : 
     720             : 
     721           0 : SvxLineEndToolBoxControl::~SvxLineEndToolBoxControl()
     722             : {
     723           0 : }
     724             : 
     725             : 
     726             : 
     727           0 : SfxPopupWindowType SvxLineEndToolBoxControl::GetPopupWindowType() const
     728             : {
     729           0 :     return SFX_POPUPWINDOW_ONCLICK;
     730             : }
     731             : 
     732             : 
     733             : 
     734           0 : SfxPopupWindow* SvxLineEndToolBoxControl::CreatePopupWindow()
     735             : {
     736             :     SvxLineEndWindow* pLineEndWin =
     737           0 :         new SvxLineEndWindow( GetId(), m_xFrame, &GetToolBox(), SVX_RESSTR( RID_SVXSTR_LINEEND ) );
     738           0 :     pLineEndWin->StartPopupMode( &GetToolBox(),
     739             :                                  FLOATWIN_POPUPMODE_GRABFOCUS |
     740             :                                  FLOATWIN_POPUPMODE_ALLOWTEAROFF |
     741           0 :                                  FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE );
     742           0 :     pLineEndWin->StartSelection();
     743           0 :     SetPopupWindow( pLineEndWin );
     744           0 :     return pLineEndWin;
     745             : }
     746             : 
     747             : 
     748             : 
     749           0 : void SvxLineEndToolBoxControl::StateChanged( sal_uInt16, SfxItemState eState, const SfxPoolItem* )
     750             : {
     751           0 :     sal_uInt16 nId = GetId();
     752           0 :     ToolBox& rTbx = GetToolBox();
     753             : 
     754           0 :     rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
     755           0 :     rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? TRISTATE_INDET : TRISTATE_FALSE );
     756           0 : }
     757             : 
     758             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10