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

Generated by: LCOV version 1.10