LCOV - code coverage report
Current view: top level - svx/source/dialog - frmsel.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 667 0.0 %
Date: 2014-04-14 Functions: 0 95 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 <svx/frmsel.hxx>
      21             : #include <vcl/builder.hxx>
      22             : 
      23             : #include <algorithm>
      24             : #include <math.h>
      25             : #include "frmselimpl.hxx"
      26             : #include "AccessibleFrameSelector.hxx"
      27             : #include <svx/dialmgr.hxx>
      28             : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
      29             : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
      30             : #include <vcl/settings.hxx>
      31             : 
      32             : #include <svx/dialogs.hrc>
      33             : #include "frmsel.hrc"
      34             : 
      35             : #include <tools/rcid.h>
      36             : 
      37             : using namespace ::com::sun::star;
      38             : using namespace ::editeng;
      39             : 
      40             : namespace svx {
      41             : 
      42             : using ::com::sun::star::uno::Reference;
      43             : using ::com::sun::star::uno::Any;
      44             : using ::com::sun::star::accessibility::XAccessible;
      45             : using namespace ::com::sun::star::accessibility;
      46             : 
      47             : // global functions from framebordertype.hxx
      48             : 
      49           0 : FrameBorderType GetFrameBorderTypeFromIndex( size_t nIndex )
      50             : {
      51             :     DBG_ASSERT( nIndex < (size_t)FRAMEBORDERTYPE_COUNT,
      52             :         "svx::GetFrameBorderTypeFromIndex - invalid index" );
      53           0 :     return static_cast< FrameBorderType >( nIndex + 1 );
      54             : }
      55             : 
      56           0 : size_t GetIndexFromFrameBorderType( FrameBorderType eBorder )
      57             : {
      58             :     DBG_ASSERT( eBorder != FRAMEBORDER_NONE,
      59             :         "svx::GetIndexFromFrameBorderType - invalid frame border type" );
      60           0 :     return static_cast< size_t >( eBorder ) - 1;
      61             : }
      62             : 
      63             : 
      64             : 
      65             : namespace {
      66             : 
      67             : /** Space between outer control border and any graphical element of the control. */
      68             : const long FRAMESEL_GEOM_OUTER    = 2;
      69             : 
      70             : /** Space between arrows and usable inner area. */
      71             : const long FRAMESEL_GEOM_INNER    = 3;
      72             : 
      73             : /** Maximum width to draw a frame border style. */
      74             : const long FRAMESEL_GEOM_WIDTH    = 9;
      75             : 
      76             : /** Additional margin for click area of outer lines. */
      77             : const long FRAMESEL_GEOM_ADD_CLICK_OUTER = 5;
      78             : 
      79             : /** Additional margin for click area of inner lines. */
      80             : const long FRAMESEL_GEOM_ADD_CLICK_INNER = 2;
      81             : 
      82             : 
      83             : 
      84             : /** Returns the corresponding flag for a frame border. */
      85           0 : FrameSelFlags lclGetFlagFromType( FrameBorderType eBorder )
      86             : {
      87           0 :     switch( eBorder )
      88             :     {
      89           0 :         case FRAMEBORDER_LEFT:      return FRAMESEL_LEFT;
      90           0 :         case FRAMEBORDER_RIGHT:     return FRAMESEL_RIGHT;
      91           0 :         case FRAMEBORDER_TOP:       return FRAMESEL_TOP;
      92           0 :         case FRAMEBORDER_BOTTOM:    return FRAMESEL_BOTTOM;
      93           0 :         case FRAMEBORDER_HOR:       return FRAMESEL_INNER_HOR;
      94           0 :         case FRAMEBORDER_VER:       return FRAMESEL_INNER_VER;
      95           0 :         case FRAMEBORDER_TLBR:      return FRAMESEL_DIAG_TLBR;
      96           0 :         case FRAMEBORDER_BLTR:      return FRAMESEL_DIAG_BLTR;
      97           0 :         case FRAMEBORDER_NONE : break;
      98             :     }
      99           0 :     return FRAMESEL_NONE;
     100             : }
     101             : 
     102             : /** Merges the rSource polypolygon into the rDest polypolygon. */
     103           0 : inline void lclPolyPolyUnion( PolyPolygon& rDest, const PolyPolygon& rSource )
     104             : {
     105           0 :     const PolyPolygon aTmp( rDest );
     106           0 :     aTmp.GetUnion( rSource, rDest );
     107           0 : }
     108             : 
     109             : } // namespace
     110             : 
     111             : 
     112             : // FrameBorder
     113             : 
     114             : 
     115           0 : FrameBorder::FrameBorder( FrameBorderType eType ) :
     116             :     meType( eType ),
     117             :     meState( FRAMESTATE_HIDE ),
     118             :     meKeyLeft( FRAMEBORDER_NONE ),
     119             :     meKeyRight( FRAMEBORDER_NONE ),
     120             :     meKeyTop( FRAMEBORDER_NONE ),
     121             :     meKeyBottom( FRAMEBORDER_NONE ),
     122             :     mbEnabled( false ),
     123           0 :     mbSelected( false )
     124             : {
     125           0 : }
     126             : 
     127           0 : void FrameBorder::Enable( FrameSelFlags nFlags )
     128             : {
     129           0 :     mbEnabled = (nFlags & lclGetFlagFromType( meType )) != 0;
     130           0 :     if( !mbEnabled )
     131           0 :         SetState( FRAMESTATE_HIDE );
     132           0 : }
     133             : 
     134           0 : void FrameBorder::SetCoreStyle( const SvxBorderLine* pStyle )
     135             : {
     136           0 :     if( pStyle )
     137           0 :         maCoreStyle = *pStyle;
     138             :     else
     139           0 :         maCoreStyle = SvxBorderLine();
     140             : 
     141             :     // from twips to points
     142           0 :     maUIStyle.Set( maCoreStyle, 0.05, FRAMESEL_GEOM_WIDTH );
     143           0 :     meState = maUIStyle.Prim() ? FRAMESTATE_SHOW : FRAMESTATE_HIDE;
     144           0 : }
     145             : 
     146           0 : void FrameBorder::SetState( FrameBorderState eState )
     147             : {
     148           0 :     meState = eState;
     149           0 :     switch( meState )
     150             :     {
     151             :         case FRAMESTATE_SHOW:
     152             :             SAL_WARN( "svx.dialog", "svx::FrameBorder::SetState - use SetCoreStyle to make border visible" );
     153           0 :         break;
     154             :         case FRAMESTATE_HIDE:
     155           0 :             maCoreStyle = SvxBorderLine();
     156           0 :             maUIStyle.Clear();
     157           0 :         break;
     158             :         case FRAMESTATE_DONTCARE:
     159           0 :             maCoreStyle = SvxBorderLine();
     160           0 :             maUIStyle = frame::Style(3, 0, 0, table::BorderLineStyle::SOLID); //OBJ_FRAMESTYLE_DONTCARE
     161           0 :         break;
     162             :     }
     163           0 : }
     164             : 
     165           0 : void FrameBorder::AddFocusPolygon( const Polygon& rFocus )
     166             : {
     167           0 :     lclPolyPolyUnion( maFocusArea, rFocus );
     168           0 : }
     169             : 
     170           0 : void FrameBorder::MergeFocusToPolyPolygon( PolyPolygon& rPPoly ) const
     171             : {
     172           0 :     lclPolyPolyUnion( rPPoly, maFocusArea );
     173           0 : }
     174             : 
     175           0 : void FrameBorder::AddClickRect( const Rectangle& rRect )
     176             : {
     177           0 :     lclPolyPolyUnion( maClickArea, Polygon( rRect ) );
     178           0 : }
     179             : 
     180           0 : bool FrameBorder::ContainsClickPoint( const Point& rPos ) const
     181             : {
     182           0 :     return Region( maClickArea ).IsInside( rPos );
     183             : }
     184             : 
     185           0 : Rectangle FrameBorder::GetClickBoundRect() const
     186             : {
     187           0 :     return maClickArea.GetBoundRect();
     188             : }
     189             : 
     190           0 : void FrameBorder::SetKeyboardNeighbors(
     191             :         FrameBorderType eLeft, FrameBorderType eRight, FrameBorderType eTop, FrameBorderType eBottom )
     192             : {
     193           0 :     meKeyLeft = eLeft;
     194           0 :     meKeyRight = eRight;
     195           0 :     meKeyTop = eTop;
     196           0 :     meKeyBottom = eBottom;
     197           0 : }
     198             : 
     199           0 : FrameBorderType FrameBorder::GetKeyboardNeighbor( sal_uInt16 nKeyCode ) const
     200             : {
     201           0 :     FrameBorderType eBorder = FRAMEBORDER_NONE;
     202           0 :     switch( nKeyCode )
     203             :     {
     204           0 :         case KEY_LEFT:  eBorder = meKeyLeft;      break;
     205           0 :         case KEY_RIGHT: eBorder = meKeyRight;     break;
     206           0 :         case KEY_UP:    eBorder = meKeyTop;       break;
     207           0 :         case KEY_DOWN:  eBorder = meKeyBottom;    break;
     208             :         default:        SAL_WARN( "svx.dialog", "svx::FrameBorder::GetKeyboardNeighbor - unknown key code" );
     209             :     }
     210           0 :     return eBorder;
     211             : }
     212             : 
     213             : 
     214             : // FrameSelectorImpl
     215             : 
     216             : 
     217           0 : FrameSelectorImpl::FrameSelectorImpl( FrameSelector& rFrameSel ) :
     218           0 :     Resource( SVX_RES( RID_SVXSTR_BORDER_CONTROL ) ),
     219             :     mrFrameSel( rFrameSel ),
     220             :     maILArrows( 16 ),
     221             :     maLeft( FRAMEBORDER_LEFT ),
     222             :     maRight( FRAMEBORDER_RIGHT ),
     223             :     maTop( FRAMEBORDER_TOP ),
     224             :     maBottom( FRAMEBORDER_BOTTOM ),
     225             :     maHor( FRAMEBORDER_HOR ),
     226             :     maVer( FRAMEBORDER_VER ),
     227             :     maTLBR( FRAMEBORDER_TLBR ),
     228             :     maBLTR( FRAMEBORDER_BLTR ),
     229             :     mnFlags( FRAMESEL_OUTER ),
     230             :     mnCtrlSize( 0 ),
     231             :     mnArrowSize( 0 ),
     232             :     mnLine1( 0 ),
     233             :     mnLine2( 0 ),
     234             :     mnLine3( 0 ),
     235             :     mnFocusOffs( 0 ),
     236             :     mbHor( false ),
     237             :     mbVer( false ),
     238             :     mbTLBR( false ),
     239             :     mbBLTR( false ),
     240             :     mbFullRepaint( true ),
     241             :     mbAutoSelect( true ),
     242             :     mbClicked( false ),
     243             :     mbHCMode( false ),
     244             :     mpAccess( 0 ),
     245             :     maChildVec( 8, static_cast< a11y::AccFrameSelector* >( 0 ) ),
     246           0 :     mxChildVec( 8 )
     247             : {
     248           0 :     FreeResource();
     249             : 
     250           0 :     maAllBorders.resize( FRAMEBORDERTYPE_COUNT, 0 );
     251           0 :     maAllBorders[ GetIndexFromFrameBorderType( FRAMEBORDER_LEFT   ) ] = &maLeft;
     252           0 :     maAllBorders[ GetIndexFromFrameBorderType( FRAMEBORDER_RIGHT  ) ] = &maRight;
     253           0 :     maAllBorders[ GetIndexFromFrameBorderType( FRAMEBORDER_TOP    ) ] = &maTop;
     254           0 :     maAllBorders[ GetIndexFromFrameBorderType( FRAMEBORDER_BOTTOM ) ] = &maBottom;
     255           0 :     maAllBorders[ GetIndexFromFrameBorderType( FRAMEBORDER_HOR    ) ] = &maHor;
     256           0 :     maAllBorders[ GetIndexFromFrameBorderType( FRAMEBORDER_VER    ) ] = &maVer;
     257           0 :     maAllBorders[ GetIndexFromFrameBorderType( FRAMEBORDER_TLBR   ) ] = &maTLBR;
     258           0 :     maAllBorders[ GetIndexFromFrameBorderType( FRAMEBORDER_BLTR   ) ] = &maBLTR;
     259             : #if OSL_DEBUG_LEVEL >= 2
     260             :     {
     261             :         bool bOk = true;
     262             :         for( FrameBorderCIter aIt( maAllBorders ); bOk && aIt.Is(); bOk = (*aIt != 0), ++aIt );
     263             :         DBG_ASSERT( bOk, "svx::FrameSelectorImpl::FrameSelectorImpl - missing entry in maAllBorders" );
     264             :     }
     265             : #endif
     266             :     //                             left neighbor     right neighbor     upper neighbor    lower neighbor
     267           0 :     maLeft.SetKeyboardNeighbors(   FRAMEBORDER_NONE, FRAMEBORDER_TLBR,  FRAMEBORDER_TOP,  FRAMEBORDER_BOTTOM );
     268           0 :     maRight.SetKeyboardNeighbors(  FRAMEBORDER_BLTR, FRAMEBORDER_NONE,  FRAMEBORDER_TOP,  FRAMEBORDER_BOTTOM );
     269           0 :     maTop.SetKeyboardNeighbors(    FRAMEBORDER_LEFT, FRAMEBORDER_RIGHT, FRAMEBORDER_NONE, FRAMEBORDER_TLBR );
     270           0 :     maBottom.SetKeyboardNeighbors( FRAMEBORDER_LEFT, FRAMEBORDER_RIGHT, FRAMEBORDER_BLTR, FRAMEBORDER_NONE );
     271           0 :     maHor.SetKeyboardNeighbors(    FRAMEBORDER_LEFT, FRAMEBORDER_RIGHT, FRAMEBORDER_TLBR, FRAMEBORDER_BLTR );
     272           0 :     maVer.SetKeyboardNeighbors(    FRAMEBORDER_TLBR, FRAMEBORDER_BLTR,  FRAMEBORDER_TOP,  FRAMEBORDER_BOTTOM );
     273           0 :     maTLBR.SetKeyboardNeighbors(   FRAMEBORDER_LEFT, FRAMEBORDER_VER,   FRAMEBORDER_TOP,  FRAMEBORDER_HOR );
     274           0 :     maBLTR.SetKeyboardNeighbors(   FRAMEBORDER_VER,  FRAMEBORDER_RIGHT, FRAMEBORDER_HOR,  FRAMEBORDER_BOTTOM );
     275             : 
     276           0 :     Initialize(mnFlags);
     277           0 : }
     278             : 
     279           0 : FrameSelectorImpl::~FrameSelectorImpl()
     280             : {
     281           0 :     if( mpAccess )
     282           0 :         mpAccess->Invalidate();
     283           0 :     for( AccessibleImplVec::iterator aIt = maChildVec.begin(), aEnd = maChildVec.end(); aIt != aEnd; ++aIt )
     284           0 :         if( *aIt )
     285           0 :             (*aIt)->Invalidate();
     286           0 : }
     287             : 
     288             : // initialization -------------------------------------------------------------
     289             : 
     290           0 : void FrameSelectorImpl::Initialize( FrameSelFlags nFlags )
     291             : {
     292           0 :     mnFlags = nFlags;
     293             : 
     294           0 :     maEnabBorders.clear();
     295           0 :     for( FrameBorderIter aIt( maAllBorders ); aIt.Is(); ++aIt )
     296             :     {
     297           0 :         (*aIt)->Enable( mnFlags );
     298           0 :         if( (*aIt)->IsEnabled() )
     299           0 :             maEnabBorders.push_back( *aIt );
     300             :     }
     301           0 :     mbHor = maHor.IsEnabled();
     302           0 :     mbVer = maVer.IsEnabled();
     303           0 :     mbTLBR = maTLBR.IsEnabled();
     304           0 :     mbBLTR = maBLTR.IsEnabled();
     305             : 
     306           0 :     InitVirtualDevice();
     307           0 : }
     308             : 
     309           0 : void FrameSelectorImpl::InitColors()
     310             : {
     311           0 :     const StyleSettings& rSett = mrFrameSel.GetSettings().GetStyleSettings();
     312           0 :     maBackCol = rSett.GetFieldColor();
     313           0 :     mbHCMode = rSett.GetHighContrastMode();
     314           0 :     maArrowCol = rSett.GetFieldTextColor();
     315           0 :     maMarkCol.operator=( maBackCol ).Merge( maArrowCol, mbHCMode ? 0x80 : 0xC0 );
     316           0 :     maHCLineCol = rSett.GetLabelTextColor();
     317           0 : }
     318             : 
     319           0 : void FrameSelectorImpl::InitArrowImageList()
     320             : {
     321             :     /* Build the arrow images bitmap with current colors. */
     322           0 :     Color pColorAry1[3];
     323           0 :     Color pColorAry2[3];
     324           0 :     pColorAry1[0] = Color( 0, 0, 0 );
     325           0 :     pColorAry2[0] = maArrowCol;       // black -> arrow color
     326           0 :     pColorAry1[1] = Color( 0, 255, 0 );
     327           0 :     pColorAry2[1] = maMarkCol;        // green -> marker color
     328           0 :     pColorAry1[2] = Color( 255, 0, 255 );
     329           0 :     pColorAry2[2] = maBackCol;       // magenta -> background
     330             : 
     331           0 :     GetRes( SVX_RES( RID_SVXSTR_BORDER_CONTROL ).SetRT( RSC_RESOURCE ) );
     332             :     maILArrows.InsertFromHorizontalBitmap(
     333           0 :         SVX_RES( BMP_FRMSEL_ARROWS ), 16, NULL, pColorAry1, pColorAry2, 3);
     334           0 :     FreeResource();
     335             :     DBG_ASSERT( maILArrows.GetImageSize().Height() == maILArrows.GetImageSize().Width(),
     336             :         "svx::FrameSelectorImpl::InitArrowImageList - images are not squarish" );
     337           0 :     mnArrowSize = maILArrows.GetImageSize().Height();
     338           0 : }
     339             : 
     340           0 : void FrameSelectorImpl::InitGlobalGeometry()
     341             : {
     342           0 :     Size aCtrlSize( mrFrameSel.CalcOutputSize( mrFrameSel.GetSizePixel() ) );
     343             :     /*  nMinSize is the lower of width and height (control will always be squarish).
     344             :         FRAMESEL_GEOM_OUTER is the minimal distance between inner control border
     345             :         and any element. */
     346           0 :     long nMinSize = std::min( aCtrlSize.Width(), aCtrlSize.Height() ) - 2 * FRAMESEL_GEOM_OUTER;
     347             :     /*  nFixedSize is the size all existing elements need in one direction:
     348             :         the diag. arrow, space betw. arrow and frame border, outer frame border,
     349             :         inner frame border, other outer frame border, space betw. frame border
     350             :         and arrow, the other arrow. */
     351           0 :     long nFixedSize = 2 * mnArrowSize + 2 * FRAMESEL_GEOM_INNER + 3 * FRAMESEL_GEOM_WIDTH;
     352             :     /*  nBetwBordersSize contains the size between an outer and inner frame border (made odd). */
     353           0 :     long nBetwBordersSize = (((nMinSize - nFixedSize) / 2) - 1) | 1;
     354             : 
     355             :     /*  The final size of the usable area. */
     356           0 :     mnCtrlSize = 2 * nBetwBordersSize + nFixedSize;
     357           0 :     maVirDev.SetOutputSizePixel( Size( mnCtrlSize, mnCtrlSize ) );
     358             : 
     359             :     /*  Center the virtual device in the control. */
     360           0 :     maVirDevPos = Point( (aCtrlSize.Width() - mnCtrlSize) / 2, (aCtrlSize.Height() - mnCtrlSize) / 2 );
     361           0 : }
     362             : 
     363           0 : void FrameSelectorImpl::InitBorderGeometry()
     364             : {
     365             :     size_t nCol, nCols, nRow, nRows;
     366             : 
     367             :     // Global border geometry values ------------------------------------------
     368             : 
     369             :     /*  mnLine* is the middle point inside a frame border (i.e. mnLine1 is mid X inside left border). */
     370           0 :     mnLine1 = mnArrowSize + FRAMESEL_GEOM_INNER + FRAMESEL_GEOM_WIDTH / 2;
     371           0 :     mnLine2 = mnCtrlSize / 2;
     372           0 :     mnLine3 = 2 * mnLine2 - mnLine1;
     373             : 
     374             :     // Frame helper array -----------------------------------------------------
     375             : 
     376           0 :     maArray.Initialize( mbVer ? 2 : 1, mbHor ? 2 : 1 );
     377           0 :     maArray.SetUseDiagDoubleClipping( true );
     378             : 
     379           0 :     maArray.SetXOffset( mnLine1 );
     380           0 :     maArray.SetAllColWidths( (mbVer ? mnLine2 : mnLine3) - mnLine1 );
     381             : 
     382           0 :     maArray.SetYOffset( mnLine1 );
     383           0 :     maArray.SetAllRowHeights( (mbHor ? mnLine2 : mnLine3) - mnLine1 );
     384             : 
     385             :     // Focus polygons ---------------------------------------------------------
     386             : 
     387             :     /*  Width for focus rectangles from center of frame borders. */
     388           0 :     mnFocusOffs = FRAMESEL_GEOM_WIDTH / 2 + 1;
     389             : 
     390           0 :     maLeft.ClearFocusArea();
     391           0 :     maVer.ClearFocusArea();
     392           0 :     maRight.ClearFocusArea();
     393           0 :     maTop.ClearFocusArea();
     394           0 :     maHor.ClearFocusArea();
     395           0 :     maBottom.ClearFocusArea();
     396             : 
     397           0 :     maLeft.AddFocusPolygon(   Rectangle( mnLine1 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine1 + mnFocusOffs, mnLine3 + mnFocusOffs ) );
     398           0 :     maVer.AddFocusPolygon(    Rectangle( mnLine2 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine2 + mnFocusOffs, mnLine3 + mnFocusOffs ) );
     399           0 :     maRight.AddFocusPolygon(  Rectangle( mnLine3 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine3 + mnFocusOffs ) );
     400           0 :     maTop.AddFocusPolygon(    Rectangle( mnLine1 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine1 + mnFocusOffs ) );
     401           0 :     maHor.AddFocusPolygon(    Rectangle( mnLine1 - mnFocusOffs, mnLine2 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine2 + mnFocusOffs ) );
     402           0 :     maBottom.AddFocusPolygon( Rectangle( mnLine1 - mnFocusOffs, mnLine3 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine3 + mnFocusOffs ) );
     403             : 
     404           0 :     for( nCol = 0, nCols = maArray.GetColCount(); nCol < nCols; ++nCol )
     405             :     {
     406           0 :         for( nRow = 0, nRows = maArray.GetRowCount(); nRow < nRows; ++nRow )
     407             :         {
     408           0 :             Rectangle aRect( maArray.GetCellRect( nCol, nRow ) );
     409           0 :             long nDiagFocusOffsX = frame::GetTLDiagOffset( -mnFocusOffs, mnFocusOffs, maArray.GetHorDiagAngle( nCol, nRow ) );
     410           0 :             long nDiagFocusOffsY = frame::GetTLDiagOffset( -mnFocusOffs, mnFocusOffs, maArray.GetVerDiagAngle( nCol, nRow ) );
     411             : 
     412           0 :             std::vector< Point > aFocusVec;
     413           0 :             aFocusVec.push_back( Point( aRect.Left()  - mnFocusOffs,     aRect.Top()    + nDiagFocusOffsY ) );
     414           0 :             aFocusVec.push_back( Point( aRect.Left()  - mnFocusOffs,     aRect.Top()    - mnFocusOffs     ) );
     415           0 :             aFocusVec.push_back( Point( aRect.Left()  + nDiagFocusOffsX, aRect.Top()    - mnFocusOffs     ) );
     416           0 :             aFocusVec.push_back( Point( aRect.Right() + mnFocusOffs,     aRect.Bottom() - nDiagFocusOffsY ) );
     417           0 :             aFocusVec.push_back( Point( aRect.Right() + mnFocusOffs,     aRect.Bottom() + mnFocusOffs     ) );
     418           0 :             aFocusVec.push_back( Point( aRect.Right() - nDiagFocusOffsX, aRect.Bottom() + mnFocusOffs     ) );
     419           0 :             maTLBR.AddFocusPolygon( Polygon( static_cast< sal_uInt16 >( aFocusVec.size() ), &aFocusVec[ 0 ] ) );
     420             : 
     421           0 :             aFocusVec.clear();
     422           0 :             aFocusVec.push_back( Point( aRect.Right() + mnFocusOffs,     aRect.Top()    + nDiagFocusOffsY ) );
     423           0 :             aFocusVec.push_back( Point( aRect.Right() + mnFocusOffs,     aRect.Top()    - mnFocusOffs     ) );
     424           0 :             aFocusVec.push_back( Point( aRect.Right() - nDiagFocusOffsX, aRect.Top()    - mnFocusOffs     ) );
     425           0 :             aFocusVec.push_back( Point( aRect.Left()  - mnFocusOffs,     aRect.Bottom() - nDiagFocusOffsY ) );
     426           0 :             aFocusVec.push_back( Point( aRect.Left()  - mnFocusOffs,     aRect.Bottom() + mnFocusOffs     ) );
     427           0 :             aFocusVec.push_back( Point( aRect.Left()  + nDiagFocusOffsX, aRect.Bottom() + mnFocusOffs     ) );
     428           0 :             maBLTR.AddFocusPolygon( Polygon( static_cast< sal_uInt16 >( aFocusVec.size() ), &aFocusVec[ 0 ] ) );
     429           0 :         }
     430             :     }
     431             : 
     432             :     // Click areas ------------------------------------------------------------
     433             : 
     434           0 :     for( FrameBorderIter aIt( maAllBorders ); aIt.Is(); ++aIt )
     435           0 :         (*aIt)->ClearClickArea();
     436             : 
     437             :     /*  Additional space for click area: is added to the space available to draw
     438             :         the frame borders. For instance left frame border:
     439             :         - To left, top, and bottom always big additional space (outer area).
     440             :         - To right: Dependent on existence of inner vertical frame border
     441             :             (if enabled, use less space).
     442             :      */
     443           0 :     long nClO = FRAMESEL_GEOM_WIDTH / 2 + FRAMESEL_GEOM_ADD_CLICK_OUTER;
     444           0 :     long nClI = (mbTLBR && mbBLTR) ? (FRAMESEL_GEOM_WIDTH / 2 + FRAMESEL_GEOM_ADD_CLICK_INNER) : nClO;
     445           0 :     long nClH = mbHor ? nClI : nClO;            // additional space dependent of horizontal inner border
     446           0 :     long nClV = mbVer ? nClI : nClO;            // additional space dependent of vertical inner border
     447             : 
     448           0 :     maLeft.AddClickRect(   Rectangle( mnLine1 - nClO, mnLine1 - nClO, mnLine1 + nClV, mnLine3 + nClO ) );
     449           0 :     maVer.AddClickRect(    Rectangle( mnLine2 - nClI, mnLine1 - nClO, mnLine2 + nClI, mnLine3 + nClO ) );
     450           0 :     maRight.AddClickRect(  Rectangle( mnLine3 - nClV, mnLine1 - nClO, mnLine3 + nClO, mnLine3 + nClO ) );
     451           0 :     maTop.AddClickRect(    Rectangle( mnLine1 - nClO, mnLine1 - nClO, mnLine3 + nClO, mnLine1 + nClH ) );
     452           0 :     maHor.AddClickRect(    Rectangle( mnLine1 - nClO, mnLine2 - nClI, mnLine3 + nClO, mnLine2 + nClI ) );
     453           0 :     maBottom.AddClickRect( Rectangle( mnLine1 - nClO, mnLine3 - nClH, mnLine3 + nClO, mnLine3 + nClO ) );
     454             : 
     455             :     /*  Diagonal frame borders use the remaining space between outer and inner frame borders. */
     456           0 :     if( mbTLBR || mbBLTR )
     457             :     {
     458           0 :         for( nCol = 0, nCols = maArray.GetColCount(); nCol < nCols; ++nCol )
     459             :         {
     460           0 :             for( nRow = 0, nRows = maArray.GetRowCount(); nRow < nRows; ++nRow )
     461             :             {
     462             :                 // the usable area between horizonal/vertical frame borders of current quadrant
     463           0 :                 Rectangle aRect( maArray.GetCellRect( nCol, nRow ) );
     464           0 :                 aRect.Left() += nClV + 1;
     465           0 :                 aRect.Right() -= nClV + 1;
     466           0 :                 aRect.Top() += nClH + 1;
     467           0 :                 aRect.Bottom() -= nClH + 1;
     468             : 
     469             :                 /*  Both diagonal frame borders enabled. */
     470           0 :                 if( mbTLBR && mbBLTR )
     471             :                 {
     472             :                     // single areas
     473           0 :                     Point aMid( aRect.Center() );
     474           0 :                     maTLBR.AddClickRect( Rectangle( aRect.TopLeft(), aMid ) );
     475           0 :                     maTLBR.AddClickRect( Rectangle( aMid + Point( 1, 1 ), aRect.BottomRight() ) );
     476           0 :                     maBLTR.AddClickRect( Rectangle( aRect.Left(), aMid.Y() + 1, aMid.X(), aRect.Bottom() ) );
     477           0 :                     maBLTR.AddClickRect( Rectangle( aMid.X() + 1, aRect.Top(), aRect.Right(), aMid.Y() ) );
     478             :                     // centered rectangle for both frame borders
     479           0 :                     Rectangle aMidRect( aRect.TopLeft(), Size( aRect.GetWidth() / 3, aRect.GetHeight() / 3 ) );
     480           0 :                     aMidRect.Move( (aRect.GetWidth() - aMidRect.GetWidth()) / 2, (aRect.GetHeight() - aMidRect.GetHeight()) / 2 );
     481           0 :                     maTLBR.AddClickRect( aMidRect );
     482           0 :                     maBLTR.AddClickRect( aMidRect );
     483             :                 }
     484             :                 /*  One of the diagonal frame borders enabled - use entire rectangle. */
     485           0 :                 else if( mbTLBR && !mbBLTR )    // top-left to bottom-right only
     486           0 :                     maTLBR.AddClickRect( aRect );
     487           0 :                 else if( !mbTLBR && mbBLTR )    // bottom-left to top-right only
     488           0 :                     maBLTR.AddClickRect( aRect );
     489             :             }
     490             :         }
     491             :     }
     492           0 : }
     493             : 
     494           0 : void FrameSelectorImpl::InitVirtualDevice()
     495             : {
     496             :     // initialize resources
     497           0 :     InitColors();
     498           0 :     InitArrowImageList();
     499             : 
     500           0 :     sizeChanged();
     501           0 : }
     502             : 
     503           0 : void FrameSelectorImpl::sizeChanged()
     504             : {
     505             :     // initialize geometry
     506           0 :     InitGlobalGeometry();
     507           0 :     InitBorderGeometry();
     508             : 
     509             :     // correct background around the used area
     510           0 :     mrFrameSel.SetBackground( Wallpaper( maBackCol ) );
     511           0 :     DoInvalidate( true );
     512           0 : }
     513             : 
     514             : // frame border access --------------------------------------------------------
     515             : 
     516           0 : const FrameBorder& FrameSelectorImpl::GetBorder( FrameBorderType eBorder ) const
     517             : {
     518           0 :     size_t nIndex = GetIndexFromFrameBorderType( eBorder );
     519           0 :     if( nIndex < maAllBorders.size() )
     520           0 :         return *maAllBorders[ nIndex ];
     521             :     SAL_WARN( "svx.dialog", "svx::FrameSelectorImpl::GetBorder - unknown border type" );
     522           0 :     return maTop;
     523             : }
     524             : 
     525           0 : FrameBorder& FrameSelectorImpl::GetBorderAccess( FrameBorderType eBorder )
     526             : {
     527           0 :     return const_cast< FrameBorder& >( GetBorder( eBorder ) );
     528             : }
     529             : 
     530             : // drawing --------------------------------------------------------------------
     531             : 
     532           0 : void FrameSelectorImpl::DrawBackground()
     533             : {
     534             :     // clear the area
     535           0 :     maVirDev.SetLineColor();
     536           0 :     maVirDev.SetFillColor( maBackCol );
     537           0 :     maVirDev.DrawRect( Rectangle( Point( 0, 0 ), maVirDev.GetOutputSizePixel() ) );
     538             : 
     539             :     // draw the inner gray (or whatever color) rectangle
     540           0 :     maVirDev.SetLineColor();
     541           0 :     maVirDev.SetFillColor( maMarkCol );
     542             :     maVirDev.DrawRect( Rectangle(
     543           0 :         mnLine1 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine3 + mnFocusOffs ) );
     544             : 
     545             :     // draw the white space for enabled frame borders
     546           0 :     PolyPolygon aPPoly;
     547           0 :     for( FrameBorderCIter aIt( maEnabBorders ); aIt.Is(); ++aIt )
     548           0 :         (*aIt)->MergeFocusToPolyPolygon( aPPoly );
     549           0 :     aPPoly.Optimize( POLY_OPTIMIZE_CLOSE );
     550           0 :     maVirDev.SetLineColor( maBackCol );
     551           0 :     maVirDev.SetFillColor( maBackCol );
     552           0 :     maVirDev.DrawPolyPolygon( aPPoly );
     553           0 : }
     554             : 
     555           0 : void FrameSelectorImpl::DrawArrows( const FrameBorder& rBorder )
     556             : {
     557             :     DBG_ASSERT( rBorder.IsEnabled(), "svx::FrameSelectorImpl::DrawArrows - access to disabled border" );
     558             : 
     559           0 :     long nLinePos = 0;
     560           0 :     switch( rBorder.GetType() )
     561             :     {
     562             :         case FRAMEBORDER_LEFT:
     563           0 :         case FRAMEBORDER_TOP:       nLinePos = mnLine1; break;
     564             :         case FRAMEBORDER_VER:
     565           0 :         case FRAMEBORDER_HOR:       nLinePos = mnLine2; break;
     566             :         case FRAMEBORDER_RIGHT:
     567           0 :         case FRAMEBORDER_BOTTOM:    nLinePos = mnLine3; break;
     568             :         default: ; //prevent warning
     569             :     }
     570           0 :     nLinePos -= mnArrowSize / 2;
     571             : 
     572           0 :     long nTLPos = 0;
     573           0 :     long nBRPos = mnCtrlSize - mnArrowSize;
     574           0 :     Point aPos1, aPos2;
     575           0 :     sal_uInt16 nImgId1 = 0, nImgId2 = 0;
     576           0 :     switch( rBorder.GetType() )
     577             :     {
     578             :         case FRAMEBORDER_LEFT:
     579             :         case FRAMEBORDER_RIGHT:
     580             :         case FRAMEBORDER_VER:
     581           0 :             aPos1 = Point( nLinePos, nTLPos ); nImgId1 = 1;
     582           0 :             aPos2 = Point( nLinePos, nBRPos ); nImgId2 = 2;
     583           0 :         break;
     584             : 
     585             :         case FRAMEBORDER_TOP:
     586             :         case FRAMEBORDER_BOTTOM:
     587             :         case FRAMEBORDER_HOR:
     588           0 :             aPos1 = Point( nTLPos, nLinePos ); nImgId1 = 3;
     589           0 :             aPos2 = Point( nBRPos, nLinePos ); nImgId2 = 4;
     590           0 :         break;
     591             : 
     592             :         case FRAMEBORDER_TLBR:
     593           0 :             aPos1 = Point( nTLPos, nTLPos ); nImgId1 = 5;
     594           0 :             aPos2 = Point( nBRPos, nBRPos ); nImgId2 = 6;
     595           0 :         break;
     596             :         case FRAMEBORDER_BLTR:
     597           0 :             aPos1 = Point( nTLPos, nBRPos ); nImgId1 = 7;
     598           0 :             aPos2 = Point( nBRPos, nTLPos ); nImgId2 = 8;
     599           0 :         break;
     600             :         default: ; //prevent warning
     601             :     }
     602             : 
     603             :     // Arrow or marker? Do not draw arrows into disabled control.
     604           0 :     sal_uInt16 nSelectAdd = (mrFrameSel.IsEnabled() && rBorder.IsSelected()) ? 0 : 8;
     605           0 :     maVirDev.DrawImage( aPos1, maILArrows.GetImage( nImgId1 + nSelectAdd ) );
     606           0 :     maVirDev.DrawImage( aPos2, maILArrows.GetImage( nImgId2 + nSelectAdd ) );
     607           0 : }
     608             : 
     609           0 : void FrameSelectorImpl::DrawAllArrows()
     610             : {
     611           0 :     for( FrameBorderCIter aIt( maEnabBorders ); aIt.Is(); ++aIt )
     612           0 :         DrawArrows( **aIt );
     613           0 : }
     614             : 
     615           0 : Color FrameSelectorImpl::GetDrawLineColor( const Color& rColor ) const
     616             : {
     617           0 :     Color aColor( mbHCMode ? maHCLineCol : rColor );
     618           0 :     if( aColor == maBackCol )
     619           0 :         aColor.Invert();
     620           0 :     return aColor;
     621             : }
     622             : 
     623           0 : void FrameSelectorImpl::DrawAllFrameBorders()
     624             : {
     625             :     // Translate core colors to current UI colors (regards current background and HC mode).
     626           0 :     for( FrameBorderIter aIt( maEnabBorders ); aIt.Is(); ++aIt )
     627             :     {
     628           0 :         Color aCoreColorPrim = ((*aIt)->GetState() == FRAMESTATE_DONTCARE) ? maMarkCol : (*aIt)->GetCoreStyle().GetColorOut();
     629           0 :         Color aCoreColorSecn = ((*aIt)->GetState() == FRAMESTATE_DONTCARE) ? maMarkCol : (*aIt)->GetCoreStyle().GetColorIn();
     630           0 :         (*aIt)->SetUIColorPrim( GetDrawLineColor( aCoreColorPrim ) );
     631           0 :         (*aIt)->SetUIColorSecn( GetDrawLineColor( aCoreColorSecn ) );
     632             :     }
     633             : 
     634             :     // Copy all frame border styles to the helper array
     635           0 :     maArray.SetColumnStyleLeft( 0, maLeft.GetUIStyle() );
     636           0 :     if( mbVer ) maArray.SetColumnStyleLeft( 1, maVer.GetUIStyle() );
     637             : 
     638             :     // Invert the style for the right line
     639           0 :     const frame::Style rRightStyle = maRight.GetUIStyle( );
     640           0 :     frame::Style rInvertedRight( rRightStyle.GetColorPrim(),
     641           0 :             rRightStyle.GetColorSecn(), rRightStyle.GetColorGap(),
     642           0 :             rRightStyle.UseGapColor(),
     643             :             rRightStyle.Secn(), rRightStyle.Dist(), rRightStyle.Prim( ),
     644           0 :             rRightStyle.Type( ) );
     645           0 :     maArray.SetColumnStyleRight( mbVer ? 1 : 0, rInvertedRight );
     646             : 
     647           0 :     maArray.SetRowStyleTop( 0, maTop.GetUIStyle() );
     648           0 :     if( mbHor )
     649             :     {
     650             :         // Invert the style for the hor line to match the real borders
     651           0 :         const frame::Style rHorStyle = maHor.GetUIStyle();
     652           0 :         frame::Style rInvertedHor( rHorStyle.GetColorPrim(),
     653           0 :             rHorStyle.GetColorSecn(), rHorStyle.GetColorGap(),
     654           0 :             rHorStyle.UseGapColor(),
     655             :             rHorStyle.Secn(), rHorStyle.Dist(), rHorStyle.Prim( ),
     656           0 :             rHorStyle.Type() );
     657           0 :         maArray.SetRowStyleTop( 1, rInvertedHor );
     658             :     }
     659             : 
     660             :     // Invert the style for the bottom line
     661           0 :     const frame::Style rBottomStyle = maBottom.GetUIStyle( );
     662           0 :     frame::Style rInvertedBottom( rBottomStyle.GetColorPrim(),
     663           0 :             rBottomStyle.GetColorSecn(), rBottomStyle.GetColorGap(),
     664           0 :             rBottomStyle.UseGapColor(),
     665             :             rBottomStyle.Secn(), rBottomStyle.Dist(), rBottomStyle.Prim( ),
     666           0 :             rBottomStyle.Type() );
     667           0 :     maArray.SetRowStyleBottom( mbHor ? 1 : 0, rInvertedBottom );
     668             : 
     669           0 :     for( size_t nCol = 0; nCol < maArray.GetColCount(); ++nCol )
     670           0 :         for( size_t nRow = 0; nRow < maArray.GetRowCount(); ++nRow )
     671           0 :             maArray.SetCellStyleDiag( nCol, nRow, maTLBR.GetUIStyle(), maBLTR.GetUIStyle() );
     672             : 
     673             :     // Let the helper array draw itself
     674           0 :     maArray.DrawArray( maVirDev );
     675           0 : }
     676             : 
     677           0 : void FrameSelectorImpl::DrawVirtualDevice()
     678             : {
     679           0 :     DrawBackground();
     680           0 :     DrawAllArrows();
     681           0 :     DrawAllFrameBorders();
     682           0 :     mbFullRepaint = false;
     683           0 : }
     684             : 
     685           0 : void FrameSelectorImpl::CopyVirDevToControl()
     686             : {
     687           0 :     if( mbFullRepaint )
     688           0 :         DrawVirtualDevice();
     689           0 :     mrFrameSel.DrawBitmap( maVirDevPos, maVirDev.GetBitmap( Point( 0, 0 ), maVirDev.GetOutputSizePixel() ) );
     690           0 : }
     691             : 
     692           0 : void FrameSelectorImpl::DrawAllTrackingRects()
     693             : {
     694           0 :     PolyPolygon aPPoly;
     695           0 :     if( mrFrameSel.IsAnyBorderSelected() )
     696             :     {
     697           0 :         for( SelFrameBorderCIter aIt( maEnabBorders ); aIt.Is(); ++aIt )
     698           0 :             (*aIt)->MergeFocusToPolyPolygon( aPPoly );
     699           0 :         aPPoly.Move( maVirDevPos.X(), maVirDevPos.Y() );
     700             :     }
     701             :     else
     702             :         // no frame border selected -> draw tracking rectangle around entire control
     703           0 :         aPPoly.Insert( Polygon( Rectangle( maVirDevPos, maVirDev.GetOutputSizePixel() ) ) );
     704             : 
     705           0 :     aPPoly.Optimize( POLY_OPTIMIZE_CLOSE );
     706           0 :     for( sal_uInt16 nIdx = 0, nCount = aPPoly.Count(); nIdx < nCount; ++nIdx )
     707           0 :         mrFrameSel.InvertTracking( aPPoly.GetObject( nIdx ), SHOWTRACK_SMALL | SHOWTRACK_WINDOW );
     708           0 : }
     709             : 
     710           0 : Point FrameSelectorImpl::GetDevPosFromMousePos( const Point& rMousePos ) const
     711             : {
     712           0 :     return rMousePos - maVirDevPos;
     713             : }
     714             : 
     715           0 : void FrameSelectorImpl::DoInvalidate( bool bFullRepaint )
     716             : {
     717           0 :     mbFullRepaint |= bFullRepaint;
     718           0 :     mrFrameSel.Invalidate( INVALIDATE_NOERASE );
     719           0 : }
     720             : 
     721             : // frame border state and style -----------------------------------------------
     722             : 
     723           0 : void FrameSelectorImpl::SetBorderState( FrameBorder& rBorder, FrameBorderState eState )
     724             : {
     725             :     DBG_ASSERT( rBorder.IsEnabled(), "svx::FrameSelectorImpl::SetBorderState - access to disabled border" );
     726           0 :     Any aOld;
     727           0 :     Any aNew;
     728           0 :     Any& rMod = eState == FRAMESTATE_SHOW ? aNew : aOld;
     729           0 :     rMod <<= AccessibleStateType::CHECKED;
     730           0 :     Reference< XAccessible > xRet;
     731           0 :     size_t nVecIdx = static_cast< size_t >( rBorder.GetType() );
     732           0 :     if( GetBorder(rBorder.GetType()).IsEnabled() && (1 <= nVecIdx) && (nVecIdx <= maChildVec.size()) )
     733           0 :         xRet = mxChildVec[ --nVecIdx ];
     734           0 :     a11y::AccFrameSelector* pFrameSelector = static_cast<a11y::AccFrameSelector*>(xRet.get());
     735             : 
     736           0 :     if( eState == FRAMESTATE_SHOW )
     737           0 :         SetBorderCoreStyle( rBorder, &maCurrStyle );
     738             :     else
     739           0 :         rBorder.SetState( eState );
     740           0 :     if (pFrameSelector)
     741           0 :             pFrameSelector->NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOld, aNew );
     742           0 :     DoInvalidate( true );
     743           0 : }
     744             : 
     745           0 : void FrameSelectorImpl::SetBorderCoreStyle( FrameBorder& rBorder, const SvxBorderLine* pStyle )
     746             : {
     747             :     DBG_ASSERT( rBorder.IsEnabled(), "svx::FrameSelectorImpl::SetBorderCoreStyle - access to disabled border" );
     748           0 :     rBorder.SetCoreStyle( pStyle );
     749           0 :     DoInvalidate( true );
     750           0 : }
     751             : 
     752           0 : void FrameSelectorImpl::ToggleBorderState( FrameBorder& rBorder )
     753             : {
     754           0 :     bool bDontCare = mrFrameSel.SupportsDontCareState();
     755           0 :     switch( rBorder.GetState() )
     756             :     {
     757             :         // same order as tristate check box: visible -> don't care -> hidden
     758             :         case FRAMESTATE_SHOW:
     759           0 :             SetBorderState( rBorder, bDontCare ? FRAMESTATE_DONTCARE : FRAMESTATE_HIDE );
     760           0 :         break;
     761             :         case FRAMESTATE_HIDE:
     762           0 :             SetBorderState( rBorder, FRAMESTATE_SHOW );
     763           0 :         break;
     764             :         case FRAMESTATE_DONTCARE:
     765           0 :             SetBorderState( rBorder, FRAMESTATE_HIDE );
     766           0 :         break;
     767             :     }
     768           0 : }
     769             : 
     770             : // frame border selection -----------------------------------------------------
     771             : 
     772           0 : void FrameSelectorImpl::SelectBorder( FrameBorder& rBorder, bool bSelect )
     773             : {
     774             :     DBG_ASSERT( rBorder.IsEnabled(), "svx::FrameSelectorImpl::SelectBorder - access to disabled border" );
     775           0 :     rBorder.Select( bSelect );
     776           0 :     DrawArrows( rBorder );
     777           0 :     DoInvalidate( false );
     778           0 : }
     779             : 
     780           0 : void FrameSelectorImpl::SilentGrabFocus()
     781             : {
     782           0 :     bool bOldAuto = mbAutoSelect;
     783           0 :     mbAutoSelect = false;
     784           0 :     mrFrameSel.GrabFocus();
     785           0 :     mbAutoSelect = bOldAuto;
     786           0 : }
     787             : 
     788           0 : bool FrameSelectorImpl::SelectedBordersEqual() const
     789             : {
     790           0 :     bool bEqual = true;
     791           0 :     SelFrameBorderCIter aIt( maEnabBorders );
     792           0 :     if( aIt.Is() )
     793             :     {
     794           0 :         const SvxBorderLine& rFirstStyle = (*aIt)->GetCoreStyle();
     795           0 :         for( ++aIt; bEqual && aIt.Is(); ++aIt )
     796           0 :             bEqual = ((*aIt)->GetCoreStyle() == rFirstStyle);
     797             :     }
     798           0 :     return bEqual;
     799             : }
     800             : 
     801             : 
     802             : // FrameSelector
     803             : 
     804             : 
     805           0 : FrameSelector::FrameSelector(Window* pParent)
     806           0 :     : Control(pParent, WB_BORDER|WB_TABSTOP)
     807             : {
     808             :     // not in c'tor init list (avoid warning about usage of *this)
     809           0 :     mxImpl.reset( new FrameSelectorImpl( *this ) );
     810           0 :     EnableRTL( false ); // #107808# don't mirror the mouse handling
     811           0 : }
     812             : 
     813           0 : extern "C" SAL_DLLPUBLIC_EXPORT Window* SAL_CALL makeSvxFrameSelector(Window *pParent, VclBuilder::stringmap &)
     814             : {
     815           0 :     return new FrameSelector(pParent);
     816             : }
     817             : 
     818           0 : FrameSelector::~FrameSelector()
     819             : {
     820           0 : }
     821             : 
     822           0 : void FrameSelector::Initialize( FrameSelFlags nFlags )
     823             : {
     824           0 :     mxImpl->Initialize( nFlags );
     825           0 :     Show();
     826           0 : }
     827             : 
     828             : // enabled frame borders ------------------------------------------------------
     829             : 
     830           0 : bool FrameSelector::IsBorderEnabled( FrameBorderType eBorder ) const
     831             : {
     832           0 :     return mxImpl->GetBorder( eBorder ).IsEnabled();
     833             : }
     834             : 
     835           0 : sal_Int32 FrameSelector::GetEnabledBorderCount() const
     836             : {
     837           0 :     return static_cast< sal_Int32 >( mxImpl->maEnabBorders.size() );
     838             : }
     839             : 
     840           0 : FrameBorderType FrameSelector::GetEnabledBorderType( sal_Int32 nIndex ) const
     841             : {
     842           0 :     FrameBorderType eBorder = FRAMEBORDER_NONE;
     843           0 :     if( nIndex >= 0 )
     844             :     {
     845           0 :         size_t nVecIdx = static_cast< size_t >( nIndex );
     846           0 :         if( nVecIdx < mxImpl->maEnabBorders.size() )
     847           0 :             eBorder = mxImpl->maEnabBorders[ nVecIdx ]->GetType();
     848             :     }
     849           0 :     return eBorder;
     850             : }
     851             : 
     852           0 : sal_Int32 FrameSelector::GetEnabledBorderIndex( FrameBorderType eBorder ) const
     853             : {
     854           0 :     sal_Int32 nIndex = 0;
     855           0 :     for( FrameBorderCIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt, ++nIndex )
     856           0 :         if( (*aIt)->GetType() == eBorder )
     857           0 :             return nIndex;
     858           0 :     return -1;
     859             : }
     860             : 
     861             : // frame border state and style -----------------------------------------------
     862             : 
     863           0 : bool FrameSelector::SupportsDontCareState() const
     864             : {
     865           0 :     return (mxImpl->mnFlags & FRAMESEL_DONTCARE) != 0;
     866             : }
     867             : 
     868           0 : FrameBorderState FrameSelector::GetFrameBorderState( FrameBorderType eBorder ) const
     869             : {
     870           0 :     return mxImpl->GetBorder( eBorder ).GetState();
     871             : }
     872             : 
     873           0 : const SvxBorderLine* FrameSelector::GetFrameBorderStyle( FrameBorderType eBorder ) const
     874             : {
     875           0 :     const SvxBorderLine& rStyle = mxImpl->GetBorder( eBorder ).GetCoreStyle();
     876             :     // rest of the world uses null pointer for invisible frame border
     877           0 :     return rStyle.GetOutWidth() ? &rStyle : 0;
     878             : }
     879             : 
     880           0 : void FrameSelector::ShowBorder( FrameBorderType eBorder, const SvxBorderLine* pStyle )
     881             : {
     882           0 :     mxImpl->SetBorderCoreStyle( mxImpl->GetBorderAccess( eBorder ), pStyle );
     883           0 : }
     884             : 
     885           0 : void FrameSelector::SetBorderDontCare( FrameBorderType eBorder )
     886             : {
     887           0 :     mxImpl->SetBorderState( mxImpl->GetBorderAccess( eBorder ), FRAMESTATE_DONTCARE );
     888           0 : }
     889             : 
     890           0 : bool FrameSelector::IsAnyBorderVisible() const
     891             : {
     892           0 :     bool bIsSet = false;
     893           0 :     for( FrameBorderCIter aIt( mxImpl->maEnabBorders ); !bIsSet && aIt.Is(); ++aIt )
     894           0 :         bIsSet = ((*aIt)->GetState() == FRAMESTATE_SHOW);
     895           0 :     return bIsSet;
     896             : }
     897             : 
     898           0 : void FrameSelector::HideAllBorders()
     899             : {
     900           0 :     for( FrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
     901           0 :         mxImpl->SetBorderState( **aIt, FRAMESTATE_HIDE );
     902           0 : }
     903             : 
     904           0 : bool FrameSelector::GetVisibleWidth( long& rnWidth, SvxBorderStyle& rnStyle ) const
     905             : {
     906           0 :     VisFrameBorderCIter aIt( mxImpl->maEnabBorders );
     907           0 :     if( !aIt.Is() )
     908           0 :         return false;
     909             : 
     910           0 :     const SvxBorderLine& rStyle = (*aIt)->GetCoreStyle();
     911           0 :     bool bFound = true;
     912           0 :     for( ++aIt; bFound && aIt.Is(); ++aIt )
     913             :     {
     914             :         bFound =
     915           0 :             (rStyle.GetWidth() == (*aIt)->GetCoreStyle().GetWidth()) &&
     916           0 :             (rStyle.GetBorderLineStyle() ==
     917           0 :                 (*aIt)->GetCoreStyle().GetBorderLineStyle());
     918             :     }
     919             : 
     920           0 :     if( bFound )
     921             :     {
     922           0 :         rnWidth = rStyle.GetWidth();
     923           0 :         rnStyle = rStyle.GetBorderLineStyle();
     924             :     }
     925           0 :     return bFound;
     926             : }
     927             : 
     928           0 : bool FrameSelector::GetVisibleColor( Color& rColor ) const
     929             : {
     930           0 :     VisFrameBorderCIter aIt( mxImpl->maEnabBorders );
     931           0 :     if( !aIt.Is() )
     932           0 :         return false;
     933             : 
     934           0 :     const SvxBorderLine& rStyle = (*aIt)->GetCoreStyle();
     935           0 :     bool bFound = true;
     936           0 :     for( ++aIt; bFound && aIt.Is(); ++aIt )
     937           0 :         bFound = (rStyle.GetColor() == (*aIt)->GetCoreStyle().GetColor());
     938             : 
     939           0 :     if( bFound )
     940           0 :         rColor = rStyle.GetColor();
     941           0 :     return bFound;
     942             : }
     943             : 
     944             : // frame border selection -----------------------------------------------------
     945             : 
     946           0 : const Link& FrameSelector::GetSelectHdl() const
     947             : {
     948           0 :     return mxImpl->maSelectHdl;
     949             : }
     950             : 
     951           0 : void FrameSelector::SetSelectHdl( const Link& rHdl )
     952             : {
     953           0 :     mxImpl->maSelectHdl = rHdl;
     954           0 : }
     955             : 
     956           0 : bool FrameSelector::IsBorderSelected( FrameBorderType eBorder ) const
     957             : {
     958           0 :     return mxImpl->GetBorder( eBorder ).IsSelected();
     959             : }
     960             : 
     961           0 : void FrameSelector::SelectBorder( FrameBorderType eBorder, bool bSelect /*, bool bFocus */ )
     962             : {
     963           0 :     mxImpl->SelectBorder( mxImpl->GetBorderAccess( eBorder ), bSelect );
     964             :     // MT: bFireFox as API parameter is ugly...
     965             :     // if (bFocus)
     966             :     {
     967           0 :         Reference< XAccessible > xRet = GetChildAccessible(eBorder);
     968           0 :         a11y::AccFrameSelector* pFrameSelector = static_cast<a11y::AccFrameSelector*>(xRet.get());
     969           0 :         if (pFrameSelector)
     970             :         {
     971           0 :             Any aOldValue, aNewValue;
     972           0 :             aNewValue <<= AccessibleStateType::FOCUSED;
     973           0 :             pFrameSelector->NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
     974           0 :         }
     975             :     }
     976           0 : }
     977             : 
     978           0 : bool FrameSelector::IsAnyBorderSelected() const
     979             : {
     980             :     // Construct an iterator for selected borders. If it is valid, there is a selected border.
     981           0 :     return SelFrameBorderCIter( mxImpl->maEnabBorders ).Is();
     982             : }
     983             : 
     984           0 : void FrameSelector::SelectAllBorders( bool bSelect )
     985             : {
     986           0 :     for( FrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
     987           0 :         mxImpl->SelectBorder( **aIt, bSelect );
     988           0 : }
     989             : 
     990           0 : void FrameSelector::SelectAllVisibleBorders( bool bSelect )
     991             : {
     992           0 :     for( VisFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
     993           0 :         mxImpl->SelectBorder( **aIt, bSelect );
     994           0 : }
     995             : 
     996           0 : void FrameSelector::SetStyleToSelection( long nWidth, SvxBorderStyle nStyle )
     997             : {
     998           0 :     mxImpl->maCurrStyle.SetBorderLineStyle( nStyle );
     999           0 :     mxImpl->maCurrStyle.SetWidth( nWidth );
    1000           0 :     for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
    1001           0 :         mxImpl->SetBorderState( **aIt, FRAMESTATE_SHOW );
    1002           0 : }
    1003             : 
    1004           0 : void FrameSelector::SetColorToSelection( const Color& rColor )
    1005             : {
    1006           0 :     mxImpl->maCurrStyle.SetColor( rColor );
    1007           0 :     for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
    1008           0 :         mxImpl->SetBorderState( **aIt, FRAMESTATE_SHOW );
    1009           0 : }
    1010             : 
    1011             : // accessibility --------------------------------------------------------------
    1012             : 
    1013           0 : Reference< XAccessible > FrameSelector::CreateAccessible()
    1014             : {
    1015           0 :     if( !mxImpl->mxAccess.is() )
    1016           0 :         mxImpl->mxAccess = mxImpl->mpAccess =
    1017           0 :             new a11y::AccFrameSelector( *this, FRAMEBORDER_NONE );
    1018           0 :     return mxImpl->mxAccess;
    1019             : }
    1020             : 
    1021           0 : Reference< XAccessible > FrameSelector::GetChildAccessible( FrameBorderType eBorder )
    1022             : {
    1023           0 :     Reference< XAccessible > xRet;
    1024           0 :     size_t nVecIdx = static_cast< size_t >( eBorder );
    1025           0 :     if( IsBorderEnabled( eBorder ) && (1 <= nVecIdx) && (nVecIdx <= mxImpl->maChildVec.size()) )
    1026             :     {
    1027           0 :         --nVecIdx;
    1028           0 :         if( !mxImpl->maChildVec[ nVecIdx ] )
    1029           0 :             mxImpl->mxChildVec[ nVecIdx ] = mxImpl->maChildVec[ nVecIdx ] =
    1030           0 :                 new a11y::AccFrameSelector( *this, eBorder );
    1031           0 :         xRet = mxImpl->mxChildVec[ nVecIdx ];
    1032             :     }
    1033           0 :     return xRet;
    1034             : }
    1035             : 
    1036           0 : Reference< XAccessible > FrameSelector::GetChildAccessible( sal_Int32 nIndex )
    1037             : {
    1038           0 :     return GetChildAccessible( GetEnabledBorderType( nIndex ) );
    1039             : }
    1040             : 
    1041           0 : Reference< XAccessible > FrameSelector::GetChildAccessible( const Point& rPos )
    1042             : {
    1043           0 :     Reference< XAccessible > xRet;
    1044           0 :     for( FrameBorderCIter aIt( mxImpl->maEnabBorders ); !xRet.is() && aIt.Is(); ++aIt )
    1045           0 :         if( (*aIt)->ContainsClickPoint( rPos ) )
    1046           0 :             xRet = GetChildAccessible( (*aIt)->GetType() );
    1047           0 :     return xRet;
    1048             : }
    1049             : 
    1050           0 : bool FrameSelector::ContainsClickPoint( const Point& rPos ) const
    1051             : {
    1052           0 :     bool bContains = false;
    1053           0 :     for( FrameBorderCIter aIt( mxImpl->maEnabBorders ); !bContains && aIt.Is(); ++aIt )
    1054           0 :         bContains = (*aIt)->ContainsClickPoint( rPos );
    1055           0 :     return bContains;
    1056             : }
    1057             : 
    1058           0 : Rectangle FrameSelector::GetClickBoundRect( FrameBorderType eBorder ) const
    1059             : {
    1060           0 :     Rectangle aRect;
    1061           0 :     const FrameBorder& rBorder = mxImpl->GetBorder( eBorder );
    1062           0 :     if( rBorder.IsEnabled() )
    1063           0 :         aRect = rBorder.GetClickBoundRect();
    1064           0 :     return aRect;
    1065             : }
    1066             : 
    1067             : // virtual functions from base class ------------------------------------------
    1068             : 
    1069           0 : void FrameSelector::Paint( const Rectangle& )
    1070             : {
    1071           0 :     mxImpl->CopyVirDevToControl();
    1072           0 :     if( HasFocus() )
    1073           0 :         mxImpl->DrawAllTrackingRects();
    1074           0 : }
    1075             : 
    1076           0 : void FrameSelector::MouseButtonDown( const MouseEvent& rMEvt )
    1077             : {
    1078             :     /*  Mouse handling:
    1079             :         * Click on an unselected frame border:
    1080             :             Set current style/color, make frame border visible, deselect all
    1081             :             other frame borders.
    1082             :         * Click on a selected frame border:
    1083             :             Toggle state of the frame border (visible -> don't care -> hidden),
    1084             :             deselect all other frame borders.
    1085             :         * SHIFT+Click or CTRL+Click on an unselected frame border:
    1086             :             Extend selection, set current style/color to all selected frame
    1087             :             borders independent of the state/style/color of the borders.
    1088             :         * SHIFT+Click or CTRL+Click on a selected frame border:
    1089             :             If all frame borders have same style/color, toggle state of all
    1090             :             borders (see above), otherwise set current style/color to all
    1091             :             borders.
    1092             :         * Click on unused area: Do not modify selection and selected frame
    1093             :             borders.
    1094             :      */
    1095             : 
    1096             :     // #107394# do not auto-select a frame border
    1097           0 :     mxImpl->SilentGrabFocus();
    1098             : 
    1099           0 :     if( rMEvt.IsLeft() )
    1100             :     {
    1101           0 :         Point aPos( mxImpl->GetDevPosFromMousePos( rMEvt.GetPosPixel() ) );
    1102           0 :         FrameBorderPtrVec aDeselectBorders;
    1103             : 
    1104           0 :         bool bAnyClicked = false;   // Any frame border clicked?
    1105           0 :         bool bNewSelected = false;  // Any unselected frame border selected?
    1106             : 
    1107             :         /*  If frame borders are set to "don't care" and the control does not
    1108             :             support this state, hide them on first mouse click.
    1109             :             DR 2004-01-30: Why are the borders set to "don't care" then?!? */
    1110           0 :         bool bHideDontCare = !mxImpl->mbClicked && !SupportsDontCareState();
    1111             : 
    1112           0 :         for( FrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
    1113             :         {
    1114           0 :             if( (*aIt)->ContainsClickPoint( aPos ) )
    1115             :             {
    1116             :                 // frame border is clicked
    1117           0 :                 bAnyClicked = true;
    1118           0 :                 if( !(*aIt)->IsSelected() )
    1119             :                 {
    1120           0 :                     bNewSelected = true;
    1121             :                     //mxImpl->SelectBorder( **aIt, true );
    1122           0 :                     SelectBorder((**aIt).GetType(), true);
    1123             :                 }
    1124             :             }
    1125             :             else
    1126             :             {
    1127             :                 // hide a "don't care" frame border only if it is not clicked
    1128           0 :                 if( bHideDontCare && ((*aIt)->GetState() == FRAMESTATE_DONTCARE) )
    1129           0 :                     mxImpl->SetBorderState( **aIt, FRAMESTATE_HIDE );
    1130             : 
    1131             :                 // deselect frame borders not clicked (if SHIFT or CTRL are not pressed)
    1132           0 :                 if( !rMEvt.IsShift() && !rMEvt.IsMod1() )
    1133           0 :                     aDeselectBorders.push_back( *aIt );
    1134             :             }
    1135             :         }
    1136             : 
    1137           0 :         if( bAnyClicked )
    1138             :         {
    1139             :             // any valid frame border clicked? -> deselect other frame borders
    1140           0 :             for( FrameBorderIter aIt( aDeselectBorders ); aIt.Is(); ++aIt )
    1141           0 :                 mxImpl->SelectBorder( **aIt, false );
    1142             : 
    1143           0 :             if( bNewSelected || !mxImpl->SelectedBordersEqual() )
    1144             :             {
    1145             :                 // new frame border selected, selection extended, or selected borders different? -> show
    1146           0 :                 for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
    1147             :                     // SetBorderState() sets current style and color to the frame border
    1148           0 :                     mxImpl->SetBorderState( **aIt, FRAMESTATE_SHOW );
    1149             :             }
    1150             :             else
    1151             :             {
    1152             :                 // all selected frame borders are equal -> toggle state
    1153           0 :                 for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
    1154           0 :                     mxImpl->ToggleBorderState( **aIt );
    1155             :             }
    1156             : 
    1157           0 :             GetSelectHdl().Call( this );
    1158           0 :         }
    1159             :     }
    1160           0 : }
    1161             : 
    1162           0 : void FrameSelector::KeyInput( const KeyEvent& rKEvt )
    1163             : {
    1164           0 :     bool bHandled = false;
    1165           0 :     KeyCode aKeyCode = rKEvt.GetKeyCode();
    1166           0 :     if( !aKeyCode.GetModifier() )
    1167             :     {
    1168           0 :         sal_uInt16 nCode = aKeyCode.GetCode();
    1169           0 :         switch( nCode )
    1170             :         {
    1171             :             case KEY_SPACE:
    1172             :             {
    1173           0 :                 for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
    1174           0 :                     mxImpl->ToggleBorderState( **aIt );
    1175           0 :                 bHandled = true;
    1176             :             }
    1177           0 :             break;
    1178             : 
    1179             :             case KEY_UP:
    1180             :             case KEY_DOWN:
    1181             :             case KEY_LEFT:
    1182             :             case KEY_RIGHT:
    1183             :             {
    1184           0 :                 if( !mxImpl->maEnabBorders.empty() )
    1185             :                 {
    1186             :                     // start from first selected frame border
    1187           0 :                     SelFrameBorderCIter aIt( mxImpl->maEnabBorders );
    1188           0 :                     FrameBorderType eBorder = aIt.Is() ? (*aIt)->GetType() : mxImpl->maEnabBorders.front()->GetType();
    1189             : 
    1190             :                     // search for next enabled frame border
    1191           0 :                     do
    1192             :                     {
    1193           0 :                         eBorder = mxImpl->GetBorder( eBorder ).GetKeyboardNeighbor( nCode );
    1194             :                     }
    1195           0 :                     while( (eBorder != FRAMEBORDER_NONE) && !IsBorderEnabled( eBorder ) );
    1196             : 
    1197             :                     // select the frame border
    1198           0 :                     if( eBorder != FRAMEBORDER_NONE )
    1199             :                     {
    1200           0 :                         DeselectAllBorders();
    1201           0 :                         SelectBorder( eBorder );
    1202             :                     }
    1203             :                 }
    1204             :             }
    1205           0 :             break;
    1206             :         }
    1207             :     }
    1208           0 :     if( !bHandled )
    1209           0 :         Window::KeyInput(rKEvt);
    1210           0 : }
    1211             : 
    1212           0 : void FrameSelector::GetFocus()
    1213             : {
    1214             :     // auto-selection of a frame border, if focus reaches control, and nothing is selected
    1215           0 :     if( mxImpl->mbAutoSelect && !IsAnyBorderSelected() && !mxImpl->maEnabBorders.empty() )
    1216           0 :         mxImpl->SelectBorder( *mxImpl->maEnabBorders.front(), true );
    1217             : 
    1218           0 :     mxImpl->DoInvalidate( false );
    1219           0 :     if( mxImpl->mxAccess.is() )
    1220           0 :         mxImpl->mpAccess->NotifyFocusListeners( sal_True );
    1221           0 :     if (IsAnyBorderSelected())
    1222             :     {
    1223           0 :         FrameBorderType borderType = FRAMEBORDER_NONE;
    1224           0 :         if (mxImpl->maLeft.IsSelected())
    1225           0 :             borderType = FRAMEBORDER_LEFT;
    1226           0 :         else if (mxImpl->maRight.IsSelected())
    1227           0 :             borderType = FRAMEBORDER_RIGHT;
    1228           0 :         else if (mxImpl->maTop.IsSelected())
    1229           0 :             borderType = FRAMEBORDER_TOP;
    1230           0 :         else if (mxImpl->maBottom.IsSelected())
    1231           0 :             borderType = FRAMEBORDER_BOTTOM;
    1232           0 :         else if (mxImpl->maHor.IsSelected())
    1233           0 :             borderType = FRAMEBORDER_HOR;
    1234           0 :         else if (mxImpl->maVer.IsSelected())
    1235           0 :             borderType = FRAMEBORDER_VER;
    1236           0 :         else if (mxImpl->maTLBR.IsSelected())
    1237           0 :             borderType = FRAMEBORDER_TLBR;
    1238           0 :         else if (mxImpl->maBLTR.IsSelected())
    1239           0 :             borderType = FRAMEBORDER_BLTR;
    1240           0 :         SelectBorder(borderType);
    1241             :     }
    1242           0 :     for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt )
    1243           0 :             mxImpl->SetBorderState( **aIt, FRAMESTATE_SHOW );
    1244           0 :     Control::GetFocus();
    1245           0 : }
    1246             : 
    1247           0 : void FrameSelector::LoseFocus()
    1248             : {
    1249           0 :     mxImpl->DoInvalidate( false );
    1250           0 :     if( mxImpl->mxAccess.is() )
    1251           0 :         mxImpl->mpAccess->NotifyFocusListeners( sal_False );
    1252           0 :     Control::LoseFocus();
    1253           0 : }
    1254             : 
    1255           0 : void FrameSelector::DataChanged( const DataChangedEvent& rDCEvt )
    1256             : {
    1257           0 :     Control::DataChanged( rDCEvt );
    1258           0 :     if( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
    1259           0 :         mxImpl->InitVirtualDevice();
    1260           0 : }
    1261             : 
    1262           0 : void FrameSelector::Resize()
    1263             : {
    1264           0 :     Control::Resize();
    1265           0 :     mxImpl->sizeChanged();
    1266           0 : }
    1267             : 
    1268           0 : Size FrameSelector::GetOptimalSize() const
    1269             : {
    1270           0 :     return LogicToPixel(Size(61, 65), MAP_APPFONT);
    1271             : }
    1272             : 
    1273             : 
    1274             : 
    1275             : template< typename Cont, typename Iter, typename Pred >
    1276           0 : FrameBorderIterBase< Cont, Iter, Pred >::FrameBorderIterBase( container_type& rCont ) :
    1277             :     maIt( rCont.begin() ),
    1278           0 :     maEnd( rCont.end() )
    1279             : {
    1280           0 :     while( Is() && !maPred( *maIt ) ) ++maIt;
    1281           0 : }
    1282             : 
    1283             : template< typename Cont, typename Iter, typename Pred >
    1284           0 : FrameBorderIterBase< Cont, Iter, Pred >& FrameBorderIterBase< Cont, Iter, Pred >::operator++()
    1285             : {
    1286           0 :     do { ++maIt; } while( Is() && !maPred( *maIt ) );
    1287           0 :     return *this;
    1288             : }
    1289             : 
    1290             : 
    1291             : 
    1292             : } // namespace svx
    1293             : 
    1294             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10