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