LCOV - code coverage report
Current view: top level - libreoffice/svtools/source/control - scrwin.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 87 191 45.5 %
Date: 2012-12-27 Functions: 6 16 37.5 %
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             : 
      21             : #define _SVT_SCRWIN_CXX
      22             : #include <svtools/scrwin.hxx>
      23             : 
      24             : //===================================================================
      25             : 
      26           4 : void ScrollableWindow::ImpInitialize( ScrollableWindowFlags nFlags )
      27             : {
      28           4 :     bHandleDragging = (sal_Bool) ( nFlags & SCRWIN_THUMBDRAGGING );
      29           4 :     bVCenter = (nFlags & SCRWIN_VCENTER) == SCRWIN_VCENTER;
      30           4 :     bHCenter = (nFlags & SCRWIN_HCENTER) == SCRWIN_HCENTER;
      31           4 :     bScrolling = sal_False;
      32             : 
      33             :     // set the handlers for the scrollbars
      34           4 :     aVScroll.SetScrollHdl( LINK(this, ScrollableWindow, ScrollHdl) );
      35           4 :     aHScroll.SetScrollHdl( LINK(this, ScrollableWindow, ScrollHdl) );
      36           4 :     aVScroll.SetEndScrollHdl( LINK(this, ScrollableWindow, EndScrollHdl) );
      37           4 :     aHScroll.SetEndScrollHdl( LINK(this, ScrollableWindow, EndScrollHdl) );
      38             : 
      39           4 :     nColumnPixW = nLinePixH = GetSettings().GetStyleSettings().GetScrollBarSize();
      40           4 : }
      41             : 
      42             : //-------------------------------------------------------------------
      43             : 
      44           4 : ScrollableWindow::ScrollableWindow( Window* pParent, WinBits nBits,
      45             :                                     ScrollableWindowFlags nFlags ) :
      46             :     Window( pParent, WinBits(nBits|WB_CLIPCHILDREN) ),
      47             :     aVScroll( this, WinBits(WB_VSCROLL | WB_DRAG) ),
      48             :     aHScroll( this, WinBits(WB_HSCROLL | WB_DRAG) ),
      49           4 :     aCornerWin( this )
      50             : {
      51           4 :     ImpInitialize( nFlags );
      52           4 : }
      53             : 
      54             : // -----------------------------------------------------------------------
      55             : 
      56           0 : void ScrollableWindow::Command( const CommandEvent& rCEvt )
      57             : {
      58           0 :     if ( (rCEvt.GetCommand() == COMMAND_WHEEL) ||
      59           0 :          (rCEvt.GetCommand() == COMMAND_STARTAUTOSCROLL) ||
      60           0 :          (rCEvt.GetCommand() == COMMAND_AUTOSCROLL) )
      61             :     {
      62             :         ScrollBar* pHScrBar;
      63             :         ScrollBar* pVScrBar;
      64           0 :         if ( aHScroll.IsVisible() )
      65           0 :             pHScrBar = &aHScroll;
      66             :         else
      67           0 :             pHScrBar = NULL;
      68           0 :         if ( aVScroll.IsVisible() )
      69           0 :             pVScrBar = &aVScroll;
      70             :         else
      71           0 :             pVScrBar = NULL;
      72           0 :         if ( HandleScrollCommand( rCEvt, pHScrBar, pVScrBar ) )
      73           0 :             return;
      74             :     }
      75             : 
      76           0 :     Window::Command( rCEvt );
      77             : }
      78             : 
      79             : //-------------------------------------------------------------------
      80             : 
      81           0 : void ScrollableWindow::DataChanged( const DataChangedEvent& rDCEvt )
      82             : {
      83           0 :     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
      84           0 :          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
      85             :     {
      86           0 :         Resize();
      87           0 :         Invalidate();
      88             :     }
      89             : 
      90           0 :     Window::DataChanged( rDCEvt );
      91           0 : }
      92             : 
      93             : //-------------------------------------------------------------------
      94             : 
      95           0 : Size ScrollableWindow::GetOutputSizePixel() const
      96             : {
      97           0 :     Size aSz( Window::GetOutputSizePixel() );
      98             : 
      99           0 :     long nTmp = GetSettings().GetStyleSettings().GetScrollBarSize();
     100           0 :     if ( aHScroll.IsVisible() )
     101           0 :         aSz.Height() -= nTmp;
     102           0 :     if ( aVScroll.IsVisible() )
     103           0 :         aSz.Width() -= nTmp;
     104           0 :     return aSz;
     105             : }
     106             : 
     107             : //-------------------------------------------------------------------
     108             : 
     109           0 : IMPL_LINK( ScrollableWindow, EndScrollHdl, ScrollBar *, pScroll )
     110             : {
     111             :     // notify the start of scrolling, if not already scrolling
     112           0 :     if ( !bScrolling )
     113           0 :         StartScroll(), bScrolling = sal_True;
     114             : 
     115             :     // get the delta in logic coordinates
     116           0 :     Size aDelta( PixelToLogic( Size( aHScroll.GetDelta(), aVScroll.GetDelta() ) ) );
     117             : 
     118             :     // scroll the window, if this is not already done
     119           0 :     if ( !bHandleDragging )
     120             :     {
     121           0 :         if ( pScroll == &aHScroll )
     122           0 :             Scroll( aDelta.Width(), 0 );
     123             :         else
     124           0 :             Scroll( 0, aDelta.Height() );
     125             :     }
     126             : 
     127             :     // notify the end of scrolling
     128           0 :     bScrolling = sal_False;
     129           0 :     EndScroll( aDelta.Width(), aDelta.Height() );
     130           0 :     return 0;
     131             : }
     132             : 
     133             : //-------------------------------------------------------------------
     134             : 
     135           0 : IMPL_LINK( ScrollableWindow, ScrollHdl, ScrollBar *, pScroll )
     136             : {
     137             :     // notify the start of scrolling, if not already scrolling
     138           0 :     if ( !bScrolling )
     139           0 :         StartScroll(), bScrolling = sal_True;
     140             : 
     141           0 :     if ( bHandleDragging )
     142             :     {
     143             :         // get the delta in logic coordinates
     144             :         Size aDelta( PixelToLogic(
     145           0 :             Size( aHScroll.GetDelta(), aVScroll.GetDelta() ) ) );
     146           0 :         if ( pScroll == &aHScroll )
     147           0 :             Scroll( aDelta.Width(), 0 );
     148             :         else
     149           0 :             Scroll( 0, aDelta.Height() );
     150             :     }
     151           0 :     return 0;
     152             : }
     153             : 
     154             : //-------------------------------------------------------------------
     155             : 
     156          16 : void ScrollableWindow::Resize()
     157             : {
     158             :     // get the new output-size in pixel
     159          16 :     Size aOutPixSz = Window::GetOutputSizePixel();
     160             : 
     161             :     // determine the size of the output-area and if we need scrollbars
     162          16 :     const long nScrSize = GetSettings().GetStyleSettings().GetScrollBarSize();
     163          16 :     sal_Bool bVVisible = sal_False; // by default no vertical-ScrollBar
     164          16 :     sal_Bool bHVisible = sal_False; // by default no horizontal-ScrollBar
     165             :     sal_Bool bChanged;          // determines if a visiblility was changed
     166          24 :     do
     167             :     {
     168          24 :         bChanged = sal_False;
     169             : 
     170             :         // does we need a vertical ScrollBar
     171          24 :         if ( aOutPixSz.Width() < aTotPixSz.Width() && !bHVisible )
     172           8 :         {   bHVisible = sal_True;
     173           8 :             aOutPixSz.Height() -= nScrSize;
     174           8 :             bChanged = sal_True;
     175             :         }
     176             : 
     177             :         // does we need a horizontal ScrollBar
     178          24 :         if ( aOutPixSz.Height() < aTotPixSz.Height() && !bVVisible )
     179           8 :         {   bVVisible = sal_True;
     180           8 :             aOutPixSz.Width() -= nScrSize;
     181           8 :             bChanged = sal_True;
     182             :         }
     183             : 
     184             :     }
     185             :     while ( bChanged );   // until no visibility has changed
     186             : 
     187             :     // store the old offset and map-mode
     188          16 :     MapMode aMap( GetMapMode() );
     189          16 :     Point aOldPixOffset( aPixOffset );
     190             : 
     191             :     // justify (right/bottom borders should never exceed the virtual window)
     192          16 :     Size aPixDelta;
     193          16 :     if ( aPixOffset.X() < 0 &&
     194           0 :          aPixOffset.X() + aTotPixSz.Width() < aOutPixSz.Width() )
     195           0 :         aPixDelta.Width() =
     196           0 :             aOutPixSz.Width() - ( aPixOffset.X() + aTotPixSz.Width() );
     197          16 :     if ( aPixOffset.Y() < 0 &&
     198           0 :          aPixOffset.Y() + aTotPixSz.Height() < aOutPixSz.Height() )
     199           0 :         aPixDelta.Height() =
     200           0 :             aOutPixSz.Height() - ( aPixOffset.Y() + aTotPixSz.Height() );
     201          16 :     if ( aPixDelta.Width() || aPixDelta.Height() )
     202             :     {
     203           0 :         aPixOffset.X() += aPixDelta.Width();
     204           0 :         aPixOffset.Y() += aPixDelta.Height();
     205             :     }
     206             : 
     207             :     // for axis without scrollbar restore the origin
     208          16 :     if ( !bVVisible || !bHVisible )
     209             :     {
     210             :         aPixOffset = Point(
     211             :                      bHVisible
     212           0 :                      ? aPixOffset.X()
     213             :                      : ( bHCenter
     214          16 :                             ? (aOutPixSz.Width()-aTotPixSz.Width()) / 2
     215             :                             : 0 ),
     216             :                      bVVisible
     217           0 :                      ? aPixOffset.Y()
     218             :                      : ( bVCenter
     219          16 :                             ? (aOutPixSz.Height()-aTotPixSz.Height()) / 2
     220          40 :                             : 0 ) );
     221             :     }
     222          16 :     if ( bHVisible && !aHScroll.IsVisible() )
     223           4 :         aPixOffset.X() = 0;
     224          16 :     if ( bVVisible && !aVScroll.IsVisible() )
     225           4 :         aPixOffset.Y() = 0;
     226             : 
     227             :     // select the shifted map-mode
     228          16 :     if ( aPixOffset != aOldPixOffset )
     229             :     {
     230           8 :         Window::SetMapMode( MapMode( MAP_PIXEL ) );
     231             :         Window::Scroll(
     232          16 :             aPixOffset.X() - aOldPixOffset.X(),
     233          24 :             aPixOffset.Y() - aOldPixOffset.Y() );
     234           8 :         SetMapMode( aMap );
     235             :     }
     236             : 
     237             :     // show or hide scrollbars
     238          16 :     aVScroll.Show( bVVisible );
     239          16 :     aHScroll.Show( bHVisible );
     240             : 
     241             :     // disable painting in the corner between the scrollbars
     242          16 :     if ( bVVisible && bHVisible )
     243             :     {
     244          16 :         aCornerWin.SetPosSizePixel(Point(aOutPixSz.Width(), aOutPixSz.Height()),
     245          24 :             Size(nScrSize, nScrSize) );
     246           8 :         aCornerWin.Show();
     247             :     }
     248             :     else
     249           8 :         aCornerWin.Hide();
     250             : 
     251             :     // resize scrollbars and set their ranges
     252          16 :     if ( bHVisible )
     253             :     {
     254             :         aHScroll.SetPosSizePixel(
     255           8 :             Point( 0, aOutPixSz.Height() ),
     256          16 :             Size( aOutPixSz.Width(), nScrSize ) );
     257           8 :         aHScroll.SetRange( Range( 0, aTotPixSz.Width() ) );
     258           8 :         aHScroll.SetPageSize( aOutPixSz.Width() );
     259           8 :         aHScroll.SetVisibleSize( aOutPixSz.Width() );
     260           8 :         aHScroll.SetLineSize( nColumnPixW );
     261           8 :         aHScroll.SetThumbPos( -aPixOffset.X() );
     262             :     }
     263          16 :     if ( bVVisible )
     264             :     {
     265             :         aVScroll.SetPosSizePixel(
     266           8 :             Point( aOutPixSz.Width(), 0 ),
     267          16 :             Size( nScrSize,aOutPixSz.Height() ) );
     268           8 :         aVScroll.SetRange( Range( 0, aTotPixSz.Height() ) );
     269           8 :         aVScroll.SetPageSize( aOutPixSz.Height() );
     270           8 :         aVScroll.SetVisibleSize( aOutPixSz.Height() );
     271           8 :         aVScroll.SetLineSize( nLinePixH );
     272           8 :         aVScroll.SetThumbPos( -aPixOffset.Y() );
     273          16 :     }
     274          16 : }
     275             : 
     276             : //-------------------------------------------------------------------
     277             : 
     278           0 : void ScrollableWindow::StartScroll()
     279             : {
     280           0 : }
     281             : 
     282             : //-------------------------------------------------------------------
     283             : 
     284           0 : void ScrollableWindow::EndScroll( long, long )
     285             : {
     286           0 : }
     287             : 
     288             : //-------------------------------------------------------------------
     289             : 
     290          24 : void ScrollableWindow::SetMapMode( const MapMode& rNewMapMode )
     291             : {
     292          24 :     MapMode aMap( rNewMapMode );
     293          24 :     aMap.SetOrigin( aMap.GetOrigin() + PixelToLogic( aPixOffset, aMap ) );
     294          24 :     Window::SetMapMode( aMap );
     295          24 : }
     296             : 
     297             : //-------------------------------------------------------------------
     298             : 
     299          16 : MapMode ScrollableWindow::GetMapMode() const
     300             : {
     301          16 :     MapMode aMap( Window::GetMapMode() );
     302          16 :     aMap.SetOrigin( aMap.GetOrigin() - PixelToLogic( aPixOffset ) );
     303          16 :     return aMap;
     304             : }
     305             : 
     306             : //-------------------------------------------------------------------
     307             : 
     308          11 : void ScrollableWindow::SetTotalSize( const Size& rNewSize )
     309             : {
     310          11 :     aTotPixSz = LogicToPixel( rNewSize );
     311          11 :     ScrollableWindow::Resize();
     312          11 : }
     313             : 
     314             : //-------------------------------------------------------------------
     315             : 
     316           0 : void ScrollableWindow::Scroll( long nDeltaX, long nDeltaY, sal_uInt16 )
     317             : {
     318           0 :     if ( !bScrolling )
     319           0 :         StartScroll();
     320             : 
     321             :     // get the delta in pixel
     322           0 :     Size aDeltaPix( LogicToPixel( Size(nDeltaX, nDeltaY) ) );
     323           0 :     Size aOutPixSz( GetOutputSizePixel() );
     324           0 :     MapMode aMap( GetMapMode() );
     325           0 :     Point aNewPixOffset( aPixOffset );
     326             : 
     327             :     // scrolling horizontally?
     328           0 :     if ( nDeltaX != 0 )
     329             :     {
     330           0 :         aNewPixOffset.X() -= aDeltaPix.Width();
     331           0 :         if ( ( aOutPixSz.Width() - aNewPixOffset.X() ) > aTotPixSz.Width() )
     332           0 :             aNewPixOffset.X() = - ( aTotPixSz.Width() - aOutPixSz.Width() );
     333           0 :         else if ( aNewPixOffset.X() > 0 )
     334           0 :             aNewPixOffset.X() = 0;
     335             :     }
     336             : 
     337             :     // scrolling vertically?
     338           0 :     if ( nDeltaY != 0 )
     339             :     {
     340           0 :         aNewPixOffset.Y() -= aDeltaPix.Height();
     341           0 :         if ( ( aOutPixSz.Height() - aNewPixOffset.Y() ) > aTotPixSz.Height() )
     342           0 :             aNewPixOffset.Y() = - ( aTotPixSz.Height() - aOutPixSz.Height() );
     343           0 :         else if ( aNewPixOffset.Y() > 0 )
     344           0 :             aNewPixOffset.Y() = 0;
     345             :     }
     346             : 
     347             :     // recompute the logical scroll units
     348           0 :     aDeltaPix.Width() = aPixOffset.X() - aNewPixOffset.X();
     349           0 :     aDeltaPix.Height() = aPixOffset.Y() - aNewPixOffset.Y();
     350           0 :     Size aDelta( PixelToLogic(aDeltaPix) );
     351           0 :     nDeltaX = aDelta.Width();
     352           0 :     nDeltaY = aDelta.Height();
     353           0 :     aPixOffset = aNewPixOffset;
     354             : 
     355             :     // scrolling?
     356           0 :     if ( nDeltaX != 0 || nDeltaY != 0 )
     357             :     {
     358           0 :         Update();
     359             : 
     360             :         // does the new area overlap the old one?
     361           0 :         if ( Abs( (int)aDeltaPix.Height() ) < aOutPixSz.Height() ||
     362           0 :              Abs( (int)aDeltaPix.Width() ) < aOutPixSz.Width() )
     363             :         {
     364             :             // scroll the overlapping area
     365           0 :             SetMapMode( aMap );
     366             : 
     367             :             // never scroll the scrollbars itself!
     368             :             Window::Scroll(-nDeltaX, -nDeltaY,
     369           0 :                 PixelToLogic( Rectangle( Point(0, 0), aOutPixSz ) ) );
     370             :         }
     371             :         else
     372             :         {
     373             :             // repaint all
     374           0 :             SetMapMode( aMap );
     375           0 :             Invalidate();
     376             :         }
     377             : 
     378           0 :         Update();
     379             :     }
     380             : 
     381           0 :     if ( !bScrolling )
     382             :     {
     383           0 :         EndScroll( nDeltaX, nDeltaY );
     384           0 :         if ( nDeltaX )
     385           0 :             aHScroll.SetThumbPos( -aPixOffset.X() );
     386           0 :         if ( nDeltaY )
     387           0 :             aVScroll.SetThumbPos( -aPixOffset.Y() );
     388           0 :     }
     389           0 : }
     390             : 
     391             : 
     392             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10