LCOV - code coverage report
Current view: top level - svtools/source/hatchwindow - ipwin.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 86 319 27.0 %
Date: 2015-06-13 12:38:46 Functions: 11 23 47.8 %
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 <com/sun/star/accessibility/AccessibleRole.hpp>
      21             : 
      22             : #include <vcl/svapp.hxx>
      23             : #include <vcl/settings.hxx>
      24             : 
      25             : #include "ipwin.hxx"
      26             : #include <hatchwindow.hxx>
      27             : 
      28             : /************************************************************************/
      29             : /*************************************************************************
      30             : |*    SvResizeHelper::SvResizeHelper()
      31             : |*
      32             : |*    Description
      33             : *************************************************************************/
      34           1 : SvResizeHelper::SvResizeHelper()
      35             :     : aBorder( 5, 5 )
      36             :     , nGrab( -1 )
      37           1 :     , bResizeable( true )
      38             : {
      39           1 : }
      40             : 
      41             : /*************************************************************************
      42             : |*    SvResizeHelper::FillHandleRects()
      43             : |*
      44             : |*    Description: the eight handles to magnify
      45             : *************************************************************************/
      46           1 : void SvResizeHelper::FillHandleRectsPixel( Rectangle aRects[ 8 ] ) const
      47             : {
      48             :     // only because of EMPTY_RECT
      49           1 :     Point aBottomRight = aOuter.BottomRight();
      50             : 
      51             :     // upper left
      52           1 :     aRects[ 0 ] = Rectangle( aOuter.TopLeft(), aBorder );
      53             :     // upper middle
      54           3 :     aRects[ 1 ] = Rectangle( Point( aOuter.Center().X() - aBorder.Width() / 2,
      55             :                                     aOuter.Top() ),
      56           3 :                             aBorder );
      57             :     // upper right
      58           1 :     aRects[ 2 ] = Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
      59             :                                     aOuter.Top() ),
      60           2 :                             aBorder );
      61             :     // middle right
      62           1 :     aRects[ 3 ] = Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
      63           3 :                                     aOuter.Center().Y() - aBorder.Height() / 2 ),
      64           4 :                             aBorder );
      65             :     // lower right
      66           1 :     aRects[ 4 ] = Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
      67           1 :                                     aBottomRight.Y() - aBorder.Height() +1 ),
      68           3 :                             aBorder );
      69             :     // lower middle
      70           3 :     aRects[ 5 ] = Rectangle( Point( aOuter.Center().X() - aBorder.Width() / 2,
      71           1 :                                     aBottomRight.Y() - aBorder.Height() +1),
      72           4 :                             aBorder );
      73             :     // lower left
      74             :     aRects[ 6 ] = Rectangle( Point( aOuter.Left(),
      75           1 :                                     aBottomRight.Y() - aBorder.Height() +1),
      76           2 :                             aBorder );
      77             :     // middle left
      78             :     aRects[ 7 ] = Rectangle( Point( aOuter.Left(),
      79           3 :                                     aOuter.Center().Y() - aBorder.Height() / 2 ),
      80           3 :                             aBorder );
      81           1 : }
      82             : 
      83             : /*************************************************************************
      84             : |*    SvResizeHelper::FillMoveRectsPixel()
      85             : |*
      86             : |*    Description: the four edges are calculated
      87             : *************************************************************************/
      88           3 : void SvResizeHelper::FillMoveRectsPixel( Rectangle aRects[ 4 ] ) const
      89             : {
      90             :     // upper
      91           3 :     aRects[ 0 ] = aOuter;
      92           3 :     aRects[ 0 ].Bottom() = aRects[ 0 ].Top() + aBorder.Height() -1;
      93             :     // right
      94           3 :     aRects[ 1 ] = aOuter;
      95           3 :     aRects[ 1 ].Left() = aRects[ 1 ].Right() - aBorder.Width() -1;
      96             :     // lower
      97           3 :     aRects[ 2 ] = aOuter;
      98           3 :     aRects[ 2 ].Top() = aRects[ 2 ].Bottom() - aBorder.Height() -1;
      99             :     // left
     100           3 :     aRects[ 3 ] = aOuter;
     101           3 :     aRects[ 3 ].Right() = aRects[ 3 ].Left() + aBorder.Width() -1;
     102           3 : }
     103             : 
     104             : /*************************************************************************
     105             : |*    SvResizeHelper::Draw()
     106             : |*
     107             : |*    Description
     108             : *************************************************************************/
     109           1 : void SvResizeHelper::Draw(vcl::RenderContext& rRenderContext)
     110             : {
     111           1 :     rRenderContext.Push();
     112           1 :     rRenderContext.SetMapMode( MapMode() );
     113           1 :     Color aColBlack;
     114           1 :     Color aFillColor( COL_LIGHTGRAY );
     115             : 
     116           1 :     rRenderContext.SetFillColor( aFillColor );
     117           1 :     rRenderContext.SetLineColor();
     118             : 
     119           1 :     Rectangle aMoveRects[ 4 ];
     120           1 :     FillMoveRectsPixel( aMoveRects );
     121             :     sal_uInt16 i;
     122           5 :     for (i = 0; i < 4; i++)
     123           4 :         rRenderContext.DrawRect(aMoveRects[i]);
     124           1 :     if (bResizeable)
     125             :     {
     126             :         // draw handles
     127           1 :         rRenderContext.SetFillColor(aColBlack);
     128           1 :         Rectangle aRects[ 8 ];
     129           1 :         FillHandleRectsPixel(aRects);
     130           9 :         for (i = 0; i < 8; i++)
     131           8 :             rRenderContext.DrawRect( aRects[ i ] );
     132             :     }
     133           1 :     rRenderContext.Pop();
     134           1 : }
     135             : 
     136             : /*************************************************************************
     137             : |*    SvResizeHelper::InvalidateBorder()
     138             : |*
     139             : |*    Description
     140             : *************************************************************************/
     141           2 : void SvResizeHelper::InvalidateBorder( vcl::Window * pWin )
     142             : {
     143           2 :     Rectangle   aMoveRects[ 4 ];
     144           2 :     FillMoveRectsPixel( aMoveRects );
     145          10 :     for( sal_uInt16 i = 0; i < 4; i++ )
     146           8 :         pWin->Invalidate( aMoveRects[ i ] );
     147           2 : }
     148             : 
     149             : /*************************************************************************
     150             : |*    SvResizeHelper::SelectBegin()
     151             : |*
     152             : |*    Description
     153             : *************************************************************************/
     154           0 : bool SvResizeHelper::SelectBegin( vcl::Window * pWin, const Point & rPos )
     155             : {
     156           0 :     if( -1 == nGrab )
     157             :     {
     158           0 :         nGrab = SelectMove( pWin, rPos );
     159           0 :         if( -1 != nGrab )
     160             :         {
     161           0 :             aSelPos = rPos; // store start position
     162           0 :             pWin->CaptureMouse();
     163           0 :             return true;
     164             :         }
     165             :     }
     166           0 :     return false;
     167             : }
     168             : 
     169             : /*************************************************************************
     170             : |*    SvResizeHelper::SelectMove()
     171             : |*
     172             : |*    Description
     173             : *************************************************************************/
     174           0 : short SvResizeHelper::SelectMove( vcl::Window * pWin, const Point & rPos )
     175             : {
     176           0 :     if( -1 == nGrab )
     177             :     {
     178           0 :         if( bResizeable )
     179             :         {
     180           0 :             Rectangle aRects[ 8 ];
     181           0 :             FillHandleRectsPixel( aRects );
     182           0 :             for( sal_uInt16 i = 0; i < 8; i++ )
     183           0 :                 if( aRects[ i ].IsInside( rPos ) )
     184           0 :                     return i;
     185             :         }
     186             :         // Move-Rect overlaps Handles
     187           0 :         Rectangle aMoveRects[ 4 ];
     188           0 :         FillMoveRectsPixel( aMoveRects );
     189           0 :         for( sal_uInt16 i = 0; i < 4; i++ )
     190           0 :             if( aMoveRects[ i ].IsInside( rPos ) )
     191           0 :                 return 8;
     192             :     }
     193             :     else
     194             :     {
     195           0 :         Rectangle aRect( GetTrackRectPixel( rPos ) );
     196           0 :         aRect.SetSize( pWin->PixelToLogic( aRect.GetSize() ) );
     197           0 :         aRect.SetPos( pWin->PixelToLogic( aRect.TopLeft() ) );
     198           0 :         pWin->ShowTracking( aRect );
     199             :     }
     200           0 :     return nGrab;
     201             : }
     202             : 
     203           0 : Point SvResizeHelper::GetTrackPosPixel( const Rectangle & rRect ) const
     204             : {
     205             :     // not important how the rectangle is returned, it is important
     206             :     // which handle has been touched
     207           0 :     Point aPos;
     208           0 :     Rectangle aRect( rRect );
     209           0 :     aRect.Justify();
     210             :     // only because of EMPTY_RECT
     211           0 :     Point aBR = aOuter.BottomRight();
     212           0 :     Point aTR = aOuter.TopRight();
     213           0 :     Point aBL = aOuter.BottomLeft();
     214           0 :     bool bRTL = AllSettings::GetLayoutRTL();
     215           0 :     switch( nGrab )
     216             :     {
     217             :         case 0:
     218             :             // FIXME: disable it for RTL because it's wrong calculations
     219           0 :             if( bRTL )
     220           0 :                 break;
     221           0 :             aPos = aRect.TopLeft() - aOuter.TopLeft();
     222           0 :             break;
     223             :         case 1:
     224           0 :             aPos.Y() =  aRect.Top() - aOuter.Top();
     225           0 :             break;
     226             :         case 2:
     227             :             // FIXME: disable it for RTL because it's wrong calculations
     228           0 :             if( bRTL )
     229           0 :                 break;
     230           0 :             aPos =  aRect.TopRight() - aTR;
     231           0 :             break;
     232             :         case 3:
     233           0 :             if( bRTL )
     234           0 :                 aPos.X() = aRect.Left() - aTR.X();
     235             :             else
     236           0 :                 aPos.X() = aRect.Right() - aTR.X();
     237           0 :             break;
     238             :         case 4:
     239             :             // FIXME: disable it for RTL because it's wrong calculations
     240           0 :             if( bRTL )
     241           0 :                 break;
     242           0 :             aPos =  aRect.BottomRight() - aBR;
     243           0 :             break;
     244             :         case 5:
     245           0 :             aPos.Y() = aRect.Bottom() - aBR.Y();
     246           0 :             break;
     247             :         case 6:
     248             :             // FIXME: disable it for RTL because it's wrong calculations
     249           0 :             if( bRTL )
     250           0 :                 break;
     251           0 :             aPos =  aRect.BottomLeft() - aBL;
     252           0 :             break;
     253             :         case 7:
     254           0 :             if( bRTL )
     255           0 :                 aPos.X() = aRect.Right() + aOuter.Right() - aOuter.TopRight().X();
     256             :             else
     257           0 :                 aPos.X() = aRect.Left() - aOuter.Left();
     258           0 :             break;
     259             :         case 8:
     260           0 :             aPos = aRect.TopLeft() - aOuter.TopLeft();
     261           0 :             break;
     262             :     }
     263           0 :     return aPos += aSelPos;
     264             : }
     265             : 
     266             : /*************************************************************************
     267             : |*    SvResizeHelper::GetTrackRectPixel()
     268             : |*
     269             : |*    Description
     270             : *************************************************************************/
     271           0 : Rectangle SvResizeHelper::GetTrackRectPixel( const Point & rTrackPos ) const
     272             : {
     273           0 :     Rectangle aTrackRect;
     274           0 :     if( -1 != nGrab )
     275             :     {
     276           0 :         Point aDiff = rTrackPos - aSelPos;
     277           0 :         aTrackRect = aOuter;
     278           0 :         Point aBR = aOuter.BottomRight();
     279           0 :         bool bRTL = AllSettings::GetLayoutRTL();
     280           0 :         switch( nGrab )
     281             :         {
     282             :             case 0:
     283           0 :                 aTrackRect.Top() += aDiff.Y();
     284             :                 // ugly solution for resizing OLE objects in RTL
     285           0 :                 if( bRTL )
     286           0 :                     aTrackRect.Right() = aBR.X() - aDiff.X();
     287             :                 else
     288           0 :                     aTrackRect.Left() += aDiff.X();
     289           0 :                 break;
     290             :             case 1:
     291           0 :                 aTrackRect.Top() += aDiff.Y();
     292           0 :                 break;
     293             :             case 2:
     294           0 :                 aTrackRect.Top() += aDiff.Y();
     295             :                 // ugly solution for resizing OLE objects in RTL
     296           0 :                 if( bRTL )
     297           0 :                     aTrackRect.Left() -= aDiff.X();
     298             :                 else
     299           0 :                     aTrackRect.Right() = aBR.X() + aDiff.X();
     300           0 :                 break;
     301             :             case 3:
     302             :                 // ugly solution for resizing OLE objects in RTL
     303           0 :                 if( bRTL )
     304           0 :                     aTrackRect.Left() -= aDiff.X();
     305             :                 else
     306           0 :                     aTrackRect.Right() = aBR.X() + aDiff.X();
     307           0 :                 break;
     308             :             case 4:
     309           0 :                 aTrackRect.Bottom() = aBR.Y() + aDiff.Y();
     310             :                 // ugly solution for resizing OLE objects in RTL
     311           0 :                 if( bRTL )
     312           0 :                     aTrackRect.Left() -= aDiff.X();
     313             :                 else
     314           0 :                     aTrackRect.Right() = aBR.X() + aDiff.X();
     315           0 :                 break;
     316             :             case 5:
     317           0 :                 aTrackRect.Bottom() = aBR.Y() + aDiff.Y();
     318           0 :                 break;
     319             :             case 6:
     320           0 :                 aTrackRect.Bottom() = aBR.Y() + aDiff.Y();
     321             :                 // ugly solution for resizing OLE objects in RTL
     322           0 :                 if( bRTL )
     323           0 :                     aTrackRect.Right() = aBR.X() - aDiff.X();
     324             :                 else
     325           0 :                     aTrackRect.Left() += aDiff.X();
     326           0 :                 break;
     327             :             case 7:
     328             :                 // ugly solution for resizing OLE objects in RTL
     329           0 :                 if( bRTL )
     330           0 :                     aTrackRect.Right() = aBR.X() - aDiff.X();
     331             :                 else
     332           0 :                     aTrackRect.Left() += aDiff.X();
     333           0 :                 break;
     334             :             case 8:
     335           0 :                 if( bRTL )
     336           0 :                     aDiff.X() = -aDiff.X(); // workaround for move in RTL mode
     337           0 :                 aTrackRect.SetPos( aTrackRect.TopLeft() + aDiff );
     338           0 :                 break;
     339             :         }
     340             :     }
     341           0 :     return aTrackRect;
     342             : }
     343             : 
     344           0 : void SvResizeHelper::ValidateRect( Rectangle & rValidate ) const
     345             : {
     346           0 :     switch( nGrab )
     347             :     {
     348             :         case 0:
     349           0 :             if( rValidate.Top() > rValidate.Bottom() )
     350             :             {
     351           0 :                 rValidate.Top() = rValidate.Bottom();
     352           0 :                 rValidate.Bottom() = RECT_EMPTY;
     353             :             }
     354           0 :             if( rValidate.Left() > rValidate.Right() )
     355             :             {
     356           0 :                 rValidate.Left() = rValidate.Right();
     357           0 :                 rValidate.Right() = RECT_EMPTY;
     358             :             }
     359           0 :             break;
     360             :         case 1:
     361           0 :             if( rValidate.Top() > rValidate.Bottom() )
     362             :             {
     363           0 :                 rValidate.Top() = rValidate.Bottom();
     364           0 :                 rValidate.Bottom() = RECT_EMPTY;
     365             :             }
     366           0 :             break;
     367             :         case 2:
     368           0 :             if( rValidate.Top() > rValidate.Bottom() )
     369             :             {
     370           0 :                 rValidate.Top() = rValidate.Bottom();
     371           0 :                 rValidate.Bottom() = RECT_EMPTY;
     372             :             }
     373           0 :             if( rValidate.Left() > rValidate.Right() )
     374           0 :                 rValidate.Right() = RECT_EMPTY;
     375           0 :             break;
     376             :         case 3:
     377           0 :             if( rValidate.Left() > rValidate.Right() )
     378           0 :                 rValidate.Right() = RECT_EMPTY;
     379           0 :             break;
     380             :         case 4:
     381           0 :             if( rValidate.Top() > rValidate.Bottom() )
     382           0 :                 rValidate.Bottom() = RECT_EMPTY;
     383           0 :             if( rValidate.Left() > rValidate.Right() )
     384           0 :                 rValidate.Right() = RECT_EMPTY;
     385           0 :             break;
     386             :         case 5:
     387           0 :             if( rValidate.Top() > rValidate.Bottom() )
     388           0 :                 rValidate.Bottom() = RECT_EMPTY;
     389           0 :             break;
     390             :         case 6:
     391           0 :             if( rValidate.Top() > rValidate.Bottom() )
     392           0 :                 rValidate.Bottom() = RECT_EMPTY;
     393           0 :             if( rValidate.Left() > rValidate.Right() )
     394             :             {
     395           0 :                 rValidate.Left() = rValidate.Right();
     396           0 :                 rValidate.Right() = RECT_EMPTY;
     397             :             }
     398           0 :             break;
     399             :         case 7:
     400           0 :             if( rValidate.Left() > rValidate.Right() )
     401             :             {
     402           0 :                 rValidate.Left() = rValidate.Right();
     403           0 :                 rValidate.Right() = RECT_EMPTY;
     404             :             }
     405           0 :             break;
     406             :     }
     407           0 :     if( rValidate.Right() == RECT_EMPTY )
     408           0 :         rValidate.Right() = rValidate.Left();
     409           0 :     if( rValidate.Bottom() == RECT_EMPTY )
     410           0 :         rValidate.Bottom() = rValidate.Top();
     411             : 
     412             :     // Mindestgr"osse 5 x 5
     413           0 :     if( rValidate.Left() + 5 > rValidate.Right() )
     414           0 :         rValidate.Right() = rValidate.Left() +5;
     415           0 :     if( rValidate.Top() + 5 > rValidate.Bottom() )
     416           0 :         rValidate.Bottom() = rValidate.Top() +5;
     417           0 : }
     418             : 
     419             : /*************************************************************************
     420             : |*    SvResizeHelper::SelectRelease()
     421             : |*
     422             : |*    Description
     423             : *************************************************************************/
     424           0 : bool SvResizeHelper::SelectRelease( vcl::Window * pWin, const Point & rPos,
     425             :                                     Rectangle & rOutPosSize )
     426             : {
     427           0 :     if( -1 != nGrab )
     428             :     {
     429           0 :         rOutPosSize = GetTrackRectPixel( rPos );
     430           0 :         rOutPosSize.Justify();
     431           0 :         nGrab = -1;
     432           0 :         pWin->ReleaseMouse();
     433           0 :         pWin->HideTracking();
     434           0 :         return true;
     435             :     }
     436           0 :     return false;
     437             : }
     438             : 
     439             : /*************************************************************************
     440             : |*    SvResizeHelper::Release()
     441             : |*
     442             : |*    Description
     443             : *************************************************************************/
     444           0 : void SvResizeHelper::Release( vcl::Window * pWin )
     445             : {
     446           0 :     if( nGrab != -1 )
     447             :     {
     448           0 :         pWin->ReleaseMouse();
     449           0 :         pWin->HideTracking();
     450           0 :         nGrab = -1;
     451             :     }
     452           0 : }
     453             : 
     454             : /*************************************************************************
     455             : |*    SvResizeWindow::SvResizeWindow()
     456             : |*
     457             : |*    Description
     458             : *************************************************************************/
     459           1 : SvResizeWindow::SvResizeWindow
     460             : (
     461             :     vcl::Window * pParent,
     462             :     VCLXHatchWindow* pWrapper
     463             : )
     464             :     : Window( pParent, WB_CLIPCHILDREN )
     465             :     , m_nMoveGrab( -1 )
     466             :     , m_bActive( false )
     467           1 :     , m_pWrapper( pWrapper )
     468             : {
     469             :     OSL_ENSURE( pParent != NULL && pWrapper != NULL, "Wrong initialization of hatch window!\n" );
     470           1 :     SetBackground();
     471           1 :     SetAccessibleRole( ::com::sun::star::accessibility::AccessibleRole::EMBEDDED_OBJECT );
     472           1 :     m_aResizer.SetOuterRectPixel( Rectangle( Point(), GetOutputSizePixel() ) );
     473           1 : }
     474             : 
     475             : /*************************************************************************
     476             : |*    SvResizeWindow::SetHatchBorderPixel()
     477             : |*
     478             : |*    Description
     479             : *************************************************************************/
     480           3 : void SvResizeWindow::SetHatchBorderPixel( const Size & rSize )
     481             : {
     482           3 :      m_aResizer.SetBorderPixel( rSize );
     483           3 : }
     484             : 
     485             : /*************************************************************************
     486             : |*    SvResizeWindow::SelectMouse()
     487             : |*
     488             : |*    Description
     489             : *************************************************************************/
     490           0 : void SvResizeWindow::SelectMouse( const Point & rPos )
     491             : {
     492           0 :     short nGrab = m_aResizer.SelectMove( this, rPos );
     493           0 :     if( nGrab >= 4 )
     494           0 :         nGrab -= 4;
     495           0 :     if( m_nMoveGrab != nGrab )
     496             :     { // Pointer did change
     497           0 :         if( -1 == nGrab )
     498           0 :             SetPointer( m_aOldPointer );
     499             :         else
     500             :         {
     501           0 :             PointerStyle aStyle = PointerStyle::Move;
     502           0 :             if( nGrab == 3 )
     503           0 :                 aStyle = PointerStyle::ESize;
     504           0 :             else if( nGrab == 2 )
     505           0 :                 aStyle = PointerStyle::NESize;
     506           0 :             else if( nGrab == 1 )
     507           0 :                 aStyle = PointerStyle::SSize;
     508           0 :             else if( nGrab == 0 )
     509           0 :                 aStyle = PointerStyle::SESize;
     510           0 :             if( m_nMoveGrab == -1 ) // the first time
     511             :             {
     512           0 :                 m_aOldPointer = GetPointer();
     513           0 :                 SetPointer( Pointer( aStyle ) );
     514             :             }
     515             :             else
     516           0 :                 SetPointer( Pointer( aStyle ) );
     517             :         }
     518           0 :         m_nMoveGrab = nGrab;
     519             :     }
     520           0 : }
     521             : 
     522             : /*************************************************************************
     523             : |*    SvResizeWindow::MouseButtonDown()
     524             : |*
     525             : |*    Description
     526             : *************************************************************************/
     527           0 : void SvResizeWindow::MouseButtonDown( const MouseEvent & rEvt )
     528             : {
     529           0 :     if( m_aResizer.SelectBegin( this, rEvt.GetPosPixel() ) )
     530           0 :         SelectMouse( rEvt.GetPosPixel() );
     531           0 : }
     532             : 
     533             : /*************************************************************************
     534             : |*    SvResizeWindow::MouseMove()
     535             : |*
     536             : |*    Description
     537             : *************************************************************************/
     538           0 : void SvResizeWindow::MouseMove( const MouseEvent & rEvt )
     539             : {
     540           0 :     if( m_aResizer.GetGrab() == -1 )
     541           0 :         SelectMouse( rEvt.GetPosPixel() );
     542             :     else
     543             :     {
     544           0 :         Rectangle aRect( m_aResizer.GetTrackRectPixel( rEvt.GetPosPixel() ) );
     545           0 :         Point aDiff = GetPosPixel();
     546           0 :         aRect.SetPos( aRect.TopLeft() + aDiff );
     547           0 :         m_aResizer.ValidateRect( aRect );
     548             : 
     549           0 :         m_pWrapper->QueryObjAreaPixel( aRect );
     550           0 :         aRect.SetPos( aRect.TopLeft() - aDiff );
     551           0 :         Point aPos = m_aResizer.GetTrackPosPixel( aRect );
     552             : 
     553           0 :         SelectMouse( aPos );
     554             :     }
     555           0 : }
     556             : 
     557             : /*************************************************************************
     558             : |*    SvResizeWindow::MouseButtonUp()
     559             : |*
     560             : |*    Description
     561             : *************************************************************************/
     562           0 : void SvResizeWindow::MouseButtonUp( const MouseEvent & rEvt )
     563             : {
     564           0 :     if( m_aResizer.GetGrab() != -1 )
     565             :     {
     566           0 :         Rectangle aRect( m_aResizer.GetTrackRectPixel( rEvt.GetPosPixel() ) );
     567           0 :         Point aDiff = GetPosPixel();
     568           0 :         aRect.SetPos( aRect.TopLeft() + aDiff );
     569             :         // aRect -= GetAllBorderPixel();
     570           0 :         m_aResizer.ValidateRect( aRect );
     571             : 
     572           0 :         m_pWrapper->QueryObjAreaPixel( aRect );
     573             : 
     574           0 :         Rectangle aOutRect;
     575           0 :         if( m_aResizer.SelectRelease( this, rEvt.GetPosPixel(), aOutRect ) )
     576             :         {
     577           0 :             m_nMoveGrab = -1;
     578           0 :             SetPointer( m_aOldPointer );
     579           0 :             m_pWrapper->RequestObjAreaPixel( aRect );
     580             :         }
     581             :     }
     582           0 : }
     583             : 
     584             : /*************************************************************************
     585             : |*    SvResizeWindow::KeyEvent()
     586             : |*
     587             : |*    Description
     588             : *************************************************************************/
     589           0 : void SvResizeWindow::KeyInput( const KeyEvent & rEvt )
     590             : {
     591           0 :     if( rEvt.GetKeyCode().GetCode() == KEY_ESCAPE )
     592             :     {
     593           0 :         m_aResizer.Release( this );
     594           0 :         m_pWrapper->InplaceDeactivate();
     595             :     }
     596           0 : }
     597             : 
     598             : /*************************************************************************
     599             : |*    SvResizeWindow::Resize()
     600             : |*
     601             : |*    Description
     602             : *************************************************************************/
     603           1 : void SvResizeWindow::Resize()
     604             : {
     605           1 :     m_aResizer.InvalidateBorder( this ); // old area
     606           1 :     m_aResizer.SetOuterRectPixel( Rectangle( Point(), GetOutputSizePixel() ) );
     607           1 :     m_aResizer.InvalidateBorder( this ); // new area
     608           1 : }
     609             : 
     610             : /*************************************************************************
     611             : |*    SvResizeWindow::Paint()
     612             : |*
     613             : |*    Description
     614             : *************************************************************************/
     615           1 : void SvResizeWindow::Paint(vcl::RenderContext& rRenderContext, const Rectangle & /*rRect*/ )
     616             : {
     617           1 :     m_aResizer.Draw(rRenderContext);
     618           1 : }
     619             : 
     620           7 : bool SvResizeWindow::PreNotify( NotifyEvent& rEvt )
     621             : {
     622           7 :     if ( rEvt.GetType() == MouseNotifyEvent::GETFOCUS && !m_bActive )
     623             :     {
     624           1 :         m_bActive = true;
     625           1 :         m_pWrapper->Activated();
     626             :     }
     627             : 
     628           7 :     return Window::PreNotify(rEvt);
     629             : }
     630             : 
     631          19 : bool SvResizeWindow::Notify( NotifyEvent& rEvt )
     632             : {
     633          19 :     if ( rEvt.GetType() == MouseNotifyEvent::LOSEFOCUS && m_bActive )
     634             :     {
     635           3 :         bool bHasFocus = HasChildPathFocus(true);
     636           3 :         if ( !bHasFocus )
     637             :         {
     638           0 :             m_bActive = false;
     639           0 :             m_pWrapper->Deactivated();
     640             :         }
     641             :     }
     642             : 
     643          19 :     return Window::Notify(rEvt);
     644             : }
     645             : 
     646             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11