LCOV - code coverage report
Current view: top level - libreoffice/sd/source/ui/animations - DialogListBox.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 161 0.0 %
Date: 2012-12-27 Functions: 0 15 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 "DialogListBox.hxx"
      21             : 
      22             : namespace sd
      23             : {
      24             : 
      25           0 : DialogListBox::DialogListBox( Window* pParent, WinBits nWinStyle ) :
      26             :     Control( pParent, nWinStyle ),
      27           0 :     mpChild( 0 )
      28             : {
      29           0 :     mpVScrollBar    = new ScrollBar( this, WB_VSCROLL | WB_DRAG );
      30           0 :     mpHScrollBar    = new ScrollBar( this, WB_HSCROLL | WB_DRAG );
      31           0 :     mpScrollBarBox  = new ScrollBarBox( this );
      32             : 
      33           0 :     Link aLink( LINK( this, DialogListBox, ScrollBarHdl ) );
      34           0 :     mpVScrollBar->SetScrollHdl( aLink );
      35           0 :     mpHScrollBar->SetScrollHdl( aLink );
      36             : 
      37           0 :     mbVScroll       = false;
      38           0 :     mbHScroll       = false;
      39           0 :     mbAutoHScroll   = ( nWinStyle & WB_AUTOHSCROLL ) ? true : false;
      40           0 : }
      41             : 
      42             : // -----------------------------------------------------------------------
      43             : 
      44           0 : DialogListBox::~DialogListBox()
      45             : {
      46           0 :     delete mpHScrollBar;
      47           0 :     delete mpVScrollBar;
      48           0 :     delete mpScrollBarBox;
      49           0 :     delete mpChild;
      50           0 : }
      51             : 
      52             : // -----------------------------------------------------------------------
      53             : 
      54           0 : void DialogListBox::SetChildWindow( Window* pChild, const Size& rMinSize )
      55             : {
      56           0 :     if( mpChild )
      57           0 :         delete mpChild;
      58             : 
      59           0 :     mpChild = pChild;
      60           0 :     maMinSize = rMinSize;
      61           0 :     ImplResizeControls();
      62           0 :     ImplCheckScrollBars();
      63           0 : }
      64             : 
      65             : // -----------------------------------------------------------------------
      66             : 
      67           0 : void DialogListBox::GetFocus()
      68             : {
      69           0 :     if( mpChild )
      70           0 :         mpChild->GrabFocus();
      71           0 : }
      72             : 
      73             : // -----------------------------------------------------------------------
      74             : 
      75           0 : ::Window* DialogListBox::GetPreferredKeyInputWindow()
      76             : {
      77           0 :     if( mpChild )
      78           0 :         return mpChild;
      79             :     else
      80           0 :         return this;
      81             : }
      82             : 
      83             : // -----------------------------------------------------------------------
      84             : 
      85           0 : void DialogListBox::Resize()
      86             : {
      87           0 :     Control::Resize();
      88           0 :     ImplResizeControls();
      89           0 :     ImplCheckScrollBars();
      90           0 : }
      91             : 
      92             : // -----------------------------------------------------------------------
      93             : 
      94           0 : IMPL_LINK_NOARG(DialogListBox, ScrollBarHdl)
      95             : {
      96           0 :     ImplResizeChild();
      97           0 :     return 1;
      98             : }
      99             : 
     100             : // -----------------------------------------------------------------------
     101             : 
     102           0 : void DialogListBox::ImplCheckScrollBars()
     103             : {
     104           0 :     bool bArrange = false;
     105             : 
     106           0 :     Size aOutSz = GetOutputSizePixel();
     107             : 
     108             :     // vert. ScrollBar
     109           0 :     if( aOutSz.Height() < maMinSize.Height() )
     110             :     {
     111           0 :         if( !mbVScroll )
     112           0 :             bArrange = true;
     113           0 :         mbVScroll = true;
     114             :     }
     115             :     else
     116             :     {
     117           0 :         if( mbVScroll )
     118           0 :             bArrange = true;
     119           0 :         mbVScroll = false;
     120             :     }
     121             : 
     122             :     // horz. ScrollBar
     123           0 :     if( mbAutoHScroll )
     124             :     {
     125           0 :         long nWidth = aOutSz.Width();
     126           0 :         if ( mbVScroll )
     127           0 :             nWidth -= mpVScrollBar->GetSizePixel().Width();
     128           0 :         if( nWidth < maMinSize.Width() )
     129             :         {
     130           0 :             if( !mbHScroll )
     131           0 :                 bArrange = true;
     132           0 :             mbHScroll = true;
     133             : 
     134           0 :             if ( !mbVScroll )
     135             :             {
     136           0 :                 int nHeight = aOutSz.Height() - mpHScrollBar->GetSizePixel().Height();
     137           0 :                 if( nHeight < maMinSize.Height() )
     138             :                 {
     139           0 :                     if( !mbVScroll )
     140           0 :                         bArrange = true;
     141           0 :                     mbVScroll = true;
     142             :                 }
     143             :             }
     144             :         }
     145             :         else
     146             :         {
     147           0 :             if( mbHScroll )
     148           0 :                 bArrange = true;
     149           0 :             mbHScroll = false;
     150             :         }
     151             :     }
     152             : 
     153           0 :     if( bArrange )
     154           0 :         ImplResizeControls();
     155             : 
     156           0 :     ImplInitScrollBars();
     157           0 : }
     158             : 
     159             : // -----------------------------------------------------------------------
     160             : 
     161           0 : void DialogListBox::ImplInitScrollBars()
     162             : {
     163           0 :     if( mpChild )
     164             :     {
     165           0 :         Size aOutSize( GetOutputSizePixel() );
     166           0 :         if( mbHScroll ) aOutSize.Height() -= mpHScrollBar->GetSizePixel().Height();
     167           0 :         if( mbVScroll ) aOutSize.Width() -= mpVScrollBar->GetSizePixel().Width();
     168             : 
     169           0 :         if ( mbVScroll )
     170             :         {
     171           0 :             mpVScrollBar->SetRangeMax( maMinSize.Height() );
     172           0 :             mpVScrollBar->SetVisibleSize( aOutSize.Height() );
     173           0 :             mpVScrollBar->SetPageSize( 16 );
     174             :         }
     175             : 
     176           0 :         if ( mbHScroll )
     177             :         {
     178           0 :             mpHScrollBar->SetRangeMax( maMinSize.Width() );
     179           0 :             mpHScrollBar->SetVisibleSize( aOutSize.Width() );
     180           0 :             mpHScrollBar->SetPageSize( 16 );
     181             :         }
     182             :     }
     183           0 : }
     184             : 
     185             : // -----------------------------------------------------------------------
     186             : 
     187           0 : void DialogListBox::ImplResizeControls()
     188             : {
     189           0 :     Size aOutSz( GetOutputSizePixel() );
     190           0 :     long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
     191           0 :     nSBWidth = CalcZoom( nSBWidth );
     192             : 
     193           0 :     maInnerSize = aOutSz;
     194           0 :     if ( mbVScroll )
     195           0 :         maInnerSize.Width() -= nSBWidth;
     196           0 :     if ( mbHScroll )
     197           0 :         maInnerSize.Height() -= nSBWidth;
     198             : 
     199             :     // ScrollBarBox
     200           0 :     if( mbVScroll && mbHScroll )
     201             :     {
     202           0 :         Point aBoxPos( maInnerSize.Width(), maInnerSize.Height() );
     203           0 :         mpScrollBarBox->SetPosSizePixel( aBoxPos, Size( nSBWidth, nSBWidth ) );
     204           0 :         mpScrollBarBox->Show();
     205             :     }
     206             :     else
     207             :     {
     208           0 :         mpScrollBarBox->Hide();
     209             :     }
     210             : 
     211             :     // vert. ScrollBar
     212           0 :     if( mbVScroll )
     213             :     {
     214             :         // Scrollbar on left or right side?
     215           0 :         Point aVPos( aOutSz.Width() - nSBWidth, 0 );
     216           0 :         mpVScrollBar->SetPosSizePixel( aVPos, Size( nSBWidth, maInnerSize.Height() ) );
     217           0 :         mpVScrollBar->Show();
     218             :     }
     219             :     else
     220             :     {
     221           0 :         mpVScrollBar->Hide();
     222             :     }
     223             : 
     224             :     // horz. ScrollBar
     225           0 :     if( mbHScroll )
     226             :     {
     227           0 :         Point aHPos( 0, aOutSz.Height() - nSBWidth );
     228           0 :         mpHScrollBar->SetPosSizePixel( aHPos, Size( maInnerSize.Width(), nSBWidth ) );
     229           0 :         mpHScrollBar->Show();
     230             :     }
     231             :     else
     232             :     {
     233           0 :         mpHScrollBar->Hide();
     234             :     }
     235             : 
     236           0 :     ImplResizeChild();
     237           0 : }
     238             : 
     239           0 : void DialogListBox::ImplResizeChild()
     240             : {
     241           0 :     Point aWinPos;
     242           0 :     Size aSize( maInnerSize );
     243             : 
     244             :     int nOffset;
     245           0 :     if( mbHScroll )
     246             :     {
     247           0 :         nOffset = mpHScrollBar->GetThumbPos();
     248           0 :         aWinPos.X() = -nOffset;
     249           0 :         aSize.Width() += nOffset;
     250             :     }
     251             : 
     252           0 :     if( mbVScroll )
     253             :     {
     254           0 :         nOffset = mpVScrollBar->GetThumbPos();
     255           0 :         aWinPos.Y() = -nOffset;
     256           0 :         aSize.Height() += nOffset;
     257             :     }
     258             : 
     259           0 :     mpChild->SetPosSizePixel( aWinPos, aSize );
     260           0 : }
     261             : 
     262             : // -----------------------------------------------------------------------
     263             : 
     264           0 : void DialogListBox::StateChanged( StateChangedType nType )
     265             : {
     266           0 :     if ( nType == STATE_CHANGE_INITSHOW )
     267             :     {
     268           0 :         ImplCheckScrollBars();
     269             :     }
     270           0 :     else if ( ( nType == STATE_CHANGE_UPDATEMODE ) || ( nType == STATE_CHANGE_DATA ) )
     271             :     {
     272           0 :         sal_Bool bUpdate = IsUpdateMode();
     273           0 :         mpChild->SetUpdateMode( bUpdate );
     274           0 :         if ( bUpdate && IsReallyVisible() )
     275           0 :             ImplCheckScrollBars();
     276             :     }
     277           0 :     else if( nType == STATE_CHANGE_ENABLE )
     278             :     {
     279           0 :         mpHScrollBar->Enable( IsEnabled() );
     280           0 :         mpVScrollBar->Enable( IsEnabled() );
     281           0 :         mpScrollBarBox->Enable( IsEnabled() );
     282           0 :         Invalidate();
     283             :     }
     284           0 :     else if ( nType == STATE_CHANGE_ZOOM )
     285             :     {
     286           0 :         mpChild->SetZoom( GetZoom() );
     287           0 :         Resize();
     288             :     }
     289           0 :     else if ( nType == STATE_CHANGE_CONTROLFONT )
     290             :     {
     291           0 :         mpChild->SetControlFont( GetControlFont() );
     292             :     }
     293           0 :     else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
     294             :     {
     295           0 :         mpChild->SetControlForeground( GetControlForeground() );
     296             :     }
     297           0 :     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
     298             :     {
     299           0 :         mpChild->SetControlBackground( GetControlBackground() );
     300             :     }
     301           0 :     else if( nType == STATE_CHANGE_VISIBLE )
     302             :     {
     303           0 :         mpChild->Show( IsVisible() );
     304             :     }
     305             : 
     306           0 :     Control::StateChanged( nType );
     307           0 : }
     308             : 
     309             : // -----------------------------------------------------------------------
     310             : 
     311           0 : long DialogListBox::Notify( NotifyEvent& rNEvt )
     312             : {
     313           0 :     long nDone = 0;
     314           0 :     if ( rNEvt.GetType() == EVENT_COMMAND )
     315             :     {
     316           0 :         const CommandEvent& rCEvt = *rNEvt.GetCommandEvent();
     317           0 :         if ( rCEvt.GetCommand() == COMMAND_WHEEL )
     318             :         {
     319           0 :             const CommandWheelData* pData = rCEvt.GetWheelData();
     320           0 :             if( !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) )
     321             :             {
     322           0 :                 nDone = HandleScrollCommand( rCEvt, mpHScrollBar, mpVScrollBar );
     323             :             }
     324             :         }
     325             :     }
     326             : 
     327           0 :     return nDone ? nDone : Window::Notify( rNEvt );
     328             : }
     329             : 
     330             : } //  namespace sd
     331             : 
     332             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10