1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26
27 // include ---------------------------------------------------------------
28 #include <tools/shl.hxx>
29 #include <vcl/svapp.hxx>
30 #include <svx/xtable.hxx>
31 #include <svx/xpool.hxx>
32 #include <svx/dialogs.hrc>
33 #include <accessibility.hrc>
34 #include <svx/dlgctrl.hxx>
35 #include <svx/dialmgr.hxx>
36 #include <tools/poly.hxx>
37 #include <vcl/region.hxx>
38 #include <vcl/gradient.hxx>
39 #include <vcl/hatch.hxx>
40 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTOBJECT_HPP_
41 #include <com/sun/star/accessibility/AccessibleEventObject.hpp>
42 #endif
43 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTID_HPP_
44 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
45 #endif
46 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HPP_
47 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
48 #endif
49 #include "svxpixelctlaccessiblecontext.hxx"
50 #include <svtools/colorcfg.hxx>
51 #include <svxrectctaccessiblecontext.hxx>
52 #include <com/sun/star/lang/XUnoTunnel.hpp>
53 #include <basegfx/point/b2dpoint.hxx>
54 #include <basegfx/polygon/b2dpolygon.hxx>
55 #include <svx/svdorect.hxx>
56 #include <svx/svdmodel.hxx>
57 #include <svx/svdopath.hxx>
58 #include <svx/sdr/contact/objectcontactofobjlistpainter.hxx>
59 #include <svx/sdr/contact/displayinfo.hxx>
60 #include <vcl/bmpacc.hxx>
61 #include <svx/xbtmpit.hxx>
62
63 #define OUTPUT_DRAWMODE_COLOR (DRAWMODE_DEFAULT)
64 #define OUTPUT_DRAWMODE_CONTRAST (DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT)
65
66 using namespace ::com::sun::star::uno;
67 using namespace ::com::sun::star::lang;
68 using namespace ::com::sun::star::accessibility;
69
70
71 /*************************************************************************
72 |*
73 |* Control zur Darstellung und Auswahl der Eckpunkte (und Mittelpunkt)
74 |* eines Objekts
75 |*
76 \************************************************************************/
77
GetRectBitmap(void)78 Bitmap& SvxRectCtl::GetRectBitmap( void )
79 {
80 if( !pBitmap )
81 InitRectBitmap();
82
83 return *pBitmap;
84 }
85
SvxRectCtl(Window * pParent,const ResId & rResId,RECT_POINT eRpt,sal_uInt16 nBorder,sal_uInt16 nCircle,CTL_STYLE eStyle)86 SvxRectCtl::SvxRectCtl( Window* pParent, const ResId& rResId, RECT_POINT eRpt,
87 sal_uInt16 nBorder, sal_uInt16 nCircle, CTL_STYLE eStyle ) :
88
89 Control( pParent, rResId ),
90
91 pAccContext ( NULL ),
92 nBorderWidth( nBorder ),
93 nRadius ( nCircle),
94 eDefRP ( eRpt ),
95 eCS ( eStyle ),
96 pBitmap ( NULL ),
97 m_nState ( 0 ),
98 mbCompleteDisable(sal_False)
99 {
100 SetMapMode( MAP_100TH_MM );
101 Resize_Impl();
102 }
103
104 // -----------------------------------------------------------------------
105
~SvxRectCtl()106 SvxRectCtl::~SvxRectCtl()
107 {
108 delete pBitmap;
109
110 if( pAccContext )
111 pAccContext->release();
112 }
113
114 // -----------------------------------------------------------------------
Resize()115 void SvxRectCtl::Resize()
116 {
117 Resize_Impl();
118 Control::Resize();
119 }
120
121 // -----------------------------------------------------------------------
122
Resize_Impl()123 void SvxRectCtl::Resize_Impl()
124 {
125 aSize = GetOutputSize();
126
127 switch( eCS )
128 {
129 case CS_RECT:
130 case CS_ANGLE:
131 case CS_SHADOW:
132 aPtLT = Point( 0 + nBorderWidth, 0 + nBorderWidth );
133 aPtMT = Point( aSize.Width() / 2, 0 + nBorderWidth );
134 aPtRT = Point( aSize.Width() - nBorderWidth, 0 + nBorderWidth );
135
136 aPtLM = Point( 0 + nBorderWidth, aSize.Height() / 2 );
137 aPtMM = Point( aSize.Width() / 2, aSize.Height() / 2 );
138 aPtRM = Point( aSize.Width() - nBorderWidth, aSize.Height() / 2 );
139
140 aPtLB = Point( 0 + nBorderWidth, aSize.Height() - nBorderWidth );
141 aPtMB = Point( aSize.Width() / 2, aSize.Height() - nBorderWidth );
142 aPtRB = Point( aSize.Width() - nBorderWidth, aSize.Height() - nBorderWidth );
143 break;
144
145 case CS_LINE:
146 aPtLT = Point( 0 + 3 * nBorderWidth, 0 + nBorderWidth );
147 aPtMT = Point( aSize.Width() / 2, 0 + nBorderWidth );
148 aPtRT = Point( aSize.Width() - 3 * nBorderWidth, 0 + nBorderWidth );
149
150 aPtLM = Point( 0 + 3 * nBorderWidth, aSize.Height() / 2 );
151 aPtMM = Point( aSize.Width() / 2, aSize.Height() / 2 );
152 aPtRM = Point( aSize.Width() - 3 * nBorderWidth, aSize.Height() / 2 );
153
154 aPtLB = Point( 0 + 3 * nBorderWidth, aSize.Height() - nBorderWidth );
155 aPtMB = Point( aSize.Width() / 2, aSize.Height() - nBorderWidth );
156 aPtRB = Point( aSize.Width() - 3 * nBorderWidth, aSize.Height() - nBorderWidth );
157 break;
158 }
159 Reset();
160 InitSettings( sal_True, sal_True );
161 }
162 // -----------------------------------------------------------------------
163
InitRectBitmap(void)164 void SvxRectCtl::InitRectBitmap( void )
165 {
166 if( pBitmap )
167 delete pBitmap;
168
169 const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
170 svtools::ColorConfig aColorConfig;
171
172 pBitmap = new Bitmap( SVX_RES( RID_SVXCTRL_RECTBTNS ) );
173
174 // set bitmap-colors
175 Color aColorAry1[7];
176 Color aColorAry2[7];
177 aColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 ); // light-gray
178 aColorAry1[1] = Color( 0xFF, 0xFF, 0x00 ); // yellow
179 aColorAry1[2] = Color( 0xFF, 0xFF, 0xFF ); // white
180 aColorAry1[3] = Color( 0x80, 0x80, 0x80 ); // dark-gray
181 aColorAry1[4] = Color( 0x00, 0x00, 0x00 ); // black
182 aColorAry1[5] = Color( 0x00, 0xFF, 0x00 ); // green
183 aColorAry1[6] = Color( 0x00, 0x00, 0xFF ); // blue
184 aColorAry2[0] = rStyles.GetDialogColor(); // background
185 aColorAry2[1] = rStyles.GetWindowColor();
186 aColorAry2[2] = rStyles.GetLightColor();
187 aColorAry2[3] = rStyles.GetShadowColor();
188 aColorAry2[4] = rStyles.GetDarkShadowColor();
189 aColorAry2[5] = Color( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
190 aColorAry2[6] = rStyles.GetDialogColor();
191
192 #ifdef DBG_UTIL
193 static sal_Bool bModify = sal_False;
194 sal_Bool& rModify = bModify;
195 if( rModify )
196 {
197 static int n = 0;
198 static sal_uInt8 r = 0xFF;
199 static sal_uInt8 g = 0x00;
200 static sal_uInt8 b = 0xFF;
201 int& rn = n;
202 sal_uInt8& rr = r;
203 sal_uInt8& rg = g;
204 sal_uInt8& rb = b;
205 aColorAry2[ rn ] = Color( rr, rg, rb );
206 }
207 #endif
208
209 pBitmap->Replace( aColorAry1, aColorAry2, 7, NULL );
210 }
211
212 // -----------------------------------------------------------------------
213
InitSettings(sal_Bool bForeground,sal_Bool bBackground)214 void SvxRectCtl::InitSettings( sal_Bool bForeground, sal_Bool bBackground )
215 {
216 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
217
218 if( bForeground )
219 {
220 svtools::ColorConfig aColorConfig;
221 Color aTextColor( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
222
223 if ( IsControlForeground() )
224 aTextColor = GetControlForeground();
225 SetTextColor( aTextColor );
226 }
227
228 if( bBackground )
229 {
230 if ( IsControlBackground() )
231 SetBackground( GetControlBackground() );
232 else
233 SetBackground( rStyleSettings.GetWindowColor() );
234 }
235
236 delete pBitmap;
237 pBitmap = NULL; // forces new creating of bitmap
238
239 Invalidate();
240 }
241
242 /*************************************************************************
243 |*
244 |* Das angeklickte Rechteck (3 x 3) wird ermittelt und der Parent (Dialog)
245 |* wird benachrichtigt, dass der Punkt geaendert wurde
246 |*
247 \************************************************************************/
248
MouseButtonDown(const MouseEvent & rMEvt)249 void SvxRectCtl::MouseButtonDown( const MouseEvent& rMEvt )
250 {
251 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
252 if(!IsCompletelyDisabled())
253 {
254 Point aPtLast = aPtNew;
255
256 aPtNew = GetApproxLogPtFromPixPt( rMEvt.GetPosPixel() );
257
258 if( aPtNew == aPtMM && ( eCS == CS_SHADOW || eCS == CS_ANGLE ) )
259 {
260 aPtNew = aPtLast;
261 }
262 else
263 {
264 Invalidate( Rectangle( aPtLast - Point( nRadius, nRadius ),
265 aPtLast + Point( nRadius, nRadius ) ) );
266 Invalidate( Rectangle( aPtNew - Point( nRadius, nRadius ),
267 aPtNew + Point( nRadius, nRadius ) ) );
268 eRP = GetRPFromPoint( aPtNew );
269
270 SetActualRP( eRP );
271
272 if( WINDOW_TABPAGE == GetParent()->GetType() )
273 ( (SvxTabPage*) GetParent() )->PointChanged( this, eRP );
274 }
275 }
276 }
277
278 // -----------------------------------------------------------------------
279
KeyInput(const KeyEvent & rKeyEvt)280 void SvxRectCtl::KeyInput( const KeyEvent& rKeyEvt )
281 {
282 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
283 if(!IsCompletelyDisabled())
284 {
285 RECT_POINT eNewRP = eRP;
286 sal_Bool bUseMM = (eCS != CS_SHADOW) && (eCS != CS_ANGLE);
287
288 switch( rKeyEvt.GetKeyCode().GetCode() )
289 {
290 case KEY_DOWN:
291 {
292 if( !(m_nState & CS_NOVERT) )
293 switch( eNewRP )
294 {
295 case RP_LT: eNewRP = RP_LM; break;
296 case RP_MT: eNewRP = bUseMM ? RP_MM : RP_MB; break;
297 case RP_RT: eNewRP = RP_RM; break;
298 case RP_LM: eNewRP = RP_LB; break;
299 case RP_MM: eNewRP = RP_MB; break;
300 case RP_RM: eNewRP = RP_RB; break;
301 default: ; //prevent warning
302 }
303 }
304 break;
305 case KEY_UP:
306 {
307 if( !(m_nState & CS_NOVERT) )
308 switch( eNewRP )
309 {
310 case RP_LM: eNewRP = RP_LT; break;
311 case RP_MM: eNewRP = RP_MT; break;
312 case RP_RM: eNewRP = RP_RT; break;
313 case RP_LB: eNewRP = RP_LM; break;
314 case RP_MB: eNewRP = bUseMM ? RP_MM : RP_MT; break;
315 case RP_RB: eNewRP = RP_RM; break;
316 default: ; //prevent warning
317 }
318 }
319 break;
320 case KEY_LEFT:
321 {
322 if( !(m_nState & CS_NOHORZ) )
323 switch( eNewRP )
324 {
325 case RP_MT: eNewRP = RP_LT; break;
326 case RP_RT: eNewRP = RP_MT; break;
327 case RP_MM: eNewRP = RP_LM; break;
328 case RP_RM: eNewRP = bUseMM ? RP_MM : RP_LM; break;
329 case RP_MB: eNewRP = RP_LB; break;
330 case RP_RB: eNewRP = RP_MB; break;
331 default: ; //prevent warning
332 }
333 }
334 break;
335 case KEY_RIGHT:
336 {
337 if( !(m_nState & CS_NOHORZ) )
338 switch( eNewRP )
339 {
340 case RP_LT: eNewRP = RP_MT; break;
341 case RP_MT: eNewRP = RP_RT; break;
342 case RP_LM: eNewRP = bUseMM ? RP_MM : RP_RM; break;
343 case RP_MM: eNewRP = RP_RM; break;
344 case RP_LB: eNewRP = RP_MB; break;
345 case RP_MB: eNewRP = RP_RB; break;
346 default: ; //prevent warning
347 }
348 }
349 break;
350 default:
351 Control::KeyInput( rKeyEvt );
352 return;
353 }
354 if( eNewRP != eRP )
355 {
356 SetActualRP( eNewRP );
357
358 if( WINDOW_TABPAGE == GetParent()->GetType() )
359 ( (SvxTabPage*) GetParent() )->PointChanged( this, eRP );
360
361 SetFocusRect();
362 }
363 }
364 }
365
366 // -----------------------------------------------------------------------
367
StateChanged(StateChangedType nType)368 void SvxRectCtl::StateChanged( StateChangedType nType )
369 {
370 if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
371 InitSettings( sal_True, sal_False );
372 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
373 InitSettings( sal_False, sal_True );
374
375 Window::StateChanged( nType );
376 }
377
378 // -----------------------------------------------------------------------
379
DataChanged(const DataChangedEvent & rDCEvt)380 void SvxRectCtl::DataChanged( const DataChangedEvent& rDCEvt )
381 {
382 if ( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
383 InitSettings( sal_True, sal_True );
384 else
385 Window::DataChanged( rDCEvt );
386 }
387
388 /*************************************************************************
389 |*
390 |* Zeichnet das Control (Rechteck mit 9 Kreisen)
391 |*
392 \************************************************************************/
393
Paint(const Rectangle &)394 void SvxRectCtl::Paint( const Rectangle& )
395 {
396 Point aPtDiff( PixelToLogic( Point( 1, 1 ) ) );
397
398 const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
399
400 SetLineColor( rStyles.GetDialogColor() );
401 SetFillColor( rStyles.GetDialogColor() );
402 DrawRect( Rectangle( Point(0,0), GetOutputSize() ) );
403
404 if( IsEnabled() )
405 SetLineColor( rStyles.GetLabelTextColor() );
406 else
407 SetLineColor( rStyles.GetShadowColor() );
408
409 SetFillColor();
410
411 switch( eCS )
412 {
413
414 case CS_RECT:
415 case CS_SHADOW:
416 if( !IsEnabled() )
417 {
418 Color aOldCol = GetLineColor();
419 SetLineColor( rStyles.GetLightColor() );
420 DrawRect( Rectangle( aPtLT + aPtDiff, aPtRB + aPtDiff ) );
421 SetLineColor( aOldCol );
422 }
423 DrawRect( Rectangle( aPtLT, aPtRB ) );
424 break;
425
426 case CS_LINE:
427 if( !IsEnabled() )
428 {
429 Color aOldCol = GetLineColor();
430 SetLineColor( rStyles.GetLightColor() );
431 DrawLine( aPtLM - Point( 2 * nBorderWidth, 0) + aPtDiff,
432 aPtRM + Point( 2 * nBorderWidth, 0 ) + aPtDiff );
433 SetLineColor( aOldCol );
434 }
435 DrawLine( aPtLM - Point( 2 * nBorderWidth, 0),
436 aPtRM + Point( 2 * nBorderWidth, 0 ) );
437 break;
438
439 case CS_ANGLE:
440 if( !IsEnabled() )
441 {
442 Color aOldCol = GetLineColor();
443 SetLineColor( rStyles.GetLightColor() );
444 DrawLine( aPtLT + aPtDiff, aPtRB + aPtDiff );
445 DrawLine( aPtLB + aPtDiff, aPtRT + aPtDiff );
446 DrawLine( aPtLM + aPtDiff, aPtRM + aPtDiff );
447 DrawLine( aPtMT + aPtDiff, aPtMB + aPtDiff );
448 SetLineColor( aOldCol );
449 }
450 DrawLine( aPtLT, aPtRB );
451 DrawLine( aPtLB, aPtRT );
452 DrawLine( aPtLM, aPtRM );
453 DrawLine( aPtMT, aPtMB );
454 break;
455
456 default:
457 break;
458 }
459 SetFillColor( GetBackground().GetColor() );
460
461 Size aBtnSize( 11, 11 );
462 Size aDstBtnSize( PixelToLogic( aBtnSize ) );
463 Point aToCenter( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1);
464 Point aBtnPnt1( IsEnabled()?0:22,0 );
465 Point aBtnPnt2( 11,0 );
466 Point aBtnPnt3( 22,0 );
467
468 sal_Bool bNoHorz = (m_nState & CS_NOHORZ) != 0;
469 sal_Bool bNoVert = (m_nState & CS_NOVERT) != 0;
470
471 Bitmap& rBitmap = GetRectBitmap();
472
473 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
474 if(IsCompletelyDisabled())
475 {
476 DrawBitmap( aPtLT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
477 DrawBitmap( aPtMT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
478 DrawBitmap( aPtRT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
479 DrawBitmap( aPtLM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
480 if( eCS == CS_RECT || eCS == CS_LINE )
481 DrawBitmap( aPtMM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
482 DrawBitmap( aPtRM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
483 DrawBitmap( aPtLB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
484 DrawBitmap( aPtMB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
485 DrawBitmap( aPtRB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
486 }
487 else
488 {
489 DrawBitmap( aPtLT - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
490 DrawBitmap( aPtMT - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
491 DrawBitmap( aPtRT - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
492
493 DrawBitmap( aPtLM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
494
495 // Mittelpunkt bei Rechteck und Linie
496 if( eCS == CS_RECT || eCS == CS_LINE )
497 DrawBitmap( aPtMM - aToCenter, aDstBtnSize, aBtnPnt1, aBtnSize, rBitmap );
498
499 DrawBitmap( aPtRM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
500
501 DrawBitmap( aPtLB - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
502 DrawBitmap( aPtMB - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
503 DrawBitmap( aPtRB - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
504 }
505
506 // draw active button, avoid center pos for angle
507 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
508 if(!IsCompletelyDisabled())
509 {
510 if( IsEnabled() && (eCS != CS_ANGLE || aPtNew != aPtMM) )
511 {
512 Point aCenterPt( aPtNew );
513 aCenterPt -= aToCenter;
514
515 DrawBitmap( aCenterPt, aDstBtnSize, aBtnPnt2, aBtnSize, rBitmap );
516 }
517 }
518 }
519
520 /*************************************************************************
521 |*
522 |* Konvertiert RECT_POINT in Point
523 |*
524 \************************************************************************/
525
GetPointFromRP(RECT_POINT _eRP) const526 Point SvxRectCtl::GetPointFromRP( RECT_POINT _eRP) const
527 {
528 switch( _eRP )
529 {
530 case RP_LT: return aPtLT;
531 case RP_MT: return aPtMT;
532 case RP_RT: return aPtRT;
533 case RP_LM: return aPtLM;
534 case RP_MM: return aPtMM;
535 case RP_RM: return aPtRM;
536 case RP_LB: return aPtLB;
537 case RP_MB: return aPtMB;
538 case RP_RB: return aPtRB;
539 }
540 return( aPtMM ); // default
541 }
542
543
SetFocusRect(const Rectangle * pRect)544 void SvxRectCtl::SetFocusRect( const Rectangle* pRect )
545 {
546 HideFocus();
547
548 if( pRect )
549 ShowFocus( *pRect );
550 else
551 ShowFocus( CalculateFocusRectangle() );
552 }
553
SetActualRPWithoutInvalidate(RECT_POINT eNewRP)554 Point SvxRectCtl::SetActualRPWithoutInvalidate( RECT_POINT eNewRP )
555 {
556 Point aPtLast = aPtNew;
557 aPtNew = GetPointFromRP( eNewRP );
558
559 if( (m_nState & CS_NOHORZ) != 0 )
560 aPtNew.X() = aPtMM.X();
561
562 if( (m_nState & CS_NOVERT) != 0 )
563 aPtNew.Y() = aPtMM.Y();
564
565 eNewRP = GetRPFromPoint( aPtNew );
566
567 eDefRP = eNewRP;
568 eRP = eNewRP;
569
570 return aPtLast;
571 }
572
GetFocus()573 void SvxRectCtl::GetFocus()
574 {
575 SetFocusRect();
576 //Solution: Send the accessible focused event
577 Control::GetFocus();
578 // Send accessibility event.
579 if(pAccContext)
580 {
581 pAccContext->FireChildFocus(GetActualRP());
582 }
583 }
584
585
LoseFocus()586 void SvxRectCtl::LoseFocus()
587 {
588 HideFocus();
589 }
590
591
GetApproxLogPtFromPixPt(const Point & rPt) const592 Point SvxRectCtl::GetApproxLogPtFromPixPt( const Point& rPt ) const
593 {
594 Point aPt = PixelToLogic( rPt );
595 long x;
596 long y;
597
598 if( ( m_nState & CS_NOHORZ ) == 0 )
599 {
600 if( aPt.X() < aSize.Width() / 3 )
601 x = aPtLT.X();
602 else if( aPt.X() < aSize.Width() * 2 / 3 )
603 x = aPtMM.X();
604 else
605 x = aPtRB.X();
606 }
607 else
608 x = aPtMM.X();
609
610 if( ( m_nState & CS_NOVERT ) == 0 )
611 {
612 if( aPt.Y() < aSize.Height() / 3 )
613 y = aPtLT.Y();
614 else if( aPt.Y() < aSize.Height() * 2 / 3 )
615 y = aPtMM.Y();
616 else
617 y = aPtRB.Y();
618 }
619 else
620 y = aPtMM.Y();
621
622 return Point( x, y );
623 }
624
625
626 /*************************************************************************
627 |*
628 |* Konvertiert Point in RECT_POINT
629 |*
630 \************************************************************************/
631
GetRPFromPoint(Point aPt) const632 RECT_POINT SvxRectCtl::GetRPFromPoint( Point aPt ) const
633 {
634 if ( aPt == aPtLT) return RP_LT;
635 else if( aPt == aPtMT) return RP_MT;
636 else if( aPt == aPtRT) return RP_RT;
637 else if( aPt == aPtLM) return RP_LM;
638 else if( aPt == aPtRM) return RP_RM;
639 else if( aPt == aPtLB) return RP_LB;
640 else if( aPt == aPtMB) return RP_MB;
641 else if( aPt == aPtRB) return RP_RB;
642
643 else
644 return RP_MM; // default
645 }
646
647 /*************************************************************************
648 |*
649 |* Bewirkt den Ursprungszustand des Controls
650 |*
651 \************************************************************************/
652
Reset()653 void SvxRectCtl::Reset()
654 {
655 aPtNew = GetPointFromRP( eDefRP );
656 eRP = eDefRP;
657 Invalidate();
658 }
659
660 /*************************************************************************
661 |*
662 |* Gibt den aktuell ausgewaehlten RECT_POINT zur�ck
663 |*
664 \************************************************************************/
665
GetActualRP() const666 RECT_POINT SvxRectCtl::GetActualRP() const
667 {
668 return( eRP );
669 }
670
671 /*************************************************************************
672 |*
673 |* Gibt den aktuell ausgewaehlten RECT_POINT zur�ck
674 |*
675 \************************************************************************/
SetActualRP(RECT_POINT eNewRP)676 void SvxRectCtl::SetActualRP( RECT_POINT eNewRP /* MT: , sal_Bool bFireFocus */ )
677 {
678 // MT: bFireFox as API parameter is ugly...
679 Point aPtLast( SetActualRPWithoutInvalidate( eNewRP ) );
680
681 Invalidate( Rectangle( aPtLast - Point( nRadius, nRadius ), aPtLast + Point( nRadius, nRadius ) ) );
682 Invalidate( Rectangle( aPtNew - Point( nRadius, nRadius ), aPtNew + Point( nRadius, nRadius ) ) );
683
684 // notify accessibility object about change
685 if( pAccContext )
686 pAccContext->selectChild( eNewRP /* MT, bFireFocus */ );
687 }
SetState(CTL_STATE nState)688 void SvxRectCtl::SetState( CTL_STATE nState )
689 {
690 m_nState = nState;
691
692 Point aPtLast( GetPointFromRP( eRP ) );
693 Point _aPtNew( aPtLast );
694
695 if( (m_nState & CS_NOHORZ) != 0 )
696 _aPtNew.X() = aPtMM.X();
697
698 if( (m_nState & CS_NOVERT) != 0 )
699 _aPtNew.Y() = aPtMM.Y();
700
701 eRP = GetRPFromPoint( _aPtNew );
702 Invalidate();
703
704 if( WINDOW_TABPAGE == GetParent()->GetType() )
705 ( (SvxTabPage*) GetParent() )->PointChanged( this, eRP );
706 }
707
GetNumOfChilds(void) const708 sal_uInt8 SvxRectCtl::GetNumOfChilds( void ) const
709 {
710 return ( eCS == CS_ANGLE )? 8 : 9;
711 }
712
CalculateFocusRectangle(void) const713 Rectangle SvxRectCtl::CalculateFocusRectangle( void ) const
714 {
715 Size aDstBtnSize( PixelToLogic( Size( 15, 15 ) ) );
716 return Rectangle( aPtNew - Point( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1 ), aDstBtnSize );
717 }
718
CalculateFocusRectangle(RECT_POINT eRectPoint) const719 Rectangle SvxRectCtl::CalculateFocusRectangle( RECT_POINT eRectPoint ) const
720 {
721 Rectangle aRet;
722 RECT_POINT eOldRectPoint = GetActualRP();
723
724 if( eOldRectPoint == eRectPoint )
725 aRet = CalculateFocusRectangle();
726 else
727 {
728 SvxRectCtl* pThis = const_cast< SvxRectCtl* >( this );
729
730 pThis->SetActualRPWithoutInvalidate( eRectPoint ); // no invalidation because it's only temporary!
731 aRet = CalculateFocusRectangle();
732
733 pThis->SetActualRPWithoutInvalidate( eOldRectPoint ); // no invalidation because nothing has changed!
734 }
735
736 return aRet;
737 }
738
CreateAccessible()739 Reference< XAccessible > SvxRectCtl::CreateAccessible()
740 {
741 Window* pParent = GetAccessibleParentWindow();
742
743 DBG_ASSERT( pParent, "-SvxRectCtl::CreateAccessible(): No Parent!" );
744
745 Reference< XAccessible > xAccParent = pParent->GetAccessible();
746 if( xAccParent.is() )
747 {
748 pAccContext = new SvxRectCtlAccessibleContext( xAccParent, *this );
749 pAccContext->acquire();
750
751 SetActualRP( GetActualRP() );
752
753 return pAccContext;
754 }
755 else
756 return Reference< XAccessible >();
757 }
758
GetApproxRPFromPixPt(const::com::sun::star::awt::Point & r) const759 RECT_POINT SvxRectCtl::GetApproxRPFromPixPt( const ::com::sun::star::awt::Point& r ) const
760 {
761 return GetRPFromPoint( GetApproxLogPtFromPixPt( Point( r.X, r.Y ) ) );
762 }
763
764 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
DoCompletelyDisable(sal_Bool bNew)765 void SvxRectCtl::DoCompletelyDisable(sal_Bool bNew)
766 {
767 mbCompleteDisable = bNew;
768 Invalidate();
769 }
770
771 /*************************************************************************
772 |*
773 |* Konstruktor ohne Size-Parameter
774 |*
775 \************************************************************************/
776
SvxAngleCtl(Window * pParent,const ResId & rResId)777 SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId ) :
778
779 SvxRectCtl( pParent, rResId ),
780
781 aFont( Application::GetSettings().GetStyleSettings().GetAppFont() )
782 {
783 aFontSize = Size( 250, 400 );
784 Initialize();
785 }
786
787 /*************************************************************************
788 |*
789 |* Konstruktor mit Size-Parameter
790 |*
791 \************************************************************************/
792
SvxAngleCtl(Window * pParent,const ResId & rResId,Size _aSize)793 SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId, Size _aSize ) :
794
795 SvxRectCtl( pParent, rResId ),
796
797 aFont( Application::GetSettings().GetStyleSettings().GetAppFont() )
798 {
799 aFontSize = _aSize;
800 Initialize();
801 }
802
803 /*************************************************************************
804 |*
805 |* Initialisierung
806 |*
807 \************************************************************************/
808
Initialize()809 void SvxAngleCtl::Initialize()
810 {
811 bPositive = sal_True;
812
813 // aFont.SetName( "Helvetica" );
814 aFont.SetSize( aFontSize );
815 aFont.SetWeight( WEIGHT_NORMAL );
816 aFont.SetTransparent( sal_False );
817
818 SetFont( aFont );
819 }
820
821 /*************************************************************************
822 |*
823 |* Zeichnet das (Mini-)Koordinatensystem
824 |*
825 \************************************************************************/
826
Paint(const Rectangle &)827 void SvxAngleCtl::Paint( const Rectangle& )
828 {
829 SetLineColor( Color( COL_BLACK ) ); // PEN_DOT ???
830 DrawLine( aPtLT - Point( 0, 0), aPtRB + Point( 0, 0 ) );
831 DrawLine( aPtLB - Point( 0, 0), aPtRT + Point( 0, 0 ) );
832
833 SetLineColor( Color( COL_BLACK ) );
834 DrawLine( aPtLM - Point( 0, 0), aPtRM + Point( 0, 0 ) );
835 DrawLine( aPtMT - Point( 0, 0), aPtMB + Point( 0, 0 ) );
836
837 Point aDiff(aFontSize.Width() / 2, aFontSize.Height() / 2);
838
839 DrawText( aPtLT - aDiff, UniString::CreateFromAscii(
840 RTL_CONSTASCII_STRINGPARAM( "135" ) ) );
841 DrawText( aPtLM - aDiff, UniString::CreateFromAscii(
842 RTL_CONSTASCII_STRINGPARAM( "180" ) ) );
843
844 if ( bPositive )
845 DrawText( aPtLB - aDiff, UniString::CreateFromAscii(
846 RTL_CONSTASCII_STRINGPARAM( "225" ) ) );
847 else
848 DrawText( aPtLB - aDiff, UniString::CreateFromAscii(
849 RTL_CONSTASCII_STRINGPARAM( "-135" ) ) );
850
851 aDiff.X() = aFontSize.Width();
852 DrawText( aPtMT - aDiff, UniString::CreateFromAscii(
853 RTL_CONSTASCII_STRINGPARAM( "90" ) ) );
854 DrawText( aPtRT - aDiff, UniString::CreateFromAscii(
855 RTL_CONSTASCII_STRINGPARAM( "45" ) ) );
856 aDiff.X() = aDiff .X() * 3 / 2;
857
858 if ( bPositive )
859 DrawText( aPtMB - aDiff, UniString::CreateFromAscii(
860 RTL_CONSTASCII_STRINGPARAM( "270" ) ) );
861 else
862 DrawText( aPtMB - aDiff, UniString::CreateFromAscii(
863 RTL_CONSTASCII_STRINGPARAM( "-90" ) ) );
864
865 DrawText( aPtRM - Point( 0, aDiff.Y() ), UniString::CreateFromAscii(
866 RTL_CONSTASCII_STRINGPARAM( "0" ) ) );
867 aDiff.X() = aFontSize.Width() * 2;
868
869 if ( bPositive )
870 DrawText( aPtRB - aDiff, UniString::CreateFromAscii(
871 RTL_CONSTASCII_STRINGPARAM( "315" ) ) );
872 else
873 DrawText( aPtRB - aDiff, UniString::CreateFromAscii(
874 RTL_CONSTASCII_STRINGPARAM( "-45" ) ) );
875 }
876
877 /*************************************************************************
878 |*
879 |* Control zum Editieren von Bitmaps
880 |*
881 \************************************************************************/
882
CreateAccessible()883 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > SvxPixelCtl::CreateAccessible()
884 {
885 if(!m_xAccess.is())
886 {
887 m_xAccess = m_pAccess = new SvxPixelCtlAccessible(*this);
888 }
889 return m_xAccess;
890 }
891
892 //Logic Pixel
PointToIndex(const Point & aPt) const893 long SvxPixelCtl::PointToIndex(const Point &aPt) const
894 {
895 sal_uInt16 nX, nY;
896
897 nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
898 nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
899
900 return nX + nY * nLines ;
901 }
IndexToPoint(long nIndex) const902 Point SvxPixelCtl::IndexToPoint(long nIndex) const
903 {
904 DBG_ASSERT(nIndex >= 0 && nIndex < nSquares ," Check Index");
905
906 sal_uInt16 nXIndex = nIndex % nLines ;
907 sal_uInt16 nYIndex = sal_uInt16(nIndex / nLines) ;
908
909 Point aPtTl;
910 aPtTl.Y() = aRectSize.Height() * nYIndex / nLines + 1;
911 aPtTl.X() = aRectSize.Width() * nXIndex / nLines + 1;
912
913 return aPtTl;
914 }
GetFoucsPosIndex() const915 long SvxPixelCtl::GetFoucsPosIndex() const
916 {
917 return aFocusPosition.getX() + aFocusPosition.getY() * nLines ;
918 }
ShowPosition(const Point & pt)919 long SvxPixelCtl::ShowPosition( const Point &pt)
920 {
921 Point aPt = PixelToLogic( pt );
922
923 sal_uInt16 nX, nY;
924 nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
925 nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
926
927 ChangePixel( nX + nY * nLines );
928
929 //Solution:Set new focus position and repaint
930 //Invalidate( Rectangle( aPtTl, aPtBr ) );
931 aFocusPosition.setX(nX);
932 aFocusPosition.setY(nY);
933 Invalidate(Rectangle(Point(0,0),aRectSize));
934
935 if( WINDOW_TABPAGE == GetParent()->GetType() )
936 ( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy
937
938 return GetFoucsPosIndex();
939
940 }
SvxPixelCtl(Window * pParent,const ResId & rResId,sal_uInt16 nNumber)941 SvxPixelCtl::SvxPixelCtl( Window* pParent, const ResId& rResId, sal_uInt16 nNumber ) :
942 Control ( pParent, rResId ),
943 nLines ( nNumber ),
944 bPaintable ( sal_True )
945 //Solution:Initialize it's value to Point(0,0)
946 ,aFocusPosition(0,0)
947 {
948 // SetMapMode( MAP_100TH_MM );
949 aRectSize = GetOutputSize();
950
951 SetPixelColor( Color( COL_BLACK ) );
952 SetBackgroundColor( Color( COL_WHITE ) );
953 SetLineColor( Application::GetSettings().GetStyleSettings().GetShadowColor() );
954
955 nSquares = nLines * nLines;
956 pPixel = new sal_uInt16[ nSquares ];
957 rtl_zeroMemory(pPixel, nSquares * sizeof(sal_uInt16));
958 m_pAccess=NULL;
959 }
960
961 /*************************************************************************
962 |*
963 |* Destruktor dealociert dyn. Array
964 |*
965 \************************************************************************/
966
~SvxPixelCtl()967 SvxPixelCtl::~SvxPixelCtl( )
968 {
969 delete []pPixel;
970 }
971
972 /*************************************************************************
973 |*
974 |* Wechselt die Vordergrund- ,bzw. Hintergrundfarbe
975 |*
976 \************************************************************************/
977
ChangePixel(sal_uInt16 nPixel)978 void SvxPixelCtl::ChangePixel( sal_uInt16 nPixel )
979 {
980 if( *( pPixel + nPixel) == 0 )
981 *( pPixel + nPixel) = 1; // koennte erweitert werden auf mehrere Farben
982 else
983 *( pPixel + nPixel) = 0;
984 }
985
986 /*************************************************************************
987 |*
988 |* Das angeklickte Rechteck wird ermittelt um die Farbe zu wechseln
989 |*
990 \************************************************************************/
991
MouseButtonDown(const MouseEvent & rMEvt)992 void SvxPixelCtl::MouseButtonDown( const MouseEvent& rMEvt )
993 {
994 //Point aPt = PixelToLogic( rMEvt.GetPosPixel() );
995 //Point aPtTl, aPtBr;
996 //sal_uInt16 nX, nY;
997
998 //nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
999 //nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
1000
1001 //ChangePixel( nX + nY * nLines );
1002
1003 //aPtTl.X() = aRectSize.Width() * nX / nLines + 1;
1004 //aPtBr.X() = aRectSize.Width() * (nX + 1) / nLines - 1;
1005 //aPtTl.Y() = aRectSize.Height() * nY / nLines + 1;
1006 //aPtBr.Y() = aRectSize.Height() * (nY + 1) / nLines - 1;
1007
1008 //Invalidate( Rectangle( aPtTl, aPtBr ) );
1009
1010 //if( WINDOW_TABPAGE == GetParent()->GetType() )
1011 // ( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy
1012 //Solution:Grab focus when click in window
1013 if( !HasFocus() )
1014 {
1015 GrabFocus();
1016 }
1017 long nIndex = ShowPosition(rMEvt.GetPosPixel());
1018
1019 if(m_pAccess)
1020 {
1021 m_pAccess->NotifyChild(nIndex,sal_True,sal_True);
1022 }
1023 }
1024
1025 /*************************************************************************
1026 |*
1027 |* Zeichnet das Control (Rechteck mit 9 Kreisen)
1028 |*
1029 \************************************************************************/
1030
Paint(const Rectangle &)1031 void SvxPixelCtl::Paint( const Rectangle& )
1032 {
1033 sal_uInt16 i, j, nTmp;
1034 Point aPtTl, aPtBr;
1035
1036 if( bPaintable )
1037 {
1038 // Linien Zeichnen
1039 Control::SetLineColor( aLineColor );
1040 for( i = 1; i < nLines; i++)
1041 {
1042 // horizontal
1043 nTmp = (sal_uInt16) ( aRectSize.Height() * i / nLines );
1044 DrawLine( Point( 0, nTmp ), Point( aRectSize.Width(), nTmp ) );
1045 // vertikal
1046 nTmp = (sal_uInt16) ( aRectSize.Width() * i / nLines );
1047 DrawLine( Point( nTmp, 0 ), Point( nTmp, aRectSize.Height() ) );
1048 }
1049
1050 // Rechtecke (Quadrate) zeichnen
1051 Control::SetLineColor();
1052 sal_uInt16 nLastPixel = *pPixel ? 0 : 1;
1053
1054 for( i = 0; i < nLines; i++)
1055 {
1056 aPtTl.Y() = aRectSize.Height() * i / nLines + 1;
1057 aPtBr.Y() = aRectSize.Height() * (i + 1) / nLines - 1;
1058
1059 for( j = 0; j < nLines; j++)
1060 {
1061 aPtTl.X() = aRectSize.Width() * j / nLines + 1;
1062 aPtBr.X() = aRectSize.Width() * (j + 1) / nLines - 1;
1063
1064 if ( *( pPixel + i * nLines + j ) != nLastPixel )
1065 {
1066 nLastPixel = *( pPixel + i * nLines + j );
1067 // Farbe wechseln: 0 -> Hintergrundfarbe
1068 SetFillColor( nLastPixel ? aPixelColor : aBackgroundColor );
1069 }
1070 DrawRect( Rectangle( aPtTl, aPtBr ) );
1071 }
1072 }
1073 //Solution:Draw visual focus when has focus
1074 if( HasFocus() )
1075 {
1076 ShowFocus(implCalFocusRect(aFocusPosition));
1077 }
1078 } // bPaintable
1079 else
1080 {
1081 SetBackground( Wallpaper( Color( COL_LIGHTGRAY ) ) );
1082 Control::SetLineColor( Color( COL_LIGHTRED ) );
1083 DrawLine( Point( 0, 0 ), Point( aRectSize.Width(), aRectSize.Height() ) );
1084 DrawLine( Point( 0, aRectSize.Height() ), Point( aRectSize.Width(), 0 ) );
1085 }
1086 }
1087 //Solution:Caculate visual focus rectangle via focus position
implCalFocusRect(const Point & aPosition)1088 Rectangle SvxPixelCtl::implCalFocusRect( const Point& aPosition )
1089 {
1090 long nLeft,nTop,nRight,nBottom;
1091 long i,j;
1092 i = aPosition.Y();
1093 j = aPosition.X();
1094 nLeft = aRectSize.Width() * j / nLines + 1;
1095 nRight = aRectSize.Width() * (j + 1) / nLines - 1;
1096 nTop = aRectSize.Height() * i / nLines + 1;
1097 nBottom = aRectSize.Height() * (i + 1) / nLines - 1;
1098 return Rectangle(nLeft,nTop,nRight,nBottom);
1099 }
1100
1101 //Solution:Keyboard fucntion
KeyInput(const KeyEvent & rKEvt)1102 void SvxPixelCtl::KeyInput( const KeyEvent& rKEvt )
1103 {
1104 KeyCode aKeyCode = rKEvt.GetKeyCode();
1105 sal_uInt16 nCode = aKeyCode.GetCode();
1106 sal_Bool bIsMod = aKeyCode.IsShift() || aKeyCode.IsMod1() || aKeyCode.IsMod2();
1107
1108 if( !bIsMod )
1109 {
1110 Point pRepaintPoint( aRectSize.Width() *( aFocusPosition.getX() - 1)/ nLines - 1,
1111 aRectSize.Height() *( aFocusPosition.getY() - 1)/ nLines -1
1112 );
1113 Size mRepaintSize( aRectSize.Width() *3/ nLines + 2,aRectSize.Height() *3/ nLines + 2);
1114 Rectangle mRepaintRect( pRepaintPoint, mRepaintSize );
1115 sal_Bool bFocusPosChanged=sal_False;
1116 switch(nCode)
1117 {
1118 case KEY_LEFT:
1119 if((aFocusPosition.getX() >= 1))
1120 {
1121 aFocusPosition.setX( aFocusPosition.getX() - 1 );
1122 Invalidate(mRepaintRect);
1123 bFocusPosChanged=sal_True;
1124 }
1125 break;
1126 case KEY_RIGHT:
1127 if( aFocusPosition.getX() < (nLines - 1) )
1128 {
1129 aFocusPosition.setX( aFocusPosition.getX() + 1 );
1130 Invalidate(mRepaintRect);
1131 bFocusPosChanged=sal_True;
1132 }
1133 break;
1134 case KEY_UP:
1135 if((aFocusPosition.getY() >= 1))
1136 {
1137 aFocusPosition.setY( aFocusPosition.getY() - 1 );
1138 Invalidate(mRepaintRect);
1139 bFocusPosChanged=sal_True;
1140 }
1141 break;
1142 case KEY_DOWN:
1143 if( aFocusPosition.getY() < ( nLines - 1 ) )
1144 {
1145 aFocusPosition.setY( aFocusPosition.getY() + 1 );
1146 Invalidate(mRepaintRect);
1147 bFocusPosChanged=sal_True;
1148 }
1149 break;
1150 case KEY_SPACE:
1151 ChangePixel( sal_uInt16(aFocusPosition.getX() + aFocusPosition.getY() * nLines) );
1152 Invalidate( implCalFocusRect(aFocusPosition) );
1153 break;
1154 default:
1155 Control::KeyInput( rKEvt );
1156 return;
1157 }
1158 if(m_xAccess.is())
1159 {
1160 long nIndex = GetFoucsPosIndex();
1161 switch(nCode)
1162 {
1163 case KEY_LEFT:
1164 case KEY_RIGHT:
1165 case KEY_UP:
1166 case KEY_DOWN:
1167 if (bFocusPosChanged)
1168 {
1169 m_pAccess->NotifyChild(nIndex,sal_False,sal_False);
1170 }
1171 break;
1172 case KEY_SPACE:
1173 m_pAccess->NotifyChild(nIndex,sal_False,sal_True);
1174 break;
1175 default:
1176 break;
1177 }
1178 }
1179 }
1180 else
1181 {
1182 Control::KeyInput( rKEvt );
1183 }
1184 }
1185
1186 //Draw focus when get focus
GetFocus()1187 void SvxPixelCtl::GetFocus()
1188 {
1189 Invalidate(implCalFocusRect(aFocusPosition));
1190
1191 if(m_pAccess)
1192 {
1193 m_pAccess->NotifyChild(GetFoucsPosIndex(),sal_True,sal_False);
1194 }
1195
1196 Control::GetFocus();
1197 }
1198
1199 //Hide focus when lose focus
LoseFocus()1200 void SvxPixelCtl::LoseFocus()
1201 {
1202 HideFocus();
1203 if (m_pAccess)
1204 {
1205 m_pAccess->LoseFocus();
1206 }
1207 Control::LoseFocus();
1208 }
1209
1210 /*************************************************************************
1211 |*
1212 |*
1213 |*
1214 \************************************************************************/
1215
SetXBitmap(const BitmapEx & rBitmapEx)1216 void SvxPixelCtl::SetXBitmap( const BitmapEx& rBitmapEx )
1217 {
1218 BitmapColor aBack;
1219 BitmapColor aFront;
1220
1221 if(isHistorical8x8(rBitmapEx, aBack, aFront))
1222 {
1223 Bitmap aBitmap(rBitmapEx.GetBitmap());
1224 BitmapReadAccess* pRead = aBitmap.AcquireReadAccess();
1225
1226 aBackgroundColor = aBack;
1227 aPixelColor = aFront;
1228
1229 for(sal_uInt16 i(0); i < nSquares; i++)
1230 {
1231 const BitmapColor aColor(pRead->GetColor(i/8, i%8));
1232
1233 if(aColor == aBack)
1234 {
1235 *( pPixel + i ) = 0;
1236 }
1237 else
1238 {
1239 *( pPixel + i ) = 1;
1240 }
1241 }
1242
1243 aBitmap.ReleaseAccess(pRead);
1244 }
1245 }
1246
1247 /*************************************************************************
1248 |*
1249 |* Gibt ein bestimmtes Pixel zurueck
1250 |*
1251 \************************************************************************/
1252
GetBitmapPixel(const sal_uInt16 nPixel)1253 sal_uInt16 SvxPixelCtl::GetBitmapPixel( const sal_uInt16 nPixel )
1254 {
1255 return( *( pPixel + nPixel ) );
1256 }
1257
1258 /*************************************************************************
1259 |*
1260 |* Bewirkt den Ursprungszustand des Controls
1261 |*
1262 \************************************************************************/
1263
Reset()1264 void SvxPixelCtl::Reset()
1265 {
1266 // clear pixel area
1267 rtl_zeroMemory(pPixel, nSquares * sizeof(sal_uInt16));
1268 Invalidate();
1269 }
1270
1271 /*************************************************************************
1272 |*
1273 |* Ctor: BitmapCtl fuer SvxPixelCtl
1274 |*
1275 \************************************************************************/
1276
SvxBitmapCtl(Window *,const Size & rSize)1277 SvxBitmapCtl::SvxBitmapCtl( Window* /*pParent*/, const Size& rSize )
1278 {
1279 aSize = rSize;
1280 // aVD.SetOutputSizePixel( aSize );
1281 }
1282
1283 /*************************************************************************
1284 |*
1285 |* Dtor
1286 |*
1287 \************************************************************************/
1288
~SvxBitmapCtl()1289 SvxBitmapCtl::~SvxBitmapCtl()
1290 {
1291 }
1292
1293 /*************************************************************************
1294 |*
1295 |* BitmapCtl: Gibt die Bitmap zurueck
1296 |*
1297 \************************************************************************/
1298
GetBitmapEx()1299 BitmapEx SvxBitmapCtl::GetBitmapEx()
1300 {
1301 const Bitmap aRetval(createHistorical8x8FromArray(pBmpArray, aPixelColor, aBackgroundColor));
1302
1303 return BitmapEx(aRetval);
1304 }
1305
1306 /*************************************************************************
1307 |*
1308 |* Fuellt die Listbox mit Farben und Strings
1309 |*
1310 \************************************************************************/
1311
Fill(const XColorListSharedPtr aColorTab)1312 void ColorLB::Fill( const XColorListSharedPtr aColorTab )
1313 {
1314 long nCount = aColorTab->Count();
1315 XColorEntry* pEntry;
1316 SetUpdateMode( sal_False );
1317
1318 for( long i = 0; i < nCount; i++ )
1319 {
1320 pEntry = aColorTab->GetColor( i );
1321 InsertEntry( pEntry->GetColor(), pEntry->GetName() );
1322 }
1323
1324 AdaptDropDownLineCountToMaximum();
1325 SetUpdateMode( sal_True );
1326 }
1327
1328 /************************************************************************/
1329
Append(const XColorEntry & rEntry)1330 void ColorLB::Append( const XColorEntry& rEntry )
1331 {
1332 InsertEntry( rEntry.GetColor(), rEntry.GetName() );
1333 AdaptDropDownLineCountToMaximum();
1334 }
1335
1336 /************************************************************************/
1337
Modify(const XColorEntry & rEntry,sal_uInt16 nPos)1338 void ColorLB::Modify( const XColorEntry& rEntry, sal_uInt16 nPos )
1339 {
1340 RemoveEntry( nPos );
1341 InsertEntry( rEntry.GetColor(), rEntry.GetName(), nPos );
1342 }
1343
1344 /*************************************************************************
1345 |*
1346 |* Fuellt die Listbox mit Farben und Strings
1347 |*
1348 \************************************************************************/
1349
Fill(const XColorListSharedPtr aColorTab)1350 void FillAttrLB::Fill( const XColorListSharedPtr aColorTab )
1351 {
1352 long nCount = aColorTab->Count();
1353 XColorEntry* pEntry;
1354 SetUpdateMode( sal_False );
1355
1356 for( long i = 0; i < nCount; i++ )
1357 {
1358 pEntry = aColorTab->GetColor( i );
1359 InsertEntry( pEntry->GetColor(), pEntry->GetName() );
1360 }
1361
1362 AdaptDropDownLineCountToMaximum();
1363 SetUpdateMode( sal_True );
1364 }
1365
1366 /*************************************************************************
1367 |*
1368 |* Fuellt die Listbox (vorlaeufig) mit Strings
1369 |*
1370 \************************************************************************/
1371
HatchingLB(Window * pParent,ResId Id)1372 HatchingLB::HatchingLB( Window* pParent, ResId Id)
1373 : ListBox( pParent, Id )
1374 {
1375 SetEdgeBlending(true);
1376 }
1377
HatchingLB(Window * pParent,WinBits aWB)1378 HatchingLB::HatchingLB( Window* pParent, WinBits aWB)
1379 : ListBox( pParent, aWB )
1380 {
1381 SetEdgeBlending(true);
1382 }
1383
Fill(const XHatchListSharedPtr aList)1384 void HatchingLB::Fill( const XHatchListSharedPtr aList )
1385 {
1386 XHatchEntry* pEntry;
1387 long nCount = aList.get() ? aList->Count() : 0;
1388
1389 SetUpdateMode( sal_False );
1390
1391 for( long i = 0; i < nCount; i++ )
1392 {
1393 pEntry = aList->GetHatch( i );
1394 const Bitmap aBitmap = aList->GetUiBitmap( i );
1395 if( !aBitmap.IsEmpty() )
1396 InsertEntry( pEntry->GetName(), aBitmap );
1397 else
1398 InsertEntry( pEntry->GetName() );
1399 }
1400
1401 AdaptDropDownLineCountToMaximum();
1402 SetUpdateMode( sal_True );
1403 }
1404
1405 /************************************************************************/
1406
Append(const XHatchEntry & rEntry,const Bitmap & rBitmap)1407 void HatchingLB::Append( const XHatchEntry& rEntry, const Bitmap& rBitmap )
1408 {
1409 if(!rBitmap.IsEmpty())
1410 {
1411 InsertEntry( rEntry.GetName(), rBitmap );
1412 }
1413 else
1414 {
1415 InsertEntry( rEntry.GetName() );
1416 }
1417
1418 AdaptDropDownLineCountToMaximum();
1419 }
1420
1421 /************************************************************************/
1422
Modify(const XHatchEntry & rEntry,sal_uInt16 nPos,const Bitmap & rBitmap)1423 void HatchingLB::Modify( const XHatchEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap )
1424 {
1425 RemoveEntry( nPos );
1426
1427 if( !rBitmap.IsEmpty() )
1428 {
1429 InsertEntry( rEntry.GetName(), rBitmap, nPos );
1430 }
1431 else
1432 {
1433 InsertEntry( rEntry.GetName(), nPos );
1434 }
1435 }
1436
1437 /************************************************************************/
1438
SelectEntryByList(const XHatchListSharedPtr aList,const String & rStr,const XHatch & rHatch,sal_uInt16 nDist)1439 void HatchingLB::SelectEntryByList( const XHatchListSharedPtr aList, const String& rStr, const XHatch& rHatch, sal_uInt16 nDist )
1440 {
1441 long nCount = aList.get() ? aList->Count() : 0;
1442 XHatchEntry* pEntry;
1443 sal_Bool bFound = sal_False;
1444 String aStr;
1445
1446 long i;
1447 for( i = 0; i < nCount && !bFound; i++ )
1448 {
1449 pEntry = aList->GetHatch( i );
1450
1451 aStr = pEntry->GetName();
1452
1453 if( rStr == aStr && rHatch == pEntry->GetHatch() )
1454 bFound = sal_True;
1455 }
1456 if( bFound )
1457 SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) );
1458 }
1459
1460 /*************************************************************************
1461 |*
1462 |* Fuellt die Listbox (vorlaeufig) mit Strings
1463 |*
1464 \************************************************************************/
1465
Fill(const XHatchListSharedPtr aList)1466 void FillAttrLB::Fill( const XHatchListSharedPtr aList )
1467 {
1468 long nCount = aList.get() ? aList->Count() : 0;
1469 XHatchEntry* pEntry;
1470 ListBox::SetUpdateMode( sal_False );
1471
1472 for( long i = 0; i < nCount; i++ )
1473 {
1474 pEntry = aList->GetHatch( i );
1475 const Bitmap aBitmap = aList->GetUiBitmap( i );
1476 if( !aBitmap.IsEmpty() )
1477 ListBox::InsertEntry( pEntry->GetName(), aBitmap );
1478 else
1479 InsertEntry( pEntry->GetName() );
1480 }
1481
1482 AdaptDropDownLineCountToMaximum();
1483 ListBox::SetUpdateMode( sal_True );
1484 }
1485
1486 /*************************************************************************
1487 |*
1488 |* Fuellt die Listbox (vorlaeufig) mit Strings
1489 |*
1490 \************************************************************************/
1491
GradientLB(Window * pParent,ResId Id)1492 GradientLB::GradientLB( Window* pParent, ResId Id)
1493 : ListBox( pParent, Id )
1494 {
1495 SetEdgeBlending(true);
1496 }
1497
GradientLB(Window * pParent,WinBits aWB)1498 GradientLB::GradientLB( Window* pParent, WinBits aWB)
1499 : ListBox( pParent, aWB )
1500 {
1501 SetEdgeBlending(true);
1502 }
1503
Fill(const XGradientListSharedPtr aList)1504 void GradientLB::Fill( const XGradientListSharedPtr aList )
1505 {
1506 XGradientEntry* pEntry;
1507 long nCount = aList.get() ? aList->Count() : 0;
1508
1509 SetUpdateMode( sal_False );
1510
1511 for( long i = 0; i < nCount; i++ )
1512 {
1513 pEntry = aList->GetGradient( i );
1514 const Bitmap aBitmap = aList->GetUiBitmap( i );
1515 if( !aBitmap.IsEmpty() )
1516 InsertEntry( pEntry->GetName(), aBitmap );
1517 else
1518 InsertEntry( pEntry->GetName() );
1519 }
1520
1521 AdaptDropDownLineCountToMaximum();
1522 SetUpdateMode( sal_True );
1523 }
1524
1525 /************************************************************************/
1526
Append(const XGradientEntry & rEntry,const Bitmap & rBitmap)1527 void GradientLB::Append( const XGradientEntry& rEntry, const Bitmap& rBitmap )
1528 {
1529 if(!rBitmap.IsEmpty())
1530 {
1531 InsertEntry( rEntry.GetName(), rBitmap );
1532 }
1533 else
1534 {
1535 InsertEntry( rEntry.GetName() );
1536 }
1537
1538 AdaptDropDownLineCountToMaximum();
1539 }
1540
1541 /************************************************************************/
1542
Modify(const XGradientEntry & rEntry,sal_uInt16 nPos,const Bitmap & rBitmap)1543 void GradientLB::Modify( const XGradientEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap )
1544 {
1545 RemoveEntry( nPos );
1546
1547 if(!rBitmap.IsEmpty())
1548 {
1549 InsertEntry( rEntry.GetName(), rBitmap, nPos );
1550 }
1551 else
1552 {
1553 InsertEntry( rEntry.GetName(), nPos );
1554 }
1555 }
1556
1557 /************************************************************************/
1558
SelectEntryByList(const XGradientListSharedPtr aList,const String & rStr,const XGradient & rGradient,sal_uInt16 nDist)1559 void GradientLB::SelectEntryByList( const XGradientListSharedPtr aList, const String& rStr, const XGradient& rGradient, sal_uInt16 nDist )
1560 {
1561 long nCount = aList.get() ? aList->Count() : 0;
1562 XGradientEntry* pEntry;
1563 sal_Bool bFound = sal_False;
1564 String aStr;
1565
1566 long i;
1567 for( i = 0; i < nCount && !bFound; i++ )
1568 {
1569 pEntry = aList->GetGradient( i );
1570
1571 aStr = pEntry->GetName();
1572
1573 if( rStr == aStr && rGradient == pEntry->GetGradient() )
1574 bFound = sal_True;
1575 }
1576 if( bFound )
1577 SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) );
1578 }
1579
1580 /*************************************************************************
1581 |*
1582 |* Fuellt die Listbox (vorlaeufig) mit Strings
1583 |*
1584 \************************************************************************/
1585
Fill(const XGradientListSharedPtr aList)1586 void FillAttrLB::Fill( const XGradientListSharedPtr aList )
1587 {
1588 long nCount = aList.get() ? aList->Count() : 0;
1589 XGradientEntry* pEntry;
1590 ListBox::SetUpdateMode( sal_False );
1591
1592 for( long i = 0; i < nCount; i++ )
1593 {
1594 pEntry = aList->GetGradient( i );
1595 const Bitmap aBitmap = aList->GetUiBitmap( i );
1596 if( !aBitmap.IsEmpty() )
1597 ListBox::InsertEntry( pEntry->GetName(), aBitmap );
1598 else
1599 InsertEntry( pEntry->GetName() );
1600 }
1601
1602 AdaptDropDownLineCountToMaximum();
1603 ListBox::SetUpdateMode( sal_True );
1604 }
1605
1606 /*************************************************************************
1607 |*
1608 |* Konstruktor von BitmapLB
1609 |*
1610 \************************************************************************/
1611
BitmapLB(Window * pParent,ResId Id)1612 BitmapLB::BitmapLB(Window* pParent, ResId Id)
1613 : ListBox(pParent, Id),
1614 maBitmapEx()
1615 {
1616 SetEdgeBlending(true);
1617 }
1618
1619 /************************************************************************/
1620
1621 namespace
1622 {
formatBitmapExToSize(BitmapEx & rBitmapEx,const Size & rSize)1623 void formatBitmapExToSize(BitmapEx& rBitmapEx, const Size& rSize)
1624 {
1625 if(!rBitmapEx.IsEmpty() && rSize.Width() > 0 && rSize.Height() > 0)
1626 {
1627 VirtualDevice aVirtualDevice;
1628 aVirtualDevice.SetOutputSizePixel(rSize);
1629
1630 if(rBitmapEx.IsTransparent())
1631 {
1632 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1633
1634 if(rStyleSettings.GetPreviewUsesCheckeredBackground())
1635 {
1636 const Point aNull(0, 0);
1637 static const sal_uInt32 nLen(8);
1638 static const Color aW(COL_WHITE);
1639 static const Color aG(0xef, 0xef, 0xef);
1640
1641 aVirtualDevice.DrawCheckered(aNull, rSize, nLen, aW, aG);
1642 }
1643 else
1644 {
1645 aVirtualDevice.SetBackground(rStyleSettings.GetFieldColor());
1646 aVirtualDevice.Erase();
1647 }
1648 }
1649
1650 if(rBitmapEx.GetSizePixel().Width() >= rSize.Width() && rBitmapEx.GetSizePixel().Height() >= rSize.Height())
1651 {
1652 static sal_uInt32 nScaleFlag(BMP_SCALE_FASTESTINTERPOLATE);
1653
1654 rBitmapEx.Scale(rSize, nScaleFlag);
1655 aVirtualDevice.DrawBitmapEx(Point(0, 0), rBitmapEx);
1656 }
1657 else
1658 {
1659 const Size aBitmapSize(rBitmapEx.GetSizePixel());
1660
1661 for(sal_Int32 y(0); y < rSize.Height(); y += aBitmapSize.Height())
1662 {
1663 for(sal_Int32 x(0); x < rSize.Width(); x += aBitmapSize.Width())
1664 {
1665 aVirtualDevice.DrawBitmapEx(
1666 Point(x, y),
1667 rBitmapEx);
1668 }
1669 }
1670 }
1671
1672 rBitmapEx = aVirtualDevice.GetBitmap(Point(0, 0), rSize);
1673 }
1674 }
1675 } // end of anonymous namespace
1676
1677 /************************************************************************/
1678
Fill(const XBitmapListSharedPtr aList)1679 void BitmapLB::Fill(const XBitmapListSharedPtr aList)
1680 {
1681 XBitmapEntry* pEntry;
1682 const long nCount(aList.get() ? aList->Count() : 0);
1683 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1684 const Size aSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize());
1685
1686 SetUpdateMode(false);
1687
1688 for(long i(0); i < nCount; i++)
1689 {
1690 pEntry = aList->GetBitmap(i);
1691 maBitmapEx = pEntry->GetGraphicObject().GetGraphic().GetBitmapEx();
1692 formatBitmapExToSize(maBitmapEx, aSize);
1693 InsertEntry(pEntry->GetName(), maBitmapEx);
1694 }
1695
1696 AdaptDropDownLineCountToMaximum();
1697 SetUpdateMode(true);
1698 }
1699
1700 /************************************************************************/
1701
Append(const Size & rSize,const XBitmapEntry & rEntry)1702 void BitmapLB::Append(const Size& rSize, const XBitmapEntry& rEntry)
1703 {
1704 maBitmapEx = rEntry.GetGraphicObject().GetGraphic().GetBitmapEx();
1705
1706 if(!maBitmapEx.IsEmpty())
1707 {
1708 formatBitmapExToSize(maBitmapEx, rSize);
1709 InsertEntry(rEntry.GetName(), maBitmapEx);
1710 }
1711 else
1712 {
1713 InsertEntry(rEntry.GetName());
1714 }
1715
1716 AdaptDropDownLineCountToMaximum();
1717 }
1718
1719 /************************************************************************/
1720
Modify(const Size & rSize,const XBitmapEntry & rEntry,sal_uInt16 nPos)1721 void BitmapLB::Modify(const Size& rSize, const XBitmapEntry& rEntry, sal_uInt16 nPos)
1722 {
1723 RemoveEntry(nPos);
1724 maBitmapEx = rEntry.GetGraphicObject().GetGraphic().GetBitmapEx();
1725
1726 if(!maBitmapEx.IsEmpty())
1727 {
1728 formatBitmapExToSize(maBitmapEx, rSize);
1729 InsertEntry(rEntry.GetName(), maBitmapEx, nPos);
1730 }
1731 else
1732 {
1733 InsertEntry(rEntry.GetName());
1734 }
1735 }
1736
1737 /************************************************************************/
1738
SelectEntryByList(const XBitmapListSharedPtr aList,const String & rStr)1739 void BitmapLB::SelectEntryByList(const XBitmapListSharedPtr aList, const String& rStr)
1740 {
1741 const long nCount(aList.get() ? aList->Count() : 0);
1742 XBitmapEntry* pEntry;
1743 bool bFound(false);
1744 long i(0);
1745
1746 for(i = 0; i < nCount && !bFound; i++)
1747 {
1748 pEntry = aList->GetBitmap(i);
1749 const String aStr(pEntry->GetName());
1750
1751 if(rStr == aStr)
1752 {
1753 bFound = true;
1754 }
1755 }
1756
1757 if(bFound)
1758 {
1759 SelectEntryPos((sal_uInt16)(i - 1));
1760 }
1761 }
1762
1763 /*************************************************************************
1764 |*
1765 |* Konstruktor von FillAttrLB
1766 |*
1767 \************************************************************************/
1768
FillAttrLB(Window * pParent,ResId Id)1769 FillAttrLB::FillAttrLB( Window* pParent, ResId Id )
1770 : ColorListBox(pParent, Id),
1771 maBitmapEx()
1772 {
1773 }
1774
1775 /************************************************************************/
1776
FillAttrLB(Window * pParent,WinBits aWB)1777 FillAttrLB::FillAttrLB(Window* pParent, WinBits aWB)
1778 : ColorListBox(pParent, aWB)
1779 {
1780 }
1781
1782 /************************************************************************/
1783
Fill(const XBitmapListSharedPtr aList)1784 void FillAttrLB::Fill(const XBitmapListSharedPtr aList)
1785 {
1786 const long nCount(aList.get() ? aList->Count() : 0);
1787 XBitmapEntry* pEntry;
1788 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1789 const Size aSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize());
1790
1791 ListBox::SetUpdateMode(false);
1792
1793 for(long i(0); i < nCount; i++)
1794 {
1795 pEntry = aList->GetBitmap( i );
1796 maBitmapEx = pEntry->GetGraphicObject().GetGraphic().GetBitmapEx();
1797 formatBitmapExToSize(maBitmapEx, aSize);
1798 ListBox::InsertEntry(pEntry->GetName(), maBitmapEx);
1799 }
1800
1801 AdaptDropDownLineCountToMaximum();
1802 ListBox::SetUpdateMode(true);
1803 }
1804
1805 /************************************************************************/
1806
SelectEntryByList(const XBitmapListSharedPtr aList,const String & rStr)1807 void FillAttrLB::SelectEntryByList( const XBitmapListSharedPtr aList, const String& rStr)
1808 {
1809 const long nCount(aList.get() ? aList->Count() : 0);
1810 XBitmapEntry* pEntry;
1811 bool bFound(false);
1812 long i(0);
1813
1814 for(i = 0; i < nCount && !bFound; i++)
1815 {
1816 pEntry = aList->GetBitmap(i);
1817 const String aStr(pEntry->GetName());
1818
1819 if(rStr == aStr)
1820 {
1821 bFound = true;
1822 }
1823 }
1824
1825 if(bFound)
1826 {
1827 SelectEntryPos((sal_uInt16)(i - 1));
1828 }
1829 }
1830
1831 /*************************************************************************
1832 |*
1833 |* Fuellt die Listbox (vorlaeufig) mit Strings
1834 |*
1835 \************************************************************************/
1836
Fill()1837 void FillTypeLB::Fill()
1838 {
1839 SetUpdateMode( sal_False );
1840
1841 InsertEntry( String( SVX_RES( RID_SVXSTR_INVISIBLE ) ) );
1842 InsertEntry( String( SVX_RES( RID_SVXSTR_COLOR ) ) );
1843 InsertEntry( String( SVX_RES( RID_SVXSTR_GRADIENT ) ) );
1844 InsertEntry( String( SVX_RES( RID_SVXSTR_HATCH ) ) );
1845 InsertEntry( String( SVX_RES( RID_SVXSTR_BITMAP ) ) );
1846
1847 AdaptDropDownLineCountToMaximum();
1848 SetUpdateMode( sal_True );
1849 }
1850
1851 /*************************************************************************
1852 |*
1853 |* Fuellt die Listbox (vorlaeufig) mit Strings
1854 |*
1855 \************************************************************************/
LineLB(Window * pParent,ResId Id)1856 LineLB::LineLB(Window* pParent, ResId Id)
1857 : ListBox(pParent, Id),
1858 mbAddStandardFields(true)
1859 {
1860 // No EdgeBlending for LineStyle/Dash SetEdgeBlending(true);
1861 }
1862
LineLB(Window * pParent,WinBits aWB)1863 LineLB::LineLB(Window* pParent, WinBits aWB)
1864 : ListBox(pParent, aWB),
1865 mbAddStandardFields(true)
1866 {
1867 // No EdgeBlending for LineStyle/Dash SetEdgeBlending(true);
1868 }
1869
~LineLB()1870 LineLB::~LineLB()
1871 {
1872 }
1873
setAddStandardFields(bool bNew)1874 void LineLB::setAddStandardFields(bool bNew)
1875 {
1876 if(getAddStandardFields() != bNew)
1877 {
1878 mbAddStandardFields = bNew;
1879 }
1880 }
1881
Fill(const XDashListSharedPtr aList)1882 void LineLB::Fill( const XDashListSharedPtr aList )
1883 {
1884 Clear();
1885
1886 if(getAddStandardFields() && aList.get())
1887 {
1888 // entry for 'none'
1889 InsertEntry(aList->GetStringForUiNoLine());
1890
1891 // entry for solid line
1892 InsertEntry(aList->GetStringForUiSolidLine(), aList->GetBitmapForUISolidLine());
1893 }
1894
1895 // entries for dashed lines
1896 long nCount = aList.get() ? aList->Count() : 0;
1897 XDashEntry* pEntry;
1898 SetUpdateMode( sal_False );
1899
1900 for( long i = 0; i < nCount; i++ )
1901 {
1902 pEntry = aList->GetDash( i );
1903 const Bitmap aBitmap = aList->GetUiBitmap( i );
1904 if( !aBitmap.IsEmpty() )
1905 {
1906 InsertEntry( pEntry->GetName(), aBitmap );
1907 //delete pBitmap;
1908 }
1909 else
1910 InsertEntry( pEntry->GetName() );
1911 }
1912
1913 AdaptDropDownLineCountToMaximum();
1914 SetUpdateMode( sal_True );
1915 }
1916
1917 /************************************************************************/
1918
Append(const XDashEntry & rEntry,const Bitmap & rBitmap)1919 void LineLB::Append( const XDashEntry& rEntry, const Bitmap& rBitmap )
1920 {
1921 if(!rBitmap.IsEmpty())
1922 {
1923 InsertEntry( rEntry.GetName(), rBitmap );
1924 }
1925 else
1926 {
1927 InsertEntry( rEntry.GetName() );
1928 }
1929
1930 AdaptDropDownLineCountToMaximum();
1931 }
1932
1933 /************************************************************************/
1934
Modify(const XDashEntry & rEntry,sal_uInt16 nPos,const Bitmap & rBitmap)1935 void LineLB::Modify( const XDashEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap )
1936 {
1937 RemoveEntry( nPos );
1938
1939 if(!rBitmap.IsEmpty())
1940 {
1941 InsertEntry( rEntry.GetName(), rBitmap, nPos );
1942 }
1943 else
1944 {
1945 InsertEntry( rEntry.GetName(), nPos );
1946 }
1947 }
1948
1949 /************************************************************************/
1950
SelectEntryByList(const XDashListSharedPtr aList,const String & rStr,const XDash & rDash,sal_uInt16 nDist)1951 void LineLB::SelectEntryByList( const XDashListSharedPtr aList, const String& rStr, const XDash& rDash, sal_uInt16 nDist )
1952 {
1953 long nCount = aList.get() ? aList->Count() : 0;
1954 XDashEntry* pEntry;
1955 sal_Bool bFound = sal_False;
1956 String aStr;
1957 XDash aDash;
1958
1959 long i;
1960 for( i = 0; i < nCount && !bFound; i++ )
1961 {
1962 pEntry = aList->GetDash( i );
1963
1964 aStr = pEntry->GetName();
1965 aDash = pEntry->GetDash();
1966
1967 if( rStr == aStr && rDash == aDash )
1968 bFound = sal_True;
1969 }
1970 if( bFound )
1971 SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) );
1972 }
1973
1974 /*************************************************************************
1975 |*
1976 |* Fuellt die Listbox (vorlaeufig) mit Strings
1977 |*
1978 \************************************************************************/
LineEndLB(Window * pParent,ResId Id)1979 LineEndLB::LineEndLB( Window* pParent, ResId Id )
1980 : ListBox( pParent, Id )
1981 {
1982 // No EdgeBlending for LineEnds SetEdgeBlending(true);
1983 }
1984
LineEndLB(Window * pParent,WinBits aWB)1985 LineEndLB::LineEndLB( Window* pParent, WinBits aWB )
1986 : ListBox( pParent, aWB )
1987 {
1988 // No EdgeBlending for LineEnds SetEdgeBlending(true);
1989 }
1990
~LineEndLB(void)1991 LineEndLB::~LineEndLB(void)
1992 {
1993 }
1994
1995
Fill(const XLineEndListSharedPtr aList,bool bStart)1996 void LineEndLB::Fill( const XLineEndListSharedPtr aList, bool bStart )
1997 {
1998 long nCount = aList.get() ? aList->Count() : 0;
1999 XLineEndEntry* pEntry;
2000 VirtualDevice aVD;
2001 SetUpdateMode( sal_False );
2002
2003 for( long i = 0; i < nCount; i++ )
2004 {
2005 pEntry = aList->GetLineEnd( i );
2006 const Bitmap aBitmap = aList->GetUiBitmap( i );
2007 if( !aBitmap.IsEmpty() )
2008 {
2009 Size aBmpSize( aBitmap.GetSizePixel() );
2010 aVD.SetOutputSizePixel( aBmpSize, sal_False );
2011 aVD.DrawBitmap( Point(), aBitmap );
2012 InsertEntry( pEntry->GetName(),
2013 aVD.GetBitmap( bStart ? Point() : Point( aBmpSize.Width() / 2, 0 ),
2014 Size( aBmpSize.Width() / 2, aBmpSize.Height() ) ) );
2015 //delete pBitmap;
2016 }
2017 else
2018 InsertEntry( pEntry->GetName() );
2019 }
2020
2021 AdaptDropDownLineCountToMaximum();
2022 SetUpdateMode( sal_True );
2023 }
2024
2025 /************************************************************************/
2026
Append(const XLineEndEntry & rEntry,const Bitmap & rBitmap,bool bStart)2027 void LineEndLB::Append( const XLineEndEntry& rEntry, const Bitmap& rBitmap, bool bStart )
2028 {
2029 if(!rBitmap.IsEmpty())
2030 {
2031 VirtualDevice aVD;
2032 const Size aBmpSize(rBitmap.GetSizePixel());
2033
2034 aVD.SetOutputSizePixel(aBmpSize, false);
2035 aVD.DrawBitmap(Point(), rBitmap);
2036 InsertEntry(
2037 rEntry.GetName(),
2038 aVD.GetBitmap(bStart ? Point() : Point(aBmpSize.Width() / 2, 0 ), Size(aBmpSize.Width() / 2, aBmpSize.Height())));
2039 }
2040 else
2041 {
2042 InsertEntry(rEntry.GetName());
2043 }
2044
2045 AdaptDropDownLineCountToMaximum();
2046 }
2047
2048 /************************************************************************/
2049
Modify(const XLineEndEntry & rEntry,sal_uInt16 nPos,const Bitmap & rBitmap,bool bStart)2050 void LineEndLB::Modify( const XLineEndEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap, bool bStart )
2051 {
2052 RemoveEntry( nPos );
2053
2054 if(!rBitmap.IsEmpty())
2055 {
2056 VirtualDevice aVD;
2057 const Size aBmpSize(rBitmap.GetSizePixel());
2058
2059 aVD.SetOutputSizePixel(aBmpSize, false);
2060 aVD.DrawBitmap(Point(), rBitmap);
2061 InsertEntry(
2062 rEntry.GetName(),
2063 aVD.GetBitmap(bStart ? Point() : Point( aBmpSize.Width() / 2, 0 ), Size( aBmpSize.Width() / 2, aBmpSize.Height())),
2064 nPos);
2065 }
2066 else
2067 {
2068 InsertEntry(rEntry.GetName(), nPos);
2069 }
2070 }
2071
2072 //////////////////////////////////////////////////////////////////////////////
2073
InitSettings(bool bForeground,bool bBackground)2074 void SvxPreviewBase::InitSettings(bool bForeground, bool bBackground)
2075 {
2076 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
2077
2078 if(bForeground)
2079 {
2080 svtools::ColorConfig aColorConfig;
2081 Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor);
2082
2083 if(IsControlForeground())
2084 {
2085 aTextColor = GetControlForeground();
2086 }
2087
2088 getBufferDevice().SetTextColor(aTextColor);
2089 }
2090
2091 if(bBackground)
2092 {
2093 if(IsControlBackground())
2094 {
2095 getBufferDevice().SetBackground(GetControlBackground());
2096 }
2097 else
2098 {
2099 getBufferDevice().SetBackground(rStyleSettings.GetWindowColor());
2100 }
2101 }
2102
2103 // do not paint background self, it gets painted buffered
2104 SetControlBackground();
2105 SetBackground();
2106
2107 Invalidate();
2108 }
2109
SvxPreviewBase(Window * pParent,const ResId & rResId)2110 SvxPreviewBase::SvxPreviewBase( Window* pParent, const ResId& rResId )
2111 : Control( pParent, rResId ),
2112 mpModel( new SdrModel() ),
2113 mpBufferDevice( new VirtualDevice(*this) )
2114 {
2115 // Draw the control's border as a flat thin black line.
2116 SetBorderStyle(WINDOW_BORDER_MONO);
2117 SetDrawMode( GetSettings().GetStyleSettings().GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR );
2118 SetMapMode(MAP_100TH_MM);
2119
2120 // init model
2121 mpModel->GetItemPool().FreezeIdRanges();
2122 }
2123
~SvxPreviewBase()2124 SvxPreviewBase::~SvxPreviewBase()
2125 {
2126 delete mpModel;
2127 delete mpBufferDevice;
2128 }
2129
LocalPrePaint()2130 void SvxPreviewBase::LocalPrePaint()
2131 {
2132 // init BufferDevice
2133 if(mpBufferDevice->GetOutputSizePixel() != GetOutputSizePixel())
2134 {
2135 mpBufferDevice->SetDrawMode(GetDrawMode());
2136 mpBufferDevice->SetSettings(GetSettings());
2137 mpBufferDevice->SetAntialiasing(GetAntialiasing());
2138 mpBufferDevice->SetOutputSizePixel(GetOutputSizePixel());
2139 mpBufferDevice->SetMapMode(GetMapMode());
2140 }
2141
2142 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
2143
2144 if(rStyleSettings.GetPreviewUsesCheckeredBackground())
2145 {
2146 const Point aNull(0, 0);
2147 static const sal_uInt32 nLen(8);
2148 static const Color aW(COL_WHITE);
2149 static const Color aG(0xef, 0xef, 0xef);
2150 const bool bWasEnabled(mpBufferDevice->IsMapModeEnabled());
2151
2152 mpBufferDevice->EnableMapMode(false);
2153 mpBufferDevice->DrawCheckered(aNull, mpBufferDevice->GetOutputSizePixel(), nLen, aW, aG);
2154 mpBufferDevice->EnableMapMode(bWasEnabled);
2155 }
2156 else
2157 {
2158 mpBufferDevice->Erase();
2159 }
2160 }
2161
LocalPostPaint()2162 void SvxPreviewBase::LocalPostPaint()
2163 {
2164 // copy to front (in pixel mode)
2165 const bool bWasEnabledSrc(mpBufferDevice->IsMapModeEnabled());
2166 const bool bWasEnabledDst(IsMapModeEnabled());
2167 const Point aEmptyPoint;
2168
2169 mpBufferDevice->EnableMapMode(false);
2170 EnableMapMode(false);
2171
2172 DrawOutDev(
2173 aEmptyPoint, GetOutputSizePixel(),
2174 aEmptyPoint, GetOutputSizePixel(),
2175 *mpBufferDevice);
2176
2177 mpBufferDevice->EnableMapMode(bWasEnabledSrc);
2178 EnableMapMode(bWasEnabledDst);
2179 }
2180
StateChanged(StateChangedType nType)2181 void SvxPreviewBase::StateChanged(StateChangedType nType)
2182 {
2183 Control::StateChanged(nType);
2184
2185 if(STATE_CHANGE_CONTROLFOREGROUND == nType)
2186 {
2187 InitSettings(true, false);
2188 }
2189 else if(STATE_CHANGE_CONTROLBACKGROUND == nType)
2190 {
2191 InitSettings(false, true);
2192 }
2193 }
2194
DataChanged(const DataChangedEvent & rDCEvt)2195 void SvxPreviewBase::DataChanged(const DataChangedEvent& rDCEvt)
2196 {
2197 SetDrawMode(GetSettings().GetStyleSettings().GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR);
2198
2199 if((DATACHANGED_SETTINGS == rDCEvt.GetType()) && (rDCEvt.GetFlags() & SETTINGS_STYLE))
2200 {
2201 InitSettings(true, true);
2202 }
2203 else
2204 {
2205 Control::DataChanged(rDCEvt);
2206 }
2207 }
2208
2209 /*************************************************************************
2210 |*
2211 |* SvxXLinePreview::SvxXLinePreview()
2212 |*
2213 *************************************************************************/
2214
SvxXLinePreview(Window * pParent,const ResId & rResId)2215 SvxXLinePreview::SvxXLinePreview( Window* pParent, const ResId& rResId )
2216 : SvxPreviewBase( pParent, rResId ),
2217 mpLineObjA( 0L ),
2218 mpLineObjB( 0L ),
2219 mpLineObjC( 0L ),
2220 mpGraphic( 0L ),
2221 mbWithSymbol( sal_False )
2222 {
2223 const Size aOutputSize(GetOutputSize());
2224 InitSettings( sal_True, sal_True );
2225
2226 const sal_Int32 nDistance(500L);
2227 const sal_Int32 nAvailableLength(aOutputSize.Width() - (4 * nDistance));
2228
2229 // create DrawObectA
2230 const sal_Int32 aYPosA(aOutputSize.Height() / 2);
2231 const basegfx::B2DPoint aPointA1( nDistance, aYPosA);
2232 const basegfx::B2DPoint aPointA2( aPointA1.getX() + ((nAvailableLength * 14) / 20), aYPosA );
2233 basegfx::B2DPolygon aPolygonA;
2234 aPolygonA.append(aPointA1);
2235 aPolygonA.append(aPointA2);
2236 mpLineObjA = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aPolygonA));
2237 mpLineObjA->SetModel(&getModel());
2238
2239 // create DrawObectB
2240 const sal_Int32 aYPosB1((aOutputSize.Height() * 3) / 4);
2241 const sal_Int32 aYPosB2((aOutputSize.Height() * 1) / 4);
2242 const basegfx::B2DPoint aPointB1( aPointA2.getX() + nDistance, aYPosB1);
2243 const basegfx::B2DPoint aPointB2( aPointB1.getX() + ((nAvailableLength * 2) / 20), aYPosB2 );
2244 const basegfx::B2DPoint aPointB3( aPointB2.getX() + ((nAvailableLength * 2) / 20), aYPosB1 );
2245 basegfx::B2DPolygon aPolygonB;
2246 aPolygonB.append(aPointB1);
2247 aPolygonB.append(aPointB2);
2248 aPolygonB.append(aPointB3);
2249 mpLineObjB = new SdrPathObj(OBJ_PLIN, basegfx::B2DPolyPolygon(aPolygonB));
2250 mpLineObjB->SetModel(&getModel());
2251
2252 // create DrawObectC
2253 const basegfx::B2DPoint aPointC1( aPointB3.getX() + nDistance, aYPosB1);
2254 const basegfx::B2DPoint aPointC2( aPointC1.getX() + ((nAvailableLength * 1) / 20), aYPosB2 );
2255 const basegfx::B2DPoint aPointC3( aPointC2.getX() + ((nAvailableLength * 1) / 20), aYPosB1 );
2256 basegfx::B2DPolygon aPolygonC;
2257 aPolygonC.append(aPointC1);
2258 aPolygonC.append(aPointC2);
2259 aPolygonC.append(aPointC3);
2260 mpLineObjC = new SdrPathObj(OBJ_PLIN, basegfx::B2DPolyPolygon(aPolygonC));
2261 mpLineObjC->SetModel(&getModel());
2262 }
2263
~SvxXLinePreview()2264 SvxXLinePreview::~SvxXLinePreview()
2265 {
2266 SdrObject::Free( mpLineObjA );
2267 SdrObject::Free( mpLineObjB );
2268 SdrObject::Free( mpLineObjC );
2269 }
2270
2271 // -----------------------------------------------------------------------
2272
SetSymbol(Graphic * p,const Size & s)2273 void SvxXLinePreview::SetSymbol(Graphic* p,const Size& s)
2274 {
2275 mpGraphic = p;
2276 maSymbolSize = s;
2277 }
2278
2279 // -----------------------------------------------------------------------
2280
ResizeSymbol(const Size & s)2281 void SvxXLinePreview::ResizeSymbol(const Size& s)
2282 {
2283 if ( s != maSymbolSize )
2284 {
2285 maSymbolSize = s;
2286 Invalidate();
2287 }
2288 }
2289
2290 // -----------------------------------------------------------------------
2291
SetLineAttributes(const SfxItemSet & rItemSet)2292 void SvxXLinePreview::SetLineAttributes(const SfxItemSet& rItemSet)
2293 {
2294 // Set ItemSet at objects
2295 mpLineObjA->SetMergedItemSet(rItemSet);
2296
2297 // At line joints, do not use arrows
2298 SfxItemSet aTempSet(rItemSet);
2299 aTempSet.ClearItem(XATTR_LINESTART);
2300 aTempSet.ClearItem(XATTR_LINEEND);
2301
2302 mpLineObjB->SetMergedItemSet(aTempSet);
2303 mpLineObjC->SetMergedItemSet(aTempSet);
2304 }
2305
2306 // -----------------------------------------------------------------------
2307
Paint(const Rectangle &)2308 void SvxXLinePreview::Paint( const Rectangle& )
2309 {
2310 LocalPrePaint();
2311
2312 // paint objects to buffer device
2313 sdr::contact::SdrObjectVector aObjectVector;
2314 aObjectVector.push_back(mpLineObjA);
2315 aObjectVector.push_back(mpLineObjB);
2316 aObjectVector.push_back(mpLineObjC);
2317
2318 sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0);
2319 sdr::contact::DisplayInfo aDisplayInfo;
2320
2321 // do processing
2322 aPainter.ProcessDisplay(aDisplayInfo);
2323
2324 if ( mbWithSymbol && mpGraphic )
2325 {
2326 const Size aOutputSize(GetOutputSize());
2327 Point aPos = Point( aOutputSize.Width() / 3, aOutputSize.Height() / 2 );
2328 aPos.X() -= maSymbolSize.Width() / 2;
2329 aPos.Y() -= maSymbolSize.Height() / 2;
2330 mpGraphic->Draw( &getBufferDevice(), aPos, maSymbolSize );
2331 }
2332
2333 LocalPostPaint();
2334 }
2335
2336 /*************************************************************************
2337 |*
2338 |* SvxXRectPreview::SvxXRectPreview()
2339 |*
2340 *************************************************************************/
2341
SvxXRectPreview(Window * pParent,const ResId & rResId)2342 SvxXRectPreview::SvxXRectPreview( Window* pParent, const ResId& rResId )
2343 : SvxPreviewBase( pParent, rResId ),
2344 mpRectangleObject(0)
2345 {
2346 InitSettings(true, true);
2347
2348 // create RectangleObject
2349 const Rectangle aObjectSize(Point(), GetOutputSize());
2350 mpRectangleObject = new SdrRectObj(aObjectSize);
2351 mpRectangleObject->SetModel(&getModel());
2352 }
2353
~SvxXRectPreview()2354 SvxXRectPreview::~SvxXRectPreview()
2355 {
2356 SdrObject::Free(mpRectangleObject);
2357 }
2358
SetAttributes(const SfxItemSet & rItemSet)2359 void SvxXRectPreview::SetAttributes(const SfxItemSet& rItemSet)
2360 {
2361 mpRectangleObject->SetMergedItemSet(rItemSet, true);
2362 mpRectangleObject->SetMergedItem(XLineStyleItem(XLINE_NONE));
2363 }
2364
Paint(const Rectangle &)2365 void SvxXRectPreview::Paint( const Rectangle& )
2366 {
2367 LocalPrePaint();
2368
2369 sdr::contact::SdrObjectVector aObjectVector;
2370
2371 aObjectVector.push_back(mpRectangleObject);
2372
2373 sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0);
2374 sdr::contact::DisplayInfo aDisplayInfo;
2375
2376 aPainter.ProcessDisplay(aDisplayInfo);
2377
2378 LocalPostPaint();
2379 }
2380
2381 /*************************************************************************
2382 |*
2383 |* SvxXShadowPreview::SvxXShadowPreview()
2384 |*
2385 *************************************************************************/
2386
SvxXShadowPreview(Window * pParent,const ResId & rResId)2387 SvxXShadowPreview::SvxXShadowPreview( Window* pParent, const ResId& rResId )
2388 : SvxPreviewBase( pParent, rResId ),
2389 mpRectangleObject(0),
2390 mpRectangleShadow(0)
2391 {
2392 InitSettings(true, true);
2393
2394 // prepare size
2395 Size aSize = GetOutputSize();
2396 aSize.Width() = aSize.Width() / 3;
2397 aSize.Height() = aSize.Height() / 3;
2398
2399 // create RectangleObject
2400 const Rectangle aObjectSize( Point( aSize.Width(), aSize.Height() ), aSize );
2401 mpRectangleObject = new SdrRectObj(aObjectSize);
2402 mpRectangleObject->SetModel(&getModel());
2403
2404 // create ShadowObject
2405 const Rectangle aShadowSize( Point( aSize.Width(), aSize.Height() ), aSize );
2406 mpRectangleShadow = new SdrRectObj(aShadowSize);
2407 mpRectangleShadow->SetModel(&getModel());
2408 }
2409
~SvxXShadowPreview()2410 SvxXShadowPreview::~SvxXShadowPreview()
2411 {
2412 SdrObject::Free(mpRectangleObject);
2413 SdrObject::Free(mpRectangleShadow);
2414 }
2415
SetRectangleAttributes(const SfxItemSet & rItemSet)2416 void SvxXShadowPreview::SetRectangleAttributes(const SfxItemSet& rItemSet)
2417 {
2418 mpRectangleObject->SetMergedItemSet(rItemSet, true);
2419 mpRectangleObject->SetMergedItem(XLineStyleItem(XLINE_NONE));
2420 }
2421
SetShadowAttributes(const SfxItemSet & rItemSet)2422 void SvxXShadowPreview::SetShadowAttributes(const SfxItemSet& rItemSet)
2423 {
2424 mpRectangleShadow->SetMergedItemSet(rItemSet, true);
2425 mpRectangleShadow->SetMergedItem(XLineStyleItem(XLINE_NONE));
2426 }
2427
SetShadowPosition(const Point & rPos)2428 void SvxXShadowPreview::SetShadowPosition(const Point& rPos)
2429 {
2430 Rectangle aObjectPosition(mpRectangleObject->GetSnapRect());
2431 aObjectPosition.Move(rPos.X(), rPos.Y());
2432 mpRectangleShadow->SetSnapRect(aObjectPosition);
2433 }
2434
Paint(const Rectangle &)2435 void SvxXShadowPreview::Paint( const Rectangle& )
2436 {
2437 LocalPrePaint();
2438
2439 sdr::contact::SdrObjectVector aObjectVector;
2440
2441 aObjectVector.push_back(mpRectangleShadow);
2442 aObjectVector.push_back(mpRectangleObject);
2443
2444 sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0);
2445 sdr::contact::DisplayInfo aDisplayInfo;
2446
2447 aPainter.ProcessDisplay(aDisplayInfo);
2448
2449 LocalPostPaint();
2450 }
2451
2452 // -----------------------------------------------------------------------
2453 // eof
2454