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