?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / vcl / source / control / button.cxx
blob43234700915358d8120a3a2c579d54d8c15e185f
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: button.cxx,v $
10 * $Revision: 1.63 $
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_vcl.hxx"
33
34 #include <tools/debug.hxx>
35
36 #ifndef _SV_SVIDS_HRC
37 #include <vcl/svids.hrc>
38 #endif
39 #include <vcl/svdata.hxx>
40 #ifndef _SV_IAMGE_HXX
41 #include <vcl/image.hxx>
42 #endif
43 #include <vcl/bitmap.hxx>
44 #include <vcl/bitmapex.hxx>
45 #include <vcl/decoview.hxx>
46 #include <vcl/event.hxx>
47 #include <vcl/svapp.hxx>
48 #include <vcl/dialog.hxx>
49 #include <vcl/fixed.hxx>
50 #include <tools/poly.hxx>
51 #include <vcl/button.hxx>
52 #include <vcl/window.h>
53 #include <vcl/controllayout.hxx>
54 #ifndef _SV_NATIVEWIDGET_HXX
55 #include <vcl/salnativewidgets.hxx>
56 #endif
57 #include <vcl/edit.hxx>
58
59 #ifndef _SV_RC_H
60 #include <tools/rc.h>
61 #endif
62
63
64
65 // =======================================================================
66
67 #define PUSHBUTTON_VIEW_STYLE (WB_3DLOOK | \
68 WB_LEFT | WB_CENTER | WB_RIGHT | \
69 WB_TOP | WB_VCENTER | WB_BOTTOM | \
70 WB_WORDBREAK | WB_NOLABEL | \
71 WB_DEFBUTTON | WB_NOLIGHTBORDER | \
72 WB_RECTSTYLE | WB_SMALLSTYLE | \
73 WB_TOGGLE )
74 #define RADIOBUTTON_VIEW_STYLE (WB_3DLOOK | \
75 WB_LEFT | WB_CENTER | WB_RIGHT | \
76 WB_TOP | WB_VCENTER | WB_BOTTOM | \
77 WB_WORDBREAK | WB_NOLABEL)
78 #define CHECKBOX_VIEW_STYLE (WB_3DLOOK | \
79 WB_LEFT | WB_CENTER | WB_RIGHT | \
80 WB_TOP | WB_VCENTER | WB_BOTTOM | \
81 WB_WORDBREAK | WB_NOLABEL)
82
83 // =======================================================================
84
85 class ImplCommonButtonData
86 {
87 public:
88 Rectangle maFocusRect;
89 USHORT mnButtonState;
90 BOOL mbSmallSymbol;
91
92 Image maImage;
93 Image maImageHC;
94 BitmapEx* mpBitmapEx;
95 BitmapEx* mpBitmapExHC;
96 ImageAlign meImageAlign;
97 SymbolAlign meSymbolAlign;
98
99 public:
100 ImplCommonButtonData();
101 ~ImplCommonButtonData();
102 };
103
104 // -----------------------------------------------------------------------
105 ImplCommonButtonData::ImplCommonButtonData()
106 {
107 mnButtonState = 0;
108 mbSmallSymbol = FALSE;
109
110 mpBitmapEx = NULL;
111 mpBitmapExHC = NULL;
112 meImageAlign = IMAGEALIGN_TOP;
113 meSymbolAlign = SYMBOLALIGN_LEFT;
114 }
115
116 // -----------------------------------------------------------------------
117 ImplCommonButtonData::~ImplCommonButtonData()
118 {
119 delete mpBitmapEx;
120 delete mpBitmapExHC;
121 }
122
123 // =======================================================================
124
125 Button::Button( WindowType nType ) :
126 Control( nType )
127 {
128 mpButtonData = new ImplCommonButtonData;
129 }
130
131 // -----------------------------------------------------------------------
132
133 Button::Button( Window* pParent, WinBits nStyle ) :
134 Control( WINDOW_BUTTON )
135 {
136 mpButtonData = new ImplCommonButtonData;
137 ImplInit( pParent, nStyle, NULL );
138 }
139
140 // -----------------------------------------------------------------------
141
142 Button::Button( Window* pParent, const ResId& rResId ) :
143 Control( WINDOW_BUTTON )
144 {
145 rResId.SetRT( RSC_BUTTON );
146 mpButtonData = new ImplCommonButtonData;
147 WinBits nStyle = ImplInitRes( rResId );
148 ImplInit( pParent, nStyle, NULL );
149 ImplLoadRes( rResId );
150
151 if ( !(nStyle & WB_HIDE) )
152 Show();
153 }
154
155 // -----------------------------------------------------------------------
156
157 Button::~Button()
158 {
159 delete mpButtonData;
160 }
161
162 // -----------------------------------------------------------------------
163
164 void Button::Click()
165 {
166 ImplCallEventListenersAndHandler( VCLEVENT_BUTTON_CLICK, maClickHdl, this );
167 }
168
169 // -----------------------------------------------------------------------
170
171 XubString Button::GetStandardText( StandardButtonType eButton )
172 {
173 static struct
174 {
175 sal_uInt32 nResId;
176 const char* pDefText;
177 } aResIdAry[BUTTON_COUNT] =
178 {
179 { SV_BUTTONTEXT_OK, "~OK" },
180 { SV_BUTTONTEXT_CANCEL, "~Cancel" },
181 { SV_BUTTONTEXT_YES, "~Yes" },
182 { SV_BUTTONTEXT_NO, "~No" },
183 { SV_BUTTONTEXT_RETRY, "~Retry" },
184 { SV_BUTTONTEXT_HELP, "~Help" },
185 { SV_BUTTONTEXT_CLOSE, "~Close" },
186 { SV_BUTTONTEXT_MORE, "~More" },
187 { SV_BUTTONTEXT_IGNORE, "~Ignore" },
188 { SV_BUTTONTEXT_ABORT, "~Abort" },
189 { SV_BUTTONTEXT_LESS, "~Less" }
190 };
191
192 String aText;
193 ResMgr* pResMgr = ImplGetResMgr();
194 if( pResMgr )
195 {
196 ResId aResId( aResIdAry[(USHORT)eButton].nResId, *pResMgr );
197 aText = String( aResId );
198 }
199 else
200 {
201 ByteString aT( aResIdAry[(USHORT)eButton].pDefText );
202 aText = String( aT, RTL_TEXTENCODING_ASCII_US );
203 }
204 return aText;
205 }
206
207 // -----------------------------------------------------------------------
208
209 XubString Button::GetStandardHelpText( StandardButtonType /* eButton */ )
210 {
211 XubString aHelpText;
212 return aHelpText;
213 }
214 // -----------------------------------------------------------------------
215 BOOL Button::SetModeImage( const Image& rImage, BmpColorMode eMode )
216 {
217 if( eMode == BMP_COLOR_NORMAL )
218 {
219 if ( rImage != mpButtonData->maImage )
220 {
221 delete mpButtonData->mpBitmapEx;
222
223 mpButtonData->mpBitmapEx = NULL;
224 mpButtonData->maImage = rImage;
225
226 StateChanged( STATE_CHANGE_DATA );
227 }
228 }
229 else if( eMode == BMP_COLOR_HIGHCONTRAST )
230 {
231 if( rImage != mpButtonData->maImageHC )
232 {
233 delete mpButtonData->mpBitmapExHC;
234
235 mpButtonData->mpBitmapExHC = NULL;
236 mpButtonData->maImageHC = rImage;
237
238 StateChanged( STATE_CHANGE_DATA );
239 }
240 }
241 else
242 return FALSE;
243
244 return TRUE;
245 }
246
247 // -----------------------------------------------------------------------
248 const Image Button::GetModeImage( BmpColorMode eMode ) const
249 {
250 if( eMode == BMP_COLOR_NORMAL )
251 {
252 return mpButtonData->maImage;
253 }
254 else if( eMode == BMP_COLOR_HIGHCONTRAST )
255 {
256 return mpButtonData->maImageHC;
257 }
258 else
259 return Image();
260 }
261
262 // -----------------------------------------------------------------------
263 BOOL Button::HasImage() const
264 {
265 return !!(mpButtonData->maImage);
266 }
267
268 // -----------------------------------------------------------------------
269 void Button::SetImageAlign( ImageAlign eAlign )
270 {
271 if ( mpButtonData->meImageAlign != eAlign )
272 {
273 mpButtonData->meImageAlign = eAlign;
274 StateChanged( STATE_CHANGE_DATA );
275 }
276 }
277
278 // -----------------------------------------------------------------------
279 ImageAlign Button::GetImageAlign() const
280 {
281 return mpButtonData->meImageAlign;
282 }
283
284 // -----------------------------------------------------------------------
285 BOOL Button::SetModeBitmap( const BitmapEx& rBitmap, BmpColorMode eMode )
286 {
287 if ( SetModeImage( rBitmap, eMode ) )
288 {
289 if( eMode == BMP_COLOR_NORMAL )
290 {
291 if ( !mpButtonData->mpBitmapEx )
292 mpButtonData->mpBitmapEx = new BitmapEx( rBitmap );
293 }
294 else if ( eMode == BMP_COLOR_HIGHCONTRAST )
295 {
296 if ( !mpButtonData->mpBitmapExHC )
297 mpButtonData->mpBitmapExHC = new BitmapEx( rBitmap );
298 }
299 else
300 return FALSE;
301
302 return TRUE;
303 }
304 return FALSE;
305 }
306
307 // -----------------------------------------------------------------------
308 BitmapEx Button::GetModeBitmap( BmpColorMode eMode ) const
309 {
310 BitmapEx aBmp;
311
312 if ( eMode == BMP_COLOR_NORMAL )
313 {
314 if ( mpButtonData->mpBitmapEx )
315 aBmp = *( mpButtonData->mpBitmapEx );
316 }
317 else if ( eMode == BMP_COLOR_HIGHCONTRAST )
318 {
319 if ( mpButtonData->mpBitmapExHC )
320 aBmp = *( mpButtonData->mpBitmapExHC );
321 }
322
323 return aBmp;
324 }
325
326 // -----------------------------------------------------------------------
327 void Button::SetFocusRect( const Rectangle& rFocusRect )
328 {
329 ImplSetFocusRect( rFocusRect );
330 }
331
332 // -----------------------------------------------------------------------
333 const Rectangle& Button::GetFocusRect() const
334 {
335 return ImplGetFocusRect();
336 }
337
338 // -----------------------------------------------------------------------
339
340 USHORT Button::ImplGetTextStyle( XubString& rText, WinBits nWinStyle,
341 ULONG nDrawFlags )
342 {
343 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
344 USHORT nTextStyle = FixedText::ImplGetTextStyle( nWinStyle & ~WB_DEFBUTTON );
345
346 if ( nDrawFlags & WINDOW_DRAW_NOMNEMONIC )
347 {
348 if ( nTextStyle & TEXT_DRAW_MNEMONIC )
349 {
350 rText = GetNonMnemonicString( rText );
351 nTextStyle &= ~TEXT_DRAW_MNEMONIC;
352 }
353 }
354
355 if ( !(nDrawFlags & WINDOW_DRAW_NODISABLE) )
356 {
357 if ( !IsEnabled() )
358 nTextStyle |= TEXT_DRAW_DISABLE;
359 }
360
361 if ( (nDrawFlags & WINDOW_DRAW_MONO) ||
362 (rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
363 nTextStyle |= TEXT_DRAW_MONO;
364
365 return nTextStyle;
366 }
367
368 // -----------------------------------------------------------------------
369
370 void Button::ImplDrawAlignedImage( OutputDevice* pDev, Point& rPos,
371 Size& rSize, BOOL bLayout,
372 ULONG nImageSep, ULONG nDrawFlags,
373 USHORT nTextStyle, Rectangle *pSymbolRect )
374 {
375 XubString aText( GetText() );
376 BOOL bDrawImage = HasImage() && ! ( ImplGetButtonState() & BUTTON_DRAW_NOIMAGE );
377 BOOL bDrawText = aText.Len() && ! ( ImplGetButtonState() & BUTTON_DRAW_NOTEXT );
378 BOOL bHasSymbol = pSymbolRect ? TRUE : FALSE;
379
380 // No text and no image => nothing to do => return
381 if ( !bDrawImage && !bDrawText && !bHasSymbol )
382 return;
383
384 WinBits nWinStyle = GetStyle();
385 Rectangle aOutRect( rPos, rSize );
386 MetricVector *pVector = bLayout ? &mpLayoutData->m_aUnicodeBoundRects : NULL;
387 String *pDisplayText = bLayout ? &mpLayoutData->m_aDisplayText : NULL;
388 ImageAlign eImageAlign = mpButtonData->meImageAlign;
389 Size aImageSize = mpButtonData->maImage.GetSizePixel();
390
391 if ( ( nDrawFlags & WINDOW_DRAW_NOMNEMONIC ) &&
392 ( nTextStyle & TEXT_DRAW_MNEMONIC ) )
393 {
394 aText = GetNonMnemonicString( aText );
395 nTextStyle &= ~TEXT_DRAW_MNEMONIC;
396 }
397
398 aImageSize.Width() = CalcZoom( aImageSize.Width() );
399 aImageSize.Height() = CalcZoom( aImageSize.Height() );
400
401 // Drawing text or symbol only is simple, use style and output rectangle
402 if ( bHasSymbol && !bDrawImage && !bDrawText )
403 {
404 *pSymbolRect = aOutRect;
405 return;
406 }
407 else if ( bDrawText && !bDrawImage && !bHasSymbol )
408 {
409 Rectangle aDrawRect = aOutRect;
410
411 aOutRect = pDev->GetTextRect( aOutRect, aText, nTextStyle );
412 rSize = aOutRect.GetSize();
413 rPos = aOutRect.TopLeft();
414
415 ImplSetFocusRect( aOutRect );
416
417 pDev->DrawText( aDrawRect, aText, nTextStyle, pVector, pDisplayText );
418 return;
419 }
420
421 // check for HC mode ( image only! )
422 Image *pImage = &(mpButtonData->maImage);
423 BitmapEx *pBitmapEx = mpButtonData->mpBitmapEx;
424
425 Color aBackCol;
426 if( !!(mpButtonData->maImageHC) && ImplGetCurrentBackgroundColor( aBackCol ) )
427 {
428 if( aBackCol.IsDark() )
429 {
430 pImage = &(mpButtonData->maImageHC);
431 pBitmapEx = mpButtonData->mpBitmapExHC;
432 }
433 }
434
435 if ( pBitmapEx && ( pDev->GetOutDevType() == OUTDEV_PRINTER ) )
436 {
437 // Die Groesse richtet sich nach dem Bildschirm, soll auf
438 // dem Drucker genau so aussehen...
439 MapMode aMap100thMM( MAP_100TH_MM );
440 aImageSize = PixelToLogic( aImageSize, aMap100thMM );
441 aImageSize = pDev->LogicToPixel( aImageSize, aMap100thMM );
442 }
443
444 Size aTextSize;
445 Size aSymbolSize;
446 Size aMax;
447 Point aImagePos = rPos;
448 Point aTextPos = rPos;
449 Rectangle aUnion = Rectangle( aImagePos, aImageSize );
450 Rectangle aSymbol;
451 long nSymbolHeight = 0;
452
453 if ( bDrawText || bHasSymbol )
454 {
455 // Get the size of the text output area ( the symbol will be drawn in
456 // this area as well, so the symbol rectangle will be calculated here, too )
457
458 Rectangle aRect = Rectangle( Point(), rSize );
459 Size aTSSize;
460
461 if ( bHasSymbol )
462 {
463 if ( bDrawText )
464 {
465 nSymbolHeight = pDev->GetTextHeight();
466 if ( mpButtonData->mbSmallSymbol )
467 nSymbolHeight = nSymbolHeight * 3 / 4;
468
469 aSymbol = Rectangle( Point(), Size( nSymbolHeight, nSymbolHeight ) );
470 ImplCalcSymbolRect( aSymbol );
471 aRect.Left() += 3 * nSymbolHeight / 2;
472 aTSSize.Width() = 3 * nSymbolHeight / 2;
473 }
474 else
475 {
476 aSymbol = Rectangle( Point(), rSize );
477 ImplCalcSymbolRect( aSymbol );
478 aTSSize.Width() = aSymbol.GetWidth();
479 }
480 aTSSize.Height() = aSymbol.GetHeight();
481 aSymbolSize = aSymbol.GetSize();
482 }
483
484 if ( bDrawText )
485 {
486 if ( ( eImageAlign == IMAGEALIGN_LEFT_TOP ) ||
487 ( eImageAlign == IMAGEALIGN_LEFT ) ||
488 ( eImageAlign == IMAGEALIGN_LEFT_BOTTOM ) ||
489 ( eImageAlign == IMAGEALIGN_RIGHT_TOP ) ||
490 ( eImageAlign == IMAGEALIGN_RIGHT ) ||
491 ( eImageAlign == IMAGEALIGN_RIGHT_BOTTOM ) )
492 {
493 aRect.Right() -= ( aImageSize.Width() + nImageSep );
494 }
495 else if ( ( eImageAlign == IMAGEALIGN_TOP_LEFT ) ||
496 ( eImageAlign == IMAGEALIGN_TOP ) ||
497 ( eImageAlign == IMAGEALIGN_TOP_RIGHT ) ||
498 ( eImageAlign == IMAGEALIGN_BOTTOM_LEFT ) ||
499 ( eImageAlign == IMAGEALIGN_BOTTOM ) ||
500 ( eImageAlign == IMAGEALIGN_BOTTOM_RIGHT ) )
501 {
502 aRect.Bottom() -= ( aImageSize.Height() + nImageSep );
503 }
504
505 aRect = pDev->GetTextRect( aRect, aText, nTextStyle );
506 aTextSize = aRect.GetSize();
507
508 aTSSize.Width() += aTextSize.Width();
509
510 if ( aTSSize.Height() < aTextSize.Height() )
511 aTSSize.Height() = aTextSize.Height();
512 }
513
514 aMax.Width() = aTSSize.Width() > aImageSize.Width() ? aTSSize.Width() : aImageSize.Width();
515 aMax.Height() = aTSSize.Height() > aImageSize.Height() ? aTSSize.Height() : aImageSize.Height();
516
517 // Now calculate the output area for the image and the text acording to the image align flags
518
519 if ( ( eImageAlign == IMAGEALIGN_LEFT ) ||
520 ( eImageAlign == IMAGEALIGN_RIGHT ) )
521 {
522 aImagePos.Y() = rPos.Y() + ( aMax.Height() - aImageSize.Height() ) / 2;
523 aTextPos.Y() = rPos.Y() + ( aMax.Height() - aTSSize.Height() ) / 2;
524 }
525 else if ( ( eImageAlign == IMAGEALIGN_LEFT_BOTTOM ) ||
526 ( eImageAlign == IMAGEALIGN_RIGHT_BOTTOM ) )
527 {
528 aImagePos.Y() = rPos.Y() + aMax.Height() - aImageSize.Height();
529 aTextPos.Y() = rPos.Y() + aMax.Height() - aTSSize.Height();
530 }
531 else if ( ( eImageAlign == IMAGEALIGN_TOP ) ||
532 ( eImageAlign == IMAGEALIGN_BOTTOM ) )
533 {
534 aImagePos.X() = rPos.X() + ( aMax.Width() - aImageSize.Width() ) / 2;
535 aTextPos.X() = rPos.X() + ( aMax.Width() - aTSSize.Width() ) / 2;
536 }
537 else if ( ( eImageAlign == IMAGEALIGN_TOP_RIGHT ) ||
538 ( eImageAlign == IMAGEALIGN_BOTTOM_RIGHT ) )
539 {
540 aImagePos.X() = rPos.X() + aMax.Width() - aImageSize.Width();
541 aTextPos.X() = rPos.X() + aMax.Width() - aTSSize.Width();
542 }
543
544 if ( ( eImageAlign == IMAGEALIGN_LEFT_TOP ) ||
545 ( eImageAlign == IMAGEALIGN_LEFT ) ||
546 ( eImageAlign == IMAGEALIGN_LEFT_BOTTOM ) )
547 {
548 aTextPos.X() = rPos.X() + aImageSize.Width() + nImageSep;
549 }
550 else if ( ( eImageAlign == IMAGEALIGN_RIGHT_TOP ) ||
551 ( eImageAlign == IMAGEALIGN_RIGHT ) ||
552 ( eImageAlign == IMAGEALIGN_RIGHT_BOTTOM ) )
553 {
554 aImagePos.X() = rPos.X() + aTSSize.Width() + nImageSep;
555 }
556 else if ( ( eImageAlign == IMAGEALIGN_TOP_LEFT ) ||
557 ( eImageAlign == IMAGEALIGN_TOP ) ||
558 ( eImageAlign == IMAGEALIGN_TOP_RIGHT ) )
559 {
560 aTextPos.Y() = rPos.Y() + aImageSize.Height() + nImageSep;
561 }
562 else if ( ( eImageAlign == IMAGEALIGN_BOTTOM_LEFT ) ||
563 ( eImageAlign == IMAGEALIGN_BOTTOM ) ||
564 ( eImageAlign == IMAGEALIGN_BOTTOM_RIGHT ) )
565 {
566 aImagePos.Y() = rPos.Y() + aTSSize.Height() + nImageSep;
567 }
568 else if ( eImageAlign == IMAGEALIGN_CENTER )
569 {
570 aImagePos.X() = rPos.X() + ( aMax.Width() - aImageSize.Width() ) / 2;
571 aImagePos.Y() = rPos.Y() + ( aMax.Height() - aImageSize.Height() ) / 2;
572 aTextPos.X() = rPos.X() + ( aMax.Width() - aTSSize.Width() ) / 2;
573 aTextPos.Y() = rPos.Y() + ( aMax.Height() - aTSSize.Height() ) / 2;
574 }
575 aUnion = Rectangle( aImagePos, aImageSize );
576 aUnion.Union( Rectangle( aTextPos, aTSSize ) );
577 }
578
579 // Now place the combination of text and image in the output area of the button
580 // according to the window style (WinBits)
581 long nXOffset = 0;
582 long nYOffset = 0;
583
584 if ( nWinStyle & WB_CENTER )
585 {
586 nXOffset = ( rSize.Width() - aUnion.GetWidth() ) / 2;
587 }
588 else if ( nWinStyle & WB_RIGHT )
589 {
590 nXOffset = rSize.Width() - aUnion.GetWidth();
591 }
592
593 if ( nWinStyle & WB_VCENTER )
594 {
595 nYOffset = ( rSize.Height() - aUnion.GetHeight() ) / 2;
596 }
597 else if ( nWinStyle & WB_BOTTOM )
598 {
599 nYOffset = rSize.Height() - aUnion.GetHeight();
600 }
601
602 // the top left corner should always be visible, so we don't allow negative offsets
603 if ( nXOffset < 0 ) nXOffset = 0;
604 if ( nYOffset < 0 ) nYOffset = 0;
605
606 aImagePos.X() += nXOffset;
607 aImagePos.Y() += nYOffset;
608 aTextPos.X() += nXOffset;
609 aTextPos.Y() += nYOffset;
610
611 // set rPos and rSize to the union
612 rSize = aUnion.GetSize();
613 rPos.X() += nXOffset;
614 rPos.Y() += nYOffset;
615
616 if ( bHasSymbol )
617 {
618 if ( mpButtonData->meSymbolAlign == SYMBOLALIGN_RIGHT )
619 {
620 Point aRightPos = Point( aTextPos.X() + aTextSize.Width() + aSymbolSize.Width()/2, aTextPos.Y() );
621 *pSymbolRect = Rectangle( aRightPos, aSymbolSize );
622 }
623 else
624 {
625 *pSymbolRect = Rectangle( aTextPos, aSymbolSize );
626 aTextPos.X() += ( 3 * nSymbolHeight / 2 );
627 }
628 if ( mpButtonData->mbSmallSymbol )
629 {
630 nYOffset = (aUnion.GetHeight() - aSymbolSize.Height())/2;
631 pSymbolRect->setY( aTextPos.Y() + nYOffset );
632 }
633 }
634
635 USHORT nStyle = 0;
636
637 if ( ! ( nDrawFlags & WINDOW_DRAW_NODISABLE ) &&
638 ! IsEnabled() )
639 nStyle |= IMAGE_DRAW_DISABLE;
640
641 if ( pBitmapEx && ( pDev->GetOutDevType() == OUTDEV_PRINTER ) )
642 {
643 // Fuer die BitmapEx ueberlegt sich KA noch, wie man die disablete
644 // Darstellung hinbekommt...
645 pBitmapEx->Draw( pDev, aImagePos, aImageSize /*, nStyle*/ );
646 }
647 else
648 {
649 if ( IsZoom() )
650 pDev->DrawImage( aImagePos, aImageSize, *pImage, nStyle );
651 else
652 pDev->DrawImage( aImagePos, *pImage, nStyle );
653 }
654
655 if ( bDrawText )
656 {
657 ImplSetFocusRect( Rectangle( aTextPos, aTextSize ) );
658 pDev->DrawText( Rectangle( aTextPos, aTextSize ), aText, nTextStyle, pVector, pDisplayText );
659 }
660 else
661 {
662 ImplSetFocusRect( Rectangle( aImagePos, aImageSize ) );
663 }
664 }
665
666 // -----------------------------------------------------------------------
667 void Button::ImplSetFocusRect( const Rectangle &rFocusRect )
668 {
669 Rectangle aFocusRect = rFocusRect;
670 Rectangle aOutputRect = Rectangle( Point(), GetOutputSizePixel() );
671
672 if ( ! aFocusRect.IsEmpty() )
673 {
674 aFocusRect.Left()--;
675 aFocusRect.Top()--;
676 aFocusRect.Right()++;
677 aFocusRect.Bottom()++;
678 }
679
680 if ( aFocusRect.Left() < aOutputRect.Left() ) aFocusRect.Left() = aOutputRect.Left();
681 if ( aFocusRect.Top() < aOutputRect.Top() ) aFocusRect.Top() = aOutputRect.Top();
682 if ( aFocusRect.Right() > aOutputRect.Right() ) aFocusRect.Right() = aOutputRect.Right();
683 if ( aFocusRect.Bottom() > aOutputRect.Bottom() ) aFocusRect.Bottom() = aOutputRect.Bottom();
684
685 mpButtonData->maFocusRect = aFocusRect;
686 }
687
688 // -----------------------------------------------------------------------
689 const Rectangle& Button::ImplGetFocusRect() const
690 {
691 return mpButtonData->maFocusRect;
692 }
693
694 // -----------------------------------------------------------------------
695 USHORT& Button::ImplGetButtonState()
696 {
697 return mpButtonData->mnButtonState;
698 }
699
700 // -----------------------------------------------------------------------
701 USHORT Button::ImplGetButtonState() const
702 {
703 return mpButtonData->mnButtonState;
704 }
705
706 // -----------------------------------------------------------------------
707 void Button::ImplSetSymbolAlign( SymbolAlign eAlign )
708 {
709 if ( mpButtonData->meSymbolAlign != eAlign )
710 {
711 mpButtonData->meSymbolAlign = eAlign;
712 StateChanged( STATE_CHANGE_DATA );
713 }
714 }
715
716 // -----------------------------------------------------------------------
717 SymbolAlign Button::ImplGetSymbolAlign() const
718 {
719 return mpButtonData->meSymbolAlign;
720 }
721 // -----------------------------------------------------------------------
722 void Button::ImplSetSmallSymbol( BOOL bSmall )
723 {
724 mpButtonData->mbSmallSymbol = bSmall;
725 }
726
727 // -----------------------------------------------------------------------
728 void Button::EnableImageDisplay( BOOL bEnable )
729 {
730 if( bEnable )
731 mpButtonData->mnButtonState &= ~BUTTON_DRAW_NOIMAGE;
732 else
733 mpButtonData->mnButtonState |= BUTTON_DRAW_NOIMAGE;
734 }
735
736 // -----------------------------------------------------------------------
737 BOOL Button::IsImageDisplayEnabled()
738 {
739 return (mpButtonData->mnButtonState & BUTTON_DRAW_NOIMAGE) == 0;
740 }
741
742 // -----------------------------------------------------------------------
743 void Button::EnableTextDisplay( BOOL bEnable )
744 {
745 if( bEnable )
746 mpButtonData->mnButtonState &= ~BUTTON_DRAW_NOTEXT;
747 else
748 mpButtonData->mnButtonState |= BUTTON_DRAW_NOTEXT;
749 }
750
751 // -----------------------------------------------------------------------
752 BOOL Button::IsTextDisplayEnabled()
753 {
754 return (mpButtonData->mnButtonState & BUTTON_DRAW_NOTEXT) == 0;
755 }
756
757 // -----------------------------------------------------------------------
758 void Button::DataChanged( const DataChangedEvent& rDCEvt )
759 {
760 Control::DataChanged( rDCEvt );
761
762 // The flag SETTINGS_IN_UPDATE_SETTINGS is set when the settings changed due to a
763 // Application::SettingsChanged event. In this scenario we want to keep the style settings
764 // of our radio buttons and our check boxes.
765 if ( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) &&
766 ( rDCEvt.GetFlags() & SETTINGS_IN_UPDATE_SETTINGS ) )
767
768 {
769 const AllSettings* pOldSettings = rDCEvt.GetOldSettings();
770 if ( pOldSettings )
771 {
772 BOOL bResetStyleSettings = FALSE;
773 AllSettings aAllSettings = GetSettings();
774 StyleSettings aStyleSetting = aAllSettings.GetStyleSettings();
775
776 USHORT nCheckBoxStyle = aStyleSetting.GetCheckBoxStyle();
777 if ( nCheckBoxStyle != pOldSettings->GetStyleSettings().GetCheckBoxStyle() )
778 {
779 aStyleSetting.SetCheckBoxStyle( pOldSettings->GetStyleSettings().GetCheckBoxStyle() );
780 bResetStyleSettings = TRUE;
781 }
782
783 USHORT nRadioButtonStyle = aStyleSetting.GetRadioButtonStyle();
784 if ( nRadioButtonStyle != pOldSettings->GetStyleSettings().GetRadioButtonStyle() )
785 {
786 aStyleSetting.SetRadioButtonStyle( pOldSettings->GetStyleSettings().GetRadioButtonStyle() );
787 bResetStyleSettings = TRUE;
788 }
789
790 if ( bResetStyleSettings )
791 {
792 aAllSettings.SetStyleSettings( pOldSettings->GetStyleSettings() );
793 SetSettings( aAllSettings );
794 }
795 }
796 }
797 }
798
799 void Button::SetSmallSymbol (bool small)
800 {
801 ImplSetSmallSymbol (small);
802 }
803
804 bool Button::IsSmallSymbol () const
805 {
806 return mpButtonData->mbSmallSymbol;
807 }
808
809 // =======================================================================
810
811 void PushButton::ImplInitPushButtonData()
812 {
813 mpWindowImpl->mbPushButton = TRUE;
814
815 meSymbol = SYMBOL_NOSYMBOL;
816 meState = STATE_NOCHECK;
817 meSaveValue = STATE_NOCHECK;
818 mnDDStyle = 0;
819 mbPressed = FALSE;
820 mbInUserDraw = FALSE;
821 }
822
823 // -----------------------------------------------------------------------
824
825 void PushButton::ImplInit( Window* pParent, WinBits nStyle )
826 {
827 nStyle = ImplInitStyle( pParent->GetWindow( WINDOW_LASTCHILD ), nStyle );
828 Button::ImplInit( pParent, nStyle, NULL );
829
830 if ( nStyle & WB_NOLIGHTBORDER )
831 ImplGetButtonState() |= BUTTON_DRAW_NOLIGHTBORDER;
832
833 ImplInitSettings( TRUE, TRUE, TRUE );
834 }
835
836 // -----------------------------------------------------------------------
837
838 WinBits PushButton::ImplInitStyle( const Window* pPrevWindow, WinBits nStyle )
839 {
840 if ( !(nStyle & WB_NOTABSTOP) )
841 nStyle |= WB_TABSTOP;
842
843 // if no alignment is given, default to "vertically centered". This is because since
844 // #i26046#, we respect the vertical alignment flags (previously we didn't completely),
845 // but we of course want to look as before when no vertical alignment is specified
846 if ( ( nStyle & ( WB_TOP | WB_VCENTER | WB_BOTTOM ) ) == 0 )
847 nStyle |= WB_VCENTER;
848
849 if ( !(nStyle & WB_NOGROUP) &&
850 (!pPrevWindow ||
851 ((pPrevWindow->GetType() != WINDOW_PUSHBUTTON) &&
852 (pPrevWindow->GetType() != WINDOW_OKBUTTON) &&
853 (pPrevWindow->GetType() != WINDOW_CANCELBUTTON) &&
854 (pPrevWindow->GetType() != WINDOW_HELPBUTTON)) ) )
855 nStyle |= WB_GROUP;
856 return nStyle;
857 }
858
859 // -----------------------------------------------------------------------
860
861 void PushButton::ImplInitSettings( BOOL bFont,
862 BOOL bForeground, BOOL bBackground )
863 {
864 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
865
866 if ( bFont )
867 {
868 Font aFont = rStyleSettings.GetPushButtonFont();
869 if ( IsControlFont() )
870 aFont.Merge( GetControlFont() );
871 SetZoomedPointFont( aFont );
872 }
873
874 if ( bForeground || bFont )
875 {
876 Color aColor;
877 if ( IsControlForeground() )
878 aColor = GetControlForeground();
879 else
880 aColor = rStyleSettings.GetButtonTextColor();
881 SetTextColor( aColor );
882 SetTextFillColor();
883 }
884
885 if ( bBackground )
886 {
887 SetBackground();
888 // #i38498#: do not check for GetParent()->IsChildTransparentModeEnabled()
889 // otherwise the formcontrol button will be overdrawn due to PARENTCLIPMODE_NOCLIP
890 // for radio and checkbox this is ok as they shoud appear transparent in documents
891 if ( IsNativeControlSupported( CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL ) )
892 {
893 EnableChildTransparentMode( TRUE );
894 SetParentClipMode( PARENTCLIPMODE_NOCLIP );
895 SetPaintTransparent( TRUE );
896 mpWindowImpl->mbUseNativeFocus = ImplGetSVData()->maNWFData.mbNoFocusRects;
897 }
898 else
899 {
900 EnableChildTransparentMode( FALSE );
901 SetParentClipMode( 0 );
902 SetPaintTransparent( FALSE );
903 }
904 }
905 }
906
907 // -----------------------------------------------------------------------
908
909 void PushButton::ImplDrawPushButtonFrame( Window* pDev,
910 Rectangle& rRect, USHORT nStyle )
911 {
912 if ( !(pDev->GetStyle() & (WB_RECTSTYLE | WB_SMALLSTYLE)) )
913 {
914 StyleSettings aStyleSettings = pDev->GetSettings().GetStyleSettings();
915 if ( pDev->IsControlBackground() )
916 aStyleSettings.Set3DColors( pDev->GetControlBackground() );
917
918 USHORT nPushButtonSysStyle = aStyleSettings.GetPushButtonStyle() & STYLE_PUSHBUTTON_STYLE;
919 if ( nPushButtonSysStyle == STYLE_PUSHBUTTON_MAC )
920 {
921 pDev->SetLineColor();
922 pDev->SetFillColor( aStyleSettings.GetFaceColor() );
923 pDev->DrawRect( rRect );
924
925 if ( (aStyleSettings.GetOptions() & STYLE_OPTION_MONO) ||
926 (pDev->GetOutDevType() == OUTDEV_PRINTER) )
927 nStyle |= BUTTON_DRAW_MONO;
928
929 if ( nStyle & BUTTON_DRAW_DEFAULT )
930 {
931 if ( nStyle & BUTTON_DRAW_MONO )
932 pDev->SetLineColor( Color( COL_BLACK ) );
933 else
934 pDev->SetLineColor( aStyleSettings.GetDarkShadowColor() );
935
936 pDev->DrawLine( Point( rRect.Left()+3, rRect.Top() ),
937 Point( rRect.Right()-3, rRect.Top() ) );
938 pDev->DrawLine( Point( rRect.Left()+3, rRect.Bottom() ),
939 Point( rRect.Right()-3, rRect.Bottom() ) );
940 pDev->DrawLine( Point( rRect.Left(), rRect.Top()+3 ),
941 Point( rRect.Left(), rRect.Bottom()-3 ) );
942 pDev->DrawLine( Point( rRect.Right(), rRect.Top()+3 ),
943 Point( rRect.Right(), rRect.Bottom()-3 ) );
944 pDev->DrawPixel( Point( rRect.Left()+2, rRect.Top()+1 ) );
945 pDev->DrawPixel( Point( rRect.Left()+1, rRect.Top()+2 ) );
946 pDev->DrawPixel( Point( rRect.Right()-2, rRect.Top()+1 ) );
947 pDev->DrawPixel( Point( rRect.Right()-1, rRect.Top()+2 ) );
948 pDev->DrawPixel( Point( rRect.Left()+2, rRect.Bottom()-1 ) );
949 pDev->DrawPixel( Point( rRect.Left()+1, rRect.Bottom()-2 ) );
950 pDev->DrawPixel( Point( rRect.Right()-2, rRect.Bottom()-1 ) );
951 pDev->DrawPixel( Point( rRect.Right()-1, rRect.Bottom()-2 ) );
952
953 if ( nStyle & BUTTON_DRAW_MONO )
954 pDev->SetLineColor( Color( COL_BLACK ) );
955 else
956 pDev->SetLineColor( aStyleSettings.GetShadowColor() );
957 pDev->DrawLine( Point( rRect.Left()+3, rRect.Bottom()-1 ),
958 Point( rRect.Right()-3, rRect.Bottom()-1 ) );
959 pDev->DrawLine( Point( rRect.Right()-1, rRect.Top()+3 ),
960 Point( rRect.Right()-1, rRect.Bottom()-3 ) );
961 pDev->DrawPixel( Point( rRect.Right()-3, rRect.Bottom()-2 ) );
962 pDev->DrawPixel( Point( rRect.Right()-2, rRect.Bottom()-2 ) );
963 pDev->DrawPixel( Point( rRect.Right()-2, rRect.Bottom()-3 ) );
964 }
965
966 rRect.Left() += 2;
967 rRect.Top() += 2;
968 rRect.Right() -= 2;
969 rRect.Bottom() -= 2;
970
971 if ( nStyle & BUTTON_DRAW_MONO )
972 pDev->SetLineColor( Color( COL_BLACK ) );
973 else
974 pDev->SetLineColor( aStyleSettings.GetDarkShadowColor() );
975
976 pDev->DrawLine( Point( rRect.Left()+2, rRect.Top() ),
977 Point( rRect.Right()-2, rRect.Top() ) );
978 pDev->DrawLine( Point( rRect.Left()+2, rRect.Bottom() ),
979 Point( rRect.Right()-2, rRect.Bottom() ) );
980 pDev->DrawLine( Point( rRect.Left(), rRect.Top()+2 ),
981 Point( rRect.Left(), rRect.Bottom()-2 ) );
982 pDev->DrawLine( Point( rRect.Right(), rRect.Top()+2 ),
983 Point( rRect.Right(), rRect.Bottom()-2 ) );
984 pDev->DrawPixel( Point( rRect.Left()+1, rRect.Top()+1 ) );
985 pDev->DrawPixel( Point( rRect.Right()-1, rRect.Top()+1 ) );
986 pDev->DrawPixel( Point( rRect.Left()+1, rRect.Bottom()-1 ) );
987 pDev->DrawPixel( Point( rRect.Right()-1, rRect.Bottom()-1 ) );
988
989 pDev->SetLineColor();
990 if ( nStyle & BUTTON_DRAW_CHECKED )
991 pDev->SetFillColor( aStyleSettings.GetCheckedColor() );
992 else
993 pDev->SetFillColor( aStyleSettings.GetFaceColor() );
994 pDev->DrawRect( Rectangle( rRect.Left()+2, rRect.Top()+2, rRect.Right()-2, rRect.Bottom()-2 ) );
995
996 if ( !(nStyle & (BUTTON_DRAW_PRESSED | BUTTON_DRAW_CHECKED)) )
997 {
998 if ( nStyle & BUTTON_DRAW_MONO )
999 pDev->SetLineColor( Color( COL_BLACK ) );
1000 else
1001 pDev->SetLineColor( aStyleSettings.GetShadowColor() );
1002 pDev->DrawLine( Point( rRect.Left()+2, rRect.Bottom()-1 ),
1003 Point( rRect.Right()-2, rRect.Bottom()-1 ) );
1004 pDev->DrawLine( Point( rRect.Right()-1, rRect.Top()+2 ),
1005 Point( rRect.Right()-1, rRect.Bottom()-2 ) );
1006 pDev->DrawPixel( Point( rRect.Right()-2, rRect.Bottom()-2 ) );
1007 pDev->SetLineColor( aStyleSettings.GetLightColor() );
1008 }
1009 else
1010 pDev->SetLineColor( aStyleSettings.GetShadowColor() );
1011
1012 if ( !(nStyle & BUTTON_DRAW_MONO) )
1013 {
1014 pDev->DrawLine( Point( rRect.Left()+2, rRect.Top()+1 ),
1015 Point( rRect.Right()-2, rRect.Top()+1 ) );
1016 pDev->DrawLine( Point( rRect.Left()+1, rRect.Top()+2 ),
1017 Point( rRect.Left()+1, rRect.Bottom()-2 ) );
1018 pDev->DrawPixel( Point( rRect.Top()+2, rRect.Right()+2 ) );
1019 }
1020
1021 rRect.Left() += 2;
1022 rRect.Top() += 2;
1023 rRect.Right() -= 2;
1024 rRect.Bottom() -= 2;
1025
1026 if ( nStyle & (BUTTON_DRAW_PRESSED | BUTTON_DRAW_CHECKED) )
1027 {
1028 rRect.Left()++;
1029 rRect.Top()++;
1030 rRect.Right()++;
1031 rRect.Bottom()++;
1032 }
1033
1034 return;
1035 }
1036 }
1037
1038 DecorationView aDecoView( pDev );
1039 if ( pDev->IsControlBackground() )
1040 {
1041 AllSettings aSettings = pDev->GetSettings();
1042 AllSettings aOldSettings = aSettings;
1043 StyleSettings aStyleSettings = aSettings.GetStyleSettings();
1044 aStyleSettings.Set3DColors( pDev->GetControlBackground() );
1045 aSettings.SetStyleSettings( aStyleSettings );
1046 pDev->OutputDevice::SetSettings( aSettings );
1047 rRect = aDecoView.DrawButton( rRect, nStyle );
1048 pDev->OutputDevice::SetSettings( aOldSettings );
1049 }
1050 else
1051 rRect = aDecoView.DrawButton( rRect, nStyle );
1052 }
1053
1054 // -----------------------------------------------------------------------
1055
1056 BOOL PushButton::ImplHitTestPushButton( Window* pDev,
1057 const Point& rPos )
1058 {
1059 Point aTempPoint;
1060 Rectangle aTestRect( aTempPoint, pDev->GetOutputSizePixel() );
1061
1062 if ( !(pDev->GetStyle() & (WB_RECTSTYLE | WB_SMALLSTYLE)) )
1063 {
1064 const StyleSettings& rStyleSettings = pDev->GetSettings().GetStyleSettings();
1065
1066 USHORT nPushButtonSysStyle = rStyleSettings.GetPushButtonStyle() & STYLE_PUSHBUTTON_STYLE;
1067 if ( nPushButtonSysStyle == STYLE_PUSHBUTTON_MAC )
1068 {
1069 aTestRect.Left() += 2;
1070 aTestRect.Top() += 2;
1071 aTestRect.Right() -= 2;
1072 aTestRect.Bottom() -= 2;
1073 }
1074 }
1075
1076 return aTestRect.IsInside( rPos );
1077 }
1078
1079 // -----------------------------------------------------------------------
1080
1081 USHORT PushButton::ImplGetTextStyle( ULONG nDrawFlags ) const
1082 {
1083 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1084
1085 USHORT nTextStyle = TEXT_DRAW_MNEMONIC | TEXT_DRAW_MULTILINE | TEXT_DRAW_ENDELLIPSIS;
1086
1087 if ( ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO ) ||
1088 ( nDrawFlags & WINDOW_DRAW_MONO ) )
1089 nTextStyle |= TEXT_DRAW_MONO;
1090
1091 if ( GetStyle() & WB_WORDBREAK )
1092 nTextStyle |= TEXT_DRAW_WORDBREAK;
1093 if ( GetStyle() & WB_NOLABEL )
1094 nTextStyle &= ~TEXT_DRAW_MNEMONIC;
1095
1096 if ( GetStyle() & WB_LEFT )
1097 nTextStyle |= TEXT_DRAW_LEFT;
1098 else if ( GetStyle() & WB_RIGHT )
1099 nTextStyle |= TEXT_DRAW_RIGHT;
1100 else
1101 nTextStyle |= TEXT_DRAW_CENTER;
1102
1103 if ( GetStyle() & WB_TOP )
1104 nTextStyle |= TEXT_DRAW_TOP;
1105 else if ( GetStyle() & WB_BOTTOM )
1106 nTextStyle |= TEXT_DRAW_BOTTOM;
1107 else
1108 nTextStyle |= TEXT_DRAW_VCENTER;
1109
1110 if ( ! ( (nDrawFlags & WINDOW_DRAW_NODISABLE) || IsEnabled() ) )
1111 nTextStyle |= TEXT_DRAW_DISABLE;
1112
1113 return nTextStyle;
1114 }
1115
1116 // -----------------------------------------------------------------------
1117
1118 static void ImplDrawBtnDropDownArrow( OutputDevice* pDev,
1119 long nX, long nY,
1120 Color& rColor, BOOL bBlack )
1121 {
1122 Color aOldLineColor = pDev->GetLineColor();
1123 Color aOldFillColor = pDev->GetFillColor();
1124
1125 pDev->SetLineColor();
1126 if ( bBlack )
1127 pDev->SetFillColor( Color( COL_BLACK ) );
1128 else
1129 pDev->SetFillColor( rColor );
1130 pDev->DrawRect( Rectangle( nX+0, nY+0, nX+6, nY+0 ) );
1131 pDev->DrawRect( Rectangle( nX+1, nY+1, nX+5, nY+1 ) );
1132 pDev->DrawRect( Rectangle( nX+2, nY+2, nX+4, nY+2 ) );
1133 pDev->DrawRect( Rectangle( nX+3, nY+3, nX+3, nY+3 ) );
1134 if ( bBlack )
1135 {
1136 pDev->SetFillColor( rColor );
1137 pDev->DrawRect( Rectangle( nX+2, nY+1, nX+4, nY+1 ) );
1138 pDev->DrawRect( Rectangle( nX+3, nY+2, nX+3, nY+2 ) );
1139 }
1140 pDev->SetLineColor( aOldLineColor );
1141 pDev->SetFillColor( aOldFillColor );
1142 }
1143
1144 // -----------------------------------------------------------------------
1145
1146 void PushButton::ImplDrawPushButtonContent( OutputDevice* pDev, ULONG nDrawFlags,
1147 const Rectangle& rRect,
1148 bool bLayout )
1149 {
1150 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1151 Rectangle aInRect = rRect;
1152 Color aColor;
1153 XubString aText = PushButton::GetText(); // PushButton:: wegen MoreButton
1154 USHORT nTextStyle = ImplGetTextStyle( nDrawFlags );
1155 USHORT nStyle;
1156
1157 if( aInRect.nRight < aInRect.nLeft || aInRect.nBottom < aInRect.nTop )
1158 aInRect.SetEmpty();
1159
1160 pDev->Push( PUSH_CLIPREGION );
1161 pDev->IntersectClipRegion( aInRect );
1162
1163 if ( nDrawFlags & WINDOW_DRAW_MONO )
1164 aColor = Color( COL_BLACK );
1165 else if ( IsControlForeground() )
1166 aColor = GetControlForeground();
1167 else if( nDrawFlags & WINDOW_DRAW_ROLLOVER )
1168 aColor = rStyleSettings.GetButtonRolloverTextColor();
1169 else
1170 aColor = rStyleSettings.GetButtonTextColor();
1171
1172 pDev->SetTextColor( aColor );
1173
1174 if ( IsEnabled() || (nDrawFlags & WINDOW_DRAW_NODISABLE) )
1175 nStyle = 0;
1176 else
1177 nStyle = SYMBOL_DRAW_DISABLE;
1178
1179 Size aSize = rRect.GetSize();
1180 Point aPos = rRect.TopLeft();
1181
1182 if ( mnDDStyle == PUSHBUTTON_DROPDOWN_MENUBUTTON )
1183 {
1184 if ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) )
1185 {
1186 // calc Symbol- and Textrect
1187 long nSymbolSize = pDev->GetTextHeight() / 2 + 1;
1188 aInRect.Right() -= 5;
1189 aInRect.Left() = aInRect.Right() - nSymbolSize;
1190 aSize.Width() -= ( 5 + nSymbolSize );
1191
1192 ImplDrawAlignedImage( pDev, aPos, aSize, bLayout,
1193 1, nDrawFlags, nTextStyle );
1194 }
1195 else
1196 ImplCalcSymbolRect( aInRect );
1197
1198 if( ! bLayout )
1199 {
1200 DecorationView aDecoView( pDev );
1201 aDecoView.DrawSymbol( aInRect, SYMBOL_SPIN_DOWN, aColor, nStyle );
1202 }
1203 }
1204 else
1205 {
1206 Rectangle aSymbolRect;
1207 ImplDrawAlignedImage( pDev, aPos, aSize, bLayout, 1, nDrawFlags,
1208 nTextStyle, IsSymbol() ? &aSymbolRect : NULL );
1209
1210 if ( IsSymbol() && ! bLayout )
1211 {
1212 DecorationView aDecoView( pDev );
1213 aDecoView.DrawSymbol( aSymbolRect, meSymbol, aColor, nStyle );
1214 }
1215
1216 if ( mnDDStyle == PUSHBUTTON_DROPDOWN_TOOLBOX && !bLayout )
1217 {
1218 BOOL bBlack = FALSE;
1219 Color aArrowColor( COL_BLACK );
1220
1221 if ( !(nDrawFlags & WINDOW_DRAW_MONO) )
1222 {
1223 if ( !IsEnabled() )
1224 aArrowColor = rStyleSettings.GetShadowColor();
1225 else
1226 {
1227 aArrowColor = Color( COL_LIGHTGREEN );
1228 bBlack = TRUE;
1229 }
1230 }
1231
1232 ImplDrawBtnDropDownArrow( pDev, aInRect.Right()-6, aInRect.Top()+1,
1233 aArrowColor, bBlack );
1234 }
1235 }
1236
1237 UserDrawEvent aUDEvt( this, aInRect, 0 );
1238 UserDraw( aUDEvt );
1239
1240 pDev->Pop(); // restore clipregion
1241 }
1242
1243 // -----------------------------------------------------------------------
1244
1245 void PushButton::UserDraw( const UserDrawEvent& )
1246 {
1247 }
1248
1249 // -----------------------------------------------------------------------
1250
1251 void PushButton::ImplDrawPushButton( bool bLayout )
1252 {
1253 if( !bLayout )
1254 HideFocus();
1255
1256 USHORT nButtonStyle = ImplGetButtonState();
1257 Point aPoint;
1258 Size aOutSz( GetOutputSizePixel() );
1259 Rectangle aRect( aPoint, aOutSz );
1260 Rectangle aInRect = aRect;
1261 Rectangle aTextRect;
1262 BOOL bNativeOK = FALSE;
1263
1264 // adjust style if button should be rendered 'pressed'
1265 if ( mbPressed )
1266 nButtonStyle |= BUTTON_DRAW_PRESSED;
1267
1268 // TODO: move this to Window class or make it a member !!!
1269 ControlType aCtrlType = 0;
1270 switch( GetParent()->GetType() )
1271 {
1272 case WINDOW_LISTBOX:
1273 case WINDOW_MULTILISTBOX:
1274 case WINDOW_TREELISTBOX:
1275 aCtrlType = CTRL_LISTBOX;
1276 break;
1277
1278 case WINDOW_COMBOBOX:
1279 case WINDOW_PATTERNBOX:
1280 case WINDOW_NUMERICBOX:
1281 case WINDOW_METRICBOX:
1282 case WINDOW_CURRENCYBOX:
1283 case WINDOW_DATEBOX:
1284 case WINDOW_TIMEBOX:
1285 case WINDOW_LONGCURRENCYBOX:
1286 aCtrlType = CTRL_COMBOBOX;
1287 break;
1288 default:
1289 break;
1290 }
1291
1292 BOOL bDropDown = ( IsSymbol() && (GetSymbol()==SYMBOL_SPIN_DOWN) && !GetText().Len() );
1293
1294 if( bDropDown && (aCtrlType == CTRL_COMBOBOX || aCtrlType == CTRL_LISTBOX ) )
1295 {
1296 if( GetParent()->IsNativeControlSupported( aCtrlType, PART_ENTIRE_CONTROL) )
1297 {
1298 // skip painting if the button was already drawn by the theme
1299 if( aCtrlType == CTRL_COMBOBOX )
1300 {
1301 Edit* pEdit = static_cast<Edit*>(GetParent());
1302 if( pEdit->ImplUseNativeBorder( pEdit->GetStyle() ) )
1303 bNativeOK = TRUE;
1304 }
1305 else if( GetParent()->IsNativeControlSupported( aCtrlType, HAS_BACKGROUND_TEXTURE) )
1306 {
1307 bNativeOK = TRUE;
1308 }
1309 if( !bNativeOK && GetParent()->IsNativeControlSupported( aCtrlType, PART_BUTTON_DOWN ) )
1310 {
1311 // let the theme draw it, note we then need support
1312 // for CTRL_LISTBOX/PART_BUTTON_DOWN and CTRL_COMBOBOX/PART_BUTTON_DOWN
1313
1314 ImplControlValue aControlValue;
1315 Region aCtrlRegion( aInRect );
1316 ControlState nState = 0;
1317
1318 if ( mbPressed ) nState |= CTRL_STATE_PRESSED;
1319 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) nState |= CTRL_STATE_PRESSED;
1320 if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED;
1321 if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT;
1322 if ( Window::IsEnabled() ) nState |= CTRL_STATE_ENABLED;
1323
1324 if ( IsMouseOver() && aInRect.IsInside( GetPointerPosPixel() ) )
1325 nState |= CTRL_STATE_ROLLOVER;
1326
1327 bNativeOK = DrawNativeControl( aCtrlType, PART_BUTTON_DOWN, aCtrlRegion, nState,
1328 aControlValue, rtl::OUString() );
1329 }
1330 }
1331 }
1332
1333 if( bNativeOK )
1334 return;
1335
1336 if ( (bNativeOK=IsNativeControlSupported(CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL)) == TRUE )
1337 {
1338 PushButtonValue aPBVal;
1339 ImplControlValue aControlValue;
1340 aControlValue.setOptionalVal( &aPBVal );
1341 Region aCtrlRegion( aInRect );
1342 ControlState nState = 0;
1343
1344 if ( mbPressed || IsChecked() ) nState |= CTRL_STATE_PRESSED;
1345 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) nState |= CTRL_STATE_PRESSED;
1346 if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED;
1347 if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT;
1348 if ( Window::IsEnabled() ) nState |= CTRL_STATE_ENABLED;
1349
1350 if ( IsMouseOver() && aInRect.IsInside( GetPointerPosPixel() ) )
1351 nState |= CTRL_STATE_ROLLOVER;
1352
1353 if( GetStyle() & WB_BEVELBUTTON )
1354 aPBVal.mbBevelButton = true;
1355
1356 // draw frame into invisible window to have aInRect modified correctly
1357 // but do not shift the inner rect for pressed buttons (ie remove BUTTON_DRAW_PRESSED)
1358 // this assumes the theme has enough visual cues to signalize the button was pressed
1359 //Window aWin( this );
1360 //ImplDrawPushButtonFrame( &aWin, aInRect, nButtonStyle & ~BUTTON_DRAW_PRESSED );
1361
1362 // looks better this way as symbols were displaced slightly using the above approach
1363 aInRect.Top()+=4;
1364 aInRect.Bottom()-=4;
1365 aInRect.Left()+=4;
1366 aInRect.Right()-=4;
1367
1368 // prepare single line hint (needed on mac to decide between normal push button and
1369 // rectangular bevel button look)
1370 Size aFontSize( Application::GetSettings().GetStyleSettings().GetPushButtonFont().GetSize() );
1371 aFontSize = LogicToPixel( aFontSize, MapMode( MAP_POINT ) );
1372 Size aInRectSize( LogicToPixel( Size( aInRect.GetWidth(), aInRect.GetHeight() ) ) );
1373 aPBVal.mbSingleLine = (aInRectSize.Height() < 2 * aFontSize.Height() );
1374
1375 bNativeOK = DrawNativeControl( CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion, nState,
1376 aControlValue, rtl::OUString()/*PushButton::GetText()*/ );
1377
1378 // draw content using the same aInRect as non-native VCL would do
1379 ImplDrawPushButtonContent( this,
1380 (nState&CTRL_STATE_ROLLOVER) ? WINDOW_DRAW_ROLLOVER : 0,
1381 aInRect, bLayout );
1382
1383 if ( HasFocus() )
1384 ShowFocus( ImplGetFocusRect() );
1385 }
1386
1387 if ( bNativeOK == FALSE )
1388 {
1389 // draw PushButtonFrame, aInRect has content size afterwards
1390 if( ! bLayout )
1391 ImplDrawPushButtonFrame( this, aInRect, nButtonStyle );
1392
1393 // draw content
1394 ImplDrawPushButtonContent( this, 0, aInRect, bLayout );
1395
1396 if( ! bLayout && HasFocus() )
1397 {
1398 ShowFocus( ImplGetFocusRect() );
1399 }
1400 }
1401 }
1402
1403 // -----------------------------------------------------------------------
1404
1405 void PushButton::ImplSetDefButton( BOOL bSet )
1406 {
1407 Size aSize( GetSizePixel() );
1408 Point aPos( GetPosPixel() );
1409 int dLeft(0), dRight(0), dTop(0), dBottom(0);
1410 BOOL bSetPos = FALSE;
1411
1412 if ( (IsNativeControlSupported(CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL)) == TRUE )
1413 {
1414 Region aBoundingRgn, aContentRgn;
1415 Rectangle aCtrlRect( 0, 0, 80, 20 ); // use a constant size to avoid accumulating
1416 // will not work if the theme has dynamic adornment sizes
1417 ImplControlValue aControlValue;
1418 Region aCtrlRegion( aCtrlRect );
1419 ControlState nState = CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED;
1420
1421 // get native size of a 'default' button
1422 // and adjust the VCL button if more space for adornment is required
1423 if( GetNativeControlRegion( CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion,
1424 nState, aControlValue, rtl::OUString(),
1425 aBoundingRgn, aContentRgn ) )
1426 {
1427 Rectangle aCont(aContentRgn.GetBoundRect());
1428 Rectangle aBound(aBoundingRgn.GetBoundRect());
1429
1430 dLeft = aCont.Left() - aBound.Left();
1431 dTop = aCont.Top() - aBound.Top();
1432 dRight = aBound.Right() - aCont.Right();
1433 dBottom = aBound.Bottom() - aCont.Bottom();
1434 bSetPos = dLeft || dTop || dRight || dBottom;
1435 }
1436 }
1437
1438 if ( bSet )
1439 {
1440 if( !(ImplGetButtonState() & BUTTON_DRAW_DEFAULT) && bSetPos )
1441 {
1442 // adjust pos/size when toggling from non-default to default
1443 aPos.Move(-dLeft, -dTop);
1444 aSize.Width() += dLeft + dRight;
1445 aSize.Height() += dTop + dBottom;
1446 }
1447 ImplGetButtonState() |= BUTTON_DRAW_DEFAULT;
1448 }
1449 else
1450 {
1451 if( (ImplGetButtonState() & BUTTON_DRAW_DEFAULT) && bSetPos )
1452 {
1453 // adjust pos/size when toggling from default to non-default
1454 aPos.Move(dLeft, dTop);
1455 aSize.Width() -= dLeft + dRight;
1456 aSize.Height() -= dTop + dBottom;
1457 }
1458 ImplGetButtonState() &= ~BUTTON_DRAW_DEFAULT;
1459 }
1460 if( bSetPos )
1461 SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height(), WINDOW_POSSIZE_ALL );
1462
1463 Invalidate();
1464 }
1465
1466 // -----------------------------------------------------------------------
1467
1468 BOOL PushButton::ImplIsDefButton() const
1469 {
1470 return (ImplGetButtonState() & BUTTON_DRAW_DEFAULT) != 0;
1471 }
1472
1473 // -----------------------------------------------------------------------
1474
1475 PushButton::PushButton( WindowType nType ) :
1476 Button( nType )
1477 {
1478 ImplInitPushButtonData();
1479 }
1480
1481 // -----------------------------------------------------------------------
1482
1483 PushButton::PushButton( Window* pParent, WinBits nStyle ) :
1484 Button( WINDOW_PUSHBUTTON )
1485 {
1486 ImplInitPushButtonData();
1487 ImplInit( pParent, nStyle );
1488 }
1489
1490 // -----------------------------------------------------------------------
1491
1492 PushButton::PushButton( Window* pParent, const ResId& rResId ) :
1493 Button( WINDOW_PUSHBUTTON )
1494 {
1495 ImplInitPushButtonData();
1496 rResId.SetRT( RSC_PUSHBUTTON );
1497 WinBits nStyle = ImplInitRes( rResId );
1498 ImplInit( pParent, nStyle );
1499 ImplLoadRes( rResId );
1500
1501 if ( !(nStyle & WB_HIDE) )
1502 Show();
1503 }
1504
1505 // -----------------------------------------------------------------------
1506
1507 PushButton::~PushButton()
1508 {
1509 }
1510
1511 // -----------------------------------------------------------------------
1512
1513 void PushButton::MouseButtonDown( const MouseEvent& rMEvt )
1514 {
1515 if ( rMEvt.IsLeft() &&
1516 ImplHitTestPushButton( this, rMEvt.GetPosPixel() ) )
1517 {
1518 USHORT nTrackFlags = 0;
1519
1520 if ( ( GetStyle() & WB_REPEAT ) &&
1521 ! ( GetStyle() & WB_TOGGLE ) )
1522 nTrackFlags |= STARTTRACK_BUTTONREPEAT;
1523
1524 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
1525 ImplDrawPushButton();
1526 StartTracking( nTrackFlags );
1527
1528 if ( nTrackFlags & STARTTRACK_BUTTONREPEAT )
1529 Click();
1530 }
1531 }
1532
1533 // -----------------------------------------------------------------------
1534
1535 void PushButton::Tracking( const TrackingEvent& rTEvt )
1536 {
1537 if ( rTEvt.IsTrackingEnded() )
1538 {
1539 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
1540 {
1541 if ( !(GetStyle() & WB_NOPOINTERFOCUS) && !rTEvt.IsTrackingCanceled() )
1542 GrabFocus();
1543
1544 if ( GetStyle() & WB_TOGGLE )
1545 {
1546 // Don't toggle, when aborted
1547 if ( !rTEvt.IsTrackingCanceled() )
1548 {
1549 if ( IsChecked() )
1550 {
1551 Check( FALSE );
1552 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
1553 }
1554 else
1555 Check( TRUE );
1556 }
1557 }
1558 else
1559 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
1560
1561 ImplDrawPushButton();
1562
1563 // Bei Abbruch kein Click-Handler rufen
1564 if ( !rTEvt.IsTrackingCanceled() )
1565 {
1566 if ( ! ( ( GetStyle() & WB_REPEAT ) &&
1567 ! ( GetStyle() & WB_TOGGLE ) ) )
1568 Click();
1569 }
1570 }
1571 }
1572 else
1573 {
1574 if ( ImplHitTestPushButton( this, rTEvt.GetMouseEvent().GetPosPixel() ) )
1575 {
1576 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
1577 {
1578 if ( rTEvt.IsTrackingRepeat() && (GetStyle() & WB_REPEAT) &&
1579 ! ( GetStyle() & WB_TOGGLE ) )
1580 Click();
1581 }
1582 else
1583 {
1584 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
1585 ImplDrawPushButton();
1586 }
1587 }
1588 else
1589 {
1590 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
1591 {
1592 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
1593 ImplDrawPushButton();
1594 }
1595 }
1596 }
1597 }
1598
1599 // -----------------------------------------------------------------------
1600
1601 void PushButton::KeyInput( const KeyEvent& rKEvt )
1602 {
1603 KeyCode aKeyCode = rKEvt.GetKeyCode();
1604
1605 if ( !aKeyCode.GetModifier() &&
1606 ((aKeyCode.GetCode() == KEY_RETURN) || (aKeyCode.GetCode() == KEY_SPACE)) )
1607 {
1608 if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) )
1609 {
1610 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
1611 ImplDrawPushButton();
1612 }
1613
1614 if ( ( GetStyle() & WB_REPEAT ) &&
1615 ! ( GetStyle() & WB_TOGGLE ) )
1616 Click();
1617 }
1618 else if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_ESCAPE) )
1619 {
1620 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
1621 ImplDrawPushButton();
1622 }
1623 else
1624 Button::KeyInput( rKEvt );
1625 }
1626
1627 // -----------------------------------------------------------------------
1628
1629 void PushButton::KeyUp( const KeyEvent& rKEvt )
1630 {
1631 KeyCode aKeyCode = rKEvt.GetKeyCode();
1632
1633 if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) &&
1634 ((aKeyCode.GetCode() == KEY_RETURN) || (aKeyCode.GetCode() == KEY_SPACE)) )
1635 {
1636 if ( GetStyle() & WB_TOGGLE )
1637 {
1638 if ( IsChecked() )
1639 {
1640 Check( FALSE );
1641 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
1642 }
1643 else
1644 Check( TRUE );
1645
1646 Toggle();
1647 }
1648 else
1649 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
1650
1651 ImplDrawPushButton();
1652
1653 if ( !( ( GetStyle() & WB_REPEAT ) &&
1654 ! ( GetStyle() & WB_TOGGLE ) ) )
1655 Click();
1656 }
1657 else
1658 Button::KeyUp( rKEvt );
1659 }
1660
1661 // -----------------------------------------------------------------------
1662
1663 void PushButton::FillLayoutData() const
1664 {
1665 mpLayoutData = new vcl::ControlLayoutData();
1666 const_cast<PushButton*>(this)->ImplDrawPushButton( true );
1667 }
1668
1669 // -----------------------------------------------------------------------
1670
1671 void PushButton::Paint( const Rectangle& )
1672 {
1673 ImplDrawPushButton();
1674 }
1675
1676 // -----------------------------------------------------------------------
1677
1678 void PushButton::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
1679 ULONG nFlags )
1680 {
1681 Point aPos = pDev->LogicToPixel( rPos );
1682 Size aSize = pDev->LogicToPixel( rSize );
1683 Rectangle aRect( aPos, aSize );
1684 Rectangle aTextRect;
1685 Font aFont = GetDrawPixelFont( pDev );
1686
1687 pDev->Push();
1688 pDev->SetMapMode();
1689 pDev->SetFont( aFont );
1690 if ( nFlags & WINDOW_DRAW_MONO )
1691 {
1692 pDev->SetTextColor( Color( COL_BLACK ) );
1693 }
1694 else
1695 {
1696 pDev->SetTextColor( GetTextColor() );
1697
1698 // DecoView uses the FaceColor...
1699 AllSettings aSettings = pDev->GetSettings();
1700 StyleSettings aStyleSettings = aSettings.GetStyleSettings();
1701 if ( IsControlBackground() )
1702 aStyleSettings.SetFaceColor( GetControlBackground() );
1703 else
1704 aStyleSettings.SetFaceColor( GetSettings().GetStyleSettings().GetFaceColor() );
1705 aSettings.SetStyleSettings( aStyleSettings );
1706 pDev->SetSettings( aSettings );
1707 }
1708 pDev->SetTextFillColor();
1709
1710 DecorationView aDecoView( pDev );
1711 USHORT nButtonStyle = 0;
1712 if ( nFlags & WINDOW_DRAW_MONO )
1713 nButtonStyle |= BUTTON_DRAW_MONO;
1714 if ( IsChecked() )
1715 nButtonStyle |= BUTTON_DRAW_CHECKED;
1716 aRect = aDecoView.DrawButton( aRect, nButtonStyle );
1717
1718 ImplDrawPushButtonContent( pDev, nFlags, aRect, false );
1719 pDev->Pop();
1720 }
1721
1722 // -----------------------------------------------------------------------
1723
1724 void PushButton::Resize()
1725 {
1726 Control::Resize();
1727 Invalidate();
1728 }
1729
1730 // -----------------------------------------------------------------------
1731
1732 void PushButton::GetFocus()
1733 {
1734 ShowFocus( ImplGetFocusRect() );
1735 SetInputContext( InputContext( GetFont() ) );
1736 Button::GetFocus();
1737 }
1738
1739 // -----------------------------------------------------------------------
1740
1741 void PushButton::LoseFocus()
1742 {
1743 EndSelection();
1744 HideFocus();
1745 Button::LoseFocus();
1746 }
1747
1748 // -----------------------------------------------------------------------
1749
1750 void PushButton::StateChanged( StateChangedType nType )
1751 {
1752 Button::StateChanged( nType );
1753
1754 if ( (nType == STATE_CHANGE_ENABLE) ||
1755 (nType == STATE_CHANGE_TEXT) ||
1756 (nType == STATE_CHANGE_IMAGE) ||
1757 (nType == STATE_CHANGE_DATA) ||
1758 (nType == STATE_CHANGE_STATE) ||
1759 (nType == STATE_CHANGE_UPDATEMODE) )
1760 {
1761 if ( IsReallyVisible() && IsUpdateMode() )
1762 Invalidate();
1763 }
1764 else if ( nType == STATE_CHANGE_STYLE )
1765 {
1766 SetStyle( ImplInitStyle( GetWindow( WINDOW_PREV ), GetStyle() ) );
1767
1768 bool bIsDefButton = ( GetStyle() & WB_DEFBUTTON ) != 0;
1769 bool bWasDefButton = ( GetPrevStyle() & WB_DEFBUTTON ) != 0;
1770 if ( bIsDefButton != bWasDefButton )
1771 ImplSetDefButton( bIsDefButton );
1772
1773 if ( IsReallyVisible() && IsUpdateMode() )
1774 {
1775 if ( (GetPrevStyle() & PUSHBUTTON_VIEW_STYLE) !=
1776 (GetStyle() & PUSHBUTTON_VIEW_STYLE) )
1777 Invalidate();
1778 }
1779 }
1780 else if ( (nType == STATE_CHANGE_ZOOM) ||
1781 (nType == STATE_CHANGE_CONTROLFONT) )
1782 {
1783 ImplInitSettings( TRUE, FALSE, FALSE );
1784 Invalidate();
1785 }
1786 else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
1787 {
1788 ImplInitSettings( FALSE, TRUE, FALSE );
1789 Invalidate();
1790 }
1791 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1792 {
1793 ImplInitSettings( FALSE, FALSE, TRUE );
1794 Invalidate();
1795 }
1796 }
1797
1798 // -----------------------------------------------------------------------
1799
1800 void PushButton::DataChanged( const DataChangedEvent& rDCEvt )
1801 {
1802 Button::DataChanged( rDCEvt );
1803
1804 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1805 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
1806 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1807 (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
1808 {
1809 ImplInitSettings( TRUE, TRUE, TRUE );
1810 Invalidate();
1811 }
1812 }
1813
1814 // -----------------------------------------------------------------------
1815
1816 long PushButton::PreNotify( NotifyEvent& rNEvt )
1817 {
1818 long nDone = 0;
1819 const MouseEvent* pMouseEvt = NULL;
1820
1821 if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL )
1822 {
1823 if( pMouseEvt->IsEnterWindow() || pMouseEvt->IsLeaveWindow() )
1824 {
1825 // trigger redraw as mouse over state has changed
1826
1827 // TODO: move this to Window class or make it a member !!!
1828 ControlType aCtrlType = 0;
1829 switch( GetParent()->GetType() )
1830 {
1831 case WINDOW_LISTBOX:
1832 case WINDOW_MULTILISTBOX:
1833 case WINDOW_TREELISTBOX:
1834 aCtrlType = CTRL_LISTBOX;
1835 break;
1836
1837 case WINDOW_COMBOBOX:
1838 case WINDOW_PATTERNBOX:
1839 case WINDOW_NUMERICBOX:
1840 case WINDOW_METRICBOX:
1841 case WINDOW_CURRENCYBOX:
1842 case WINDOW_DATEBOX:
1843 case WINDOW_TIMEBOX:
1844 case WINDOW_LONGCURRENCYBOX:
1845 aCtrlType = CTRL_COMBOBOX;
1846 break;
1847 default:
1848 break;
1849 }
1850
1851 BOOL bDropDown = ( IsSymbol() && (GetSymbol()==SYMBOL_SPIN_DOWN) && !GetText().Len() );
1852
1853 if( bDropDown && GetParent()->IsNativeControlSupported( aCtrlType, PART_ENTIRE_CONTROL) &&
1854 !GetParent()->IsNativeControlSupported( aCtrlType, PART_BUTTON_DOWN) )
1855 {
1856 Window *pBorder = GetParent()->GetWindow( WINDOW_BORDER );
1857 if(aCtrlType == CTRL_COMBOBOX)
1858 {
1859 // only paint the button part to avoid flickering of the combobox text
1860 Point aPt;
1861 Rectangle aClipRect( aPt, GetOutputSizePixel() );
1862 aClipRect.SetPos(pBorder->ScreenToOutputPixel(OutputToScreenPixel(aClipRect.TopLeft())));
1863 pBorder->Invalidate( aClipRect );
1864 }
1865 else
1866 {
1867 pBorder->Invalidate( INVALIDATE_NOERASE );
1868 pBorder->Update();
1869 }
1870 }
1871 else if( IsNativeControlSupported(CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL) )
1872 {
1873 Invalidate();
1874 }
1875 }
1876 }
1877
1878 return nDone ? nDone : Button::PreNotify(rNEvt);
1879 }
1880
1881 // -----------------------------------------------------------------------
1882
1883 void PushButton::Toggle()
1884 {
1885 ImplCallEventListenersAndHandler( VCLEVENT_PUSHBUTTON_TOGGLE, maToggleHdl, this );
1886 }
1887
1888 // -----------------------------------------------------------------------
1889
1890 void PushButton::SetSymbol( SymbolType eSymbol )
1891 {
1892 if ( meSymbol != eSymbol )
1893 {
1894 meSymbol = eSymbol;
1895 StateChanged( STATE_CHANGE_DATA );
1896 }
1897 }
1898
1899 // -----------------------------------------------------------------------
1900 void PushButton::SetSymbolAlign( SymbolAlign eAlign )
1901 {
1902 ImplSetSymbolAlign( eAlign );
1903 }
1904
1905 // -----------------------------------------------------------------------
1906 SymbolAlign PushButton::GetSymbolAlign() const
1907 {
1908 return ImplGetSymbolAlign();
1909 }
1910
1911 // -----------------------------------------------------------------------
1912
1913 void PushButton::SetDropDown( USHORT nStyle )
1914 {
1915 if ( mnDDStyle != nStyle )
1916 {
1917 mnDDStyle = nStyle;
1918 StateChanged( STATE_CHANGE_DATA );
1919 }
1920 }
1921
1922 // -----------------------------------------------------------------------
1923
1924 void PushButton::SetState( TriState eState )
1925 {
1926 if ( meState != eState )
1927 {
1928 meState = eState;
1929 if ( meState == STATE_NOCHECK )
1930 ImplGetButtonState() &= ~(BUTTON_DRAW_CHECKED | BUTTON_DRAW_DONTKNOW);
1931 else if ( meState == STATE_CHECK )
1932 {
1933 ImplGetButtonState() &= ~BUTTON_DRAW_DONTKNOW;
1934 ImplGetButtonState() |= BUTTON_DRAW_CHECKED;
1935 }
1936 else // STATE_DONTKNOW
1937 {
1938 ImplGetButtonState() &= ~BUTTON_DRAW_CHECKED;
1939 ImplGetButtonState() |= BUTTON_DRAW_DONTKNOW;
1940 }
1941
1942 StateChanged( STATE_CHANGE_STATE );
1943 Toggle();
1944 }
1945 }
1946
1947 // -----------------------------------------------------------------------
1948
1949 void PushButton::SetPressed( BOOL bPressed )
1950 {
1951 if ( mbPressed != bPressed )
1952 {
1953 mbPressed = bPressed;
1954 StateChanged( STATE_CHANGE_DATA );
1955 }
1956 }
1957
1958 // -----------------------------------------------------------------------
1959
1960 void PushButton::EndSelection()
1961 {
1962 EndTracking( ENDTRACK_CANCEL );
1963 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
1964 {
1965 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
1966 if ( !mbPressed )
1967 ImplDrawPushButton();
1968 }
1969 }
1970
1971 // -----------------------------------------------------------------------
1972
1973 Size PushButton::CalcMinimumSize( long nMaxWidth ) const
1974 {
1975 Size aSize;
1976
1977 if ( IsSymbol() )
1978 {
1979 if ( IsSmallSymbol ())
1980 aSize = Size( 16, 12 );
1981 else
1982 aSize = Size( 26, 24 );
1983 }
1984 else if ( IsImage() && ! (ImplGetButtonState() & BUTTON_DRAW_NOIMAGE) )
1985 aSize = GetModeImage().GetSizePixel();
1986 if ( PushButton::GetText().Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) )
1987 {
1988 ULONG nDrawFlags = 0;
1989 Size textSize = GetTextRect( Rectangle( Point(), Size( nMaxWidth ? nMaxWidth : 0x7fffffff, 0x7fffffff ) ),
1990 PushButton::GetText(), ImplGetTextStyle( nDrawFlags ) ).GetSize();
1991 aSize.Width() += int( textSize.Width () * 1.15 );
1992 aSize.Height() = std::max( aSize.Height(), long( textSize.Height() * 1.15 ) );
1993 }
1994
1995 // cf. ImplDrawPushButton ...
1996 aSize.Width() += 8;
1997 aSize.Height() += 8;
1998
1999 return CalcWindowSize( aSize );
2000 }
2001
2002 Size PushButton::GetOptimalSize(WindowSizeType eType) const
2003 {
2004 switch (eType) {
2005 case WINDOWSIZE_MINIMUM: {
2006 return CalcMinimumSize();
2007 }
2008 default:
2009 return Button::GetOptimalSize( eType );
2010 }
2011 }
2012
2013 // =======================================================================
2014
2015 void OKButton::ImplInit( Window* pParent, WinBits nStyle )
2016 {
2017 PushButton::ImplInit( pParent, nStyle );
2018
2019 SetText( Button::GetStandardText( BUTTON_OK ) );
2020 SetHelpText( Button::GetStandardHelpText( BUTTON_OK ) );
2021 }
2022
2023 // -----------------------------------------------------------------------
2024
2025 OKButton::OKButton( Window* pParent, WinBits nStyle ) :
2026 PushButton( WINDOW_OKBUTTON )
2027 {
2028 ImplInit( pParent, nStyle );
2029 }
2030
2031 // -----------------------------------------------------------------------
2032
2033 OKButton::OKButton( Window* pParent, const ResId& rResId ) :
2034 PushButton( WINDOW_OKBUTTON )
2035 {
2036 rResId.SetRT( RSC_OKBUTTON );
2037 WinBits nStyle = ImplInitRes( rResId );
2038 ImplInit( pParent, nStyle );
2039 ImplLoadRes( rResId );
2040
2041 if ( !(nStyle & WB_HIDE) )
2042 Show();
2043 }
2044
2045 // -----------------------------------------------------------------------
2046
2047 void OKButton::Click()
2048 {
2049 // Ist kein Link gesetzt, dann schliesse Parent
2050 if ( !GetClickHdl() )
2051 {
2052 Window* pParent = GetParent();
2053 if ( pParent->IsSystemWindow() )
2054 {
2055 if ( pParent->IsDialog() )
2056 {
2057 if ( ((Dialog*)pParent)->IsInExecute() )
2058 ((Dialog*)pParent)->EndDialog( TRUE );
2059 // gegen rekursive Aufrufe schuetzen
2060 else if ( !((Dialog*)pParent)->IsInClose() )
2061 {
2062 if ( pParent->GetStyle() & WB_CLOSEABLE )
2063 ((Dialog*)pParent)->Close();
2064 }
2065 }
2066 else
2067 {
2068 if ( pParent->GetStyle() & WB_CLOSEABLE )
2069 ((SystemWindow*)pParent)->Close();
2070 }
2071 }
2072 }
2073 else
2074 {
2075 PushButton::Click();
2076 }
2077 }
2078
2079 // =======================================================================
2080
2081 void CancelButton::ImplInit( Window* pParent, WinBits nStyle )
2082 {
2083 PushButton::ImplInit( pParent, nStyle );
2084
2085 SetText( Button::GetStandardText( BUTTON_CANCEL ) );
2086 SetHelpText( Button::GetStandardHelpText( BUTTON_CANCEL ) );
2087 }
2088
2089 // -----------------------------------------------------------------------
2090
2091 CancelButton::CancelButton( Window* pParent, WinBits nStyle ) :
2092 PushButton( WINDOW_CANCELBUTTON )
2093 {
2094 ImplInit( pParent, nStyle );
2095 }
2096
2097 // -----------------------------------------------------------------------
2098
2099 CancelButton::CancelButton( Window* pParent, const ResId& rResId ) :
2100 PushButton( WINDOW_CANCELBUTTON )
2101 {
2102 rResId.SetRT( RSC_CANCELBUTTON );
2103 WinBits nStyle = ImplInitRes( rResId );
2104 ImplInit( pParent, nStyle );
2105 ImplLoadRes( rResId );
2106
2107 if ( !(nStyle & WB_HIDE) )
2108 Show();
2109 }
2110
2111 // -----------------------------------------------------------------------
2112
2113 void CancelButton::Click()
2114 {
2115 // Ist kein Link gesetzt, dann schliesse Parent
2116 if ( !GetClickHdl() )
2117 {
2118 Window* pParent = GetParent();
2119 if ( pParent->IsSystemWindow() )
2120 {
2121 if ( pParent->IsDialog() )
2122 {
2123 if ( ((Dialog*)pParent)->IsInExecute() )
2124 ((Dialog*)pParent)->EndDialog( FALSE );
2125 // gegen rekursive Aufrufe schuetzen
2126 else if ( !((Dialog*)pParent)->IsInClose() )
2127 {
2128 if ( pParent->GetStyle() & WB_CLOSEABLE )
2129 ((Dialog*)pParent)->Close();
2130 }
2131 }
2132 else
2133 {
2134 if ( pParent->GetStyle() & WB_CLOSEABLE )
2135 ((SystemWindow*)pParent)->Close();
2136 }
2137 }
2138 }
2139 else
2140 {
2141 PushButton::Click();
2142 }
2143 }
2144
2145 // =======================================================================
2146
2147 void HelpButton::ImplInit( Window* pParent, WinBits nStyle )
2148 {
2149 PushButton::ImplInit( pParent, nStyle | WB_NOPOINTERFOCUS );
2150
2151 SetText( Button::GetStandardText( BUTTON_HELP ) );
2152 SetHelpText( Button::GetStandardHelpText( BUTTON_HELP ) );
2153 }
2154
2155 // -----------------------------------------------------------------------
2156
2157 HelpButton::HelpButton( Window* pParent, WinBits nStyle ) :
2158 PushButton( WINDOW_HELPBUTTON )
2159 {
2160 ImplInit( pParent, nStyle );
2161 }
2162
2163 // -----------------------------------------------------------------------
2164
2165 HelpButton::HelpButton( Window* pParent, const ResId& rResId ) :
2166 PushButton( WINDOW_HELPBUTTON )
2167 {
2168 rResId.SetRT( RSC_HELPBUTTON );
2169 WinBits nStyle = ImplInitRes( rResId );
2170 ImplInit( pParent, nStyle );
2171 ImplLoadRes( rResId );
2172
2173 if ( !(nStyle & WB_HIDE) )
2174 Show();
2175 }
2176
2177 // -----------------------------------------------------------------------
2178
2179 void HelpButton::Click()
2180 {
2181 // Ist kein Link gesetzt, loese Hilfe aus
2182 if ( !GetClickHdl() )
2183 {
2184 Window* pFocusWin = Application::GetFocusWindow();
2185 if ( !pFocusWin )
2186 pFocusWin = this;
2187
2188 HelpEvent aEvt( pFocusWin->GetPointerPosPixel(), HELPMODE_CONTEXT );
2189 pFocusWin->RequestHelp( aEvt );
2190 }
2191 PushButton::Click();
2192 }
2193
2194 // =======================================================================
2195
2196 void RadioButton::ImplInitRadioButtonData()
2197 {
2198 mbChecked = FALSE;
2199 mbSaveValue = FALSE;
2200 mbRadioCheck = TRUE;
2201 mbStateChanged = FALSE;
2202 }
2203
2204 // -----------------------------------------------------------------------
2205
2206 void RadioButton::ImplInit( Window* pParent, WinBits nStyle )
2207 {
2208 nStyle = ImplInitStyle( pParent->GetWindow( WINDOW_LASTCHILD ), nStyle );
2209 Button::ImplInit( pParent, nStyle, NULL );
2210
2211 ImplInitSettings( TRUE, TRUE, TRUE );
2212 }
2213
2214 // -----------------------------------------------------------------------
2215
2216 WinBits RadioButton::ImplInitStyle( const Window* pPrevWindow, WinBits nStyle )
2217 {
2218 if ( !(nStyle & WB_NOGROUP) &&
2219 (!pPrevWindow || (pPrevWindow->GetType() != WINDOW_RADIOBUTTON)) )
2220 nStyle |= WB_GROUP;
2221 if ( !(nStyle & WB_NOTABSTOP) )
2222 {
2223 if ( IsChecked() )
2224 nStyle |= WB_TABSTOP;
2225 else
2226 nStyle &= ~WB_TABSTOP;
2227 }
2228 return nStyle;
2229 }
2230
2231 // -----------------------------------------------------------------------
2232
2233 void RadioButton::ImplInitSettings( BOOL bFont,
2234 BOOL bForeground, BOOL bBackground )
2235 {
2236 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
2237
2238 if ( bFont )
2239 {
2240 Font aFont = rStyleSettings.GetRadioCheckFont();
2241 if ( IsControlFont() )
2242 aFont.Merge( GetControlFont() );
2243 SetZoomedPointFont( aFont );
2244 }
2245
2246 if ( bForeground || bFont )
2247 {
2248 Color aColor;
2249 if ( IsControlForeground() )
2250 aColor = GetControlForeground();
2251 else
2252 aColor = rStyleSettings.GetRadioCheckTextColor();
2253 SetTextColor( aColor );
2254 SetTextFillColor();
2255 }
2256
2257 if ( bBackground )
2258 {
2259 Window* pParent = GetParent();
2260 if ( !IsControlBackground() &&
2261 (pParent->IsChildTransparentModeEnabled() || IsNativeControlSupported( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL ) ) )
2262 {
2263 EnableChildTransparentMode( TRUE );
2264 SetParentClipMode( PARENTCLIPMODE_NOCLIP );
2265 SetPaintTransparent( TRUE );
2266 SetBackground();
2267 if( IsNativeControlSupported( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL ) )
2268 mpWindowImpl->mbUseNativeFocus = ImplGetSVData()->maNWFData.mbNoFocusRects;
2269 }
2270 else
2271 {
2272 EnableChildTransparentMode( FALSE );
2273 SetParentClipMode( 0 );
2274 SetPaintTransparent( FALSE );
2275
2276 if ( IsControlBackground() )
2277 SetBackground( GetControlBackground() );
2278 else
2279 SetBackground( pParent->GetBackground() );
2280 }
2281 }
2282 }
2283
2284 //---------------------------------------------------------------------
2285 //--- 12.03.2003 18:46:14 ---------------------------------------------
2286
2287 void RadioButton::DrawRadioButtonState( )
2288 {
2289 ImplDrawRadioButtonState( );
2290 }
2291
2292 // -----------------------------------------------------------------------
2293
2294 void RadioButton::ImplInvalidateOrDrawRadioButtonState()
2295 {
2296 if( ImplGetSVData()->maNWFData.mbCheckBoxNeedsErase )
2297 {
2298 if ( IsNativeControlSupported(CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL) )
2299 {
2300 Invalidate();
2301 Update();
2302 return;
2303 }
2304 }
2305 ImplDrawRadioButtonState();
2306 }
2307
2308 void RadioButton::ImplDrawRadioButtonState()
2309 {
2310 USHORT nButtonStyle = 0;
2311 BOOL bNativeOK = FALSE;
2312
2313 // no native drawing for image radio buttons
2314 if ( !maImage && (bNativeOK=IsNativeControlSupported(CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL)) == TRUE )
2315 {
2316 ImplControlValue aControlValue( mbChecked ? BUTTONVALUE_ON : BUTTONVALUE_OFF, rtl::OUString(), 0 );
2317 Rectangle aCtrlRect( maStateRect.TopLeft(), maStateRect.GetSize() );
2318 Region aCtrlRegion( aCtrlRect );
2319 ControlState nState = 0;
2320
2321 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) nState |= CTRL_STATE_PRESSED;
2322 if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED;
2323 if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT;
2324 if ( IsEnabled() ) nState |= CTRL_STATE_ENABLED;
2325
2326 if ( IsMouseOver() && maMouseRect.IsInside( GetPointerPosPixel() ) )
2327 nState |= CTRL_STATE_ROLLOVER;
2328
2329 bNativeOK = DrawNativeControl( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion, nState,
2330 aControlValue,rtl::OUString() );
2331
2332 }
2333
2334 if ( bNativeOK == FALSE )
2335 {
2336 // kein Image-RadioButton
2337 if ( !maImage )
2338 {
2339 USHORT nStyle = ImplGetButtonState();
2340 if ( !IsEnabled() )
2341 nStyle |= BUTTON_DRAW_DISABLED;
2342 if ( mbChecked )
2343 nStyle |= BUTTON_DRAW_CHECKED;
2344 Image aImage = GetRadioImage( GetSettings(), nStyle );
2345 if ( IsZoom() )
2346 DrawImage( maStateRect.TopLeft(), maStateRect.GetSize(), aImage );
2347 else
2348 DrawImage( maStateRect.TopLeft(), aImage );
2349 }
2350 else
2351 {
2352 HideFocus();
2353
2354 DecorationView aDecoView( this );
2355 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
2356 Rectangle aImageRect = maStateRect;
2357 Size aImageSize = maImage.GetSizePixel();
2358 BOOL bEnabled = IsEnabled();
2359
2360 aImageSize.Width() = CalcZoom( aImageSize.Width() );
2361 aImageSize.Height() = CalcZoom( aImageSize.Height() );
2362
2363 // Border und Selektionsstatus ausgeben
2364 nButtonStyle = FRAME_DRAW_DOUBLEIN;
2365 aImageRect = aDecoView.DrawFrame( aImageRect, nButtonStyle );
2366 if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) || !bEnabled )
2367 SetFillColor( rStyleSettings.GetFaceColor() );
2368 else
2369 SetFillColor( rStyleSettings.GetFieldColor() );
2370 SetLineColor();
2371 DrawRect( aImageRect );
2372
2373 // Image ausgeben
2374 nButtonStyle = 0;
2375 if ( !bEnabled )
2376 nButtonStyle |= IMAGE_DRAW_DISABLE;
2377
2378 // check for HC mode
2379 Image *pImage = &maImage;
2380 Color aBackCol;
2381 if( !!maImageHC && ImplGetCurrentBackgroundColor( aBackCol ) )
2382 {
2383 if( aBackCol.IsDark() )
2384 pImage = &maImageHC;
2385 // #99902 no col transform required
2386 //if( aBackCol.IsBright() )
2387 // nStyle |= IMAGE_DRAW_COLORTRANSFORM;
2388 }
2389
2390 Point aImagePos( aImageRect.TopLeft() );
2391 aImagePos.X() += (aImageRect.GetWidth()-aImageSize.Width())/2;
2392 aImagePos.Y() += (aImageRect.GetHeight()-aImageSize.Height())/2;
2393 if ( IsZoom() )
2394 DrawImage( aImagePos, aImageSize, *pImage, nButtonStyle );
2395 else
2396 DrawImage( aImagePos, *pImage, nButtonStyle );
2397
2398 aImageRect.Left()++;
2399 aImageRect.Top()++;
2400 aImageRect.Right()--;
2401 aImageRect.Bottom()--;
2402
2403 ImplSetFocusRect( aImageRect );
2404
2405 if ( mbChecked )
2406 {
2407 SetLineColor( rStyleSettings.GetHighlightColor() );
2408 SetFillColor();
2409 if ( (aImageSize.Width() >= 20) || (aImageSize.Height() >= 20) )
2410 {
2411 aImageRect.Left()++;
2412 aImageRect.Top()++;
2413 aImageRect.Right()--;
2414 aImageRect.Bottom()--;
2415 }
2416 DrawRect( aImageRect );
2417 aImageRect.Left()++;
2418 aImageRect.Top()++;
2419 aImageRect.Right()--;
2420 aImageRect.Bottom()--;
2421 DrawRect( aImageRect );
2422 }
2423
2424 if ( HasFocus() )
2425 ShowFocus( ImplGetFocusRect() );
2426 }
2427 }
2428 }
2429
2430 // -----------------------------------------------------------------------
2431
2432 void RadioButton::ImplDraw( OutputDevice* pDev, ULONG nDrawFlags,
2433 const Point& rPos, const Size& rSize,
2434 const Size& rImageSize, long nImageSep,
2435 Rectangle& rStateRect,
2436 Rectangle& rMouseRect,
2437 bool bLayout )
2438 {
2439 WinBits nWinStyle = GetStyle();
2440 XubString aText( GetText() );
2441 Rectangle aRect( rPos, rSize );
2442 MetricVector* pVector = bLayout ? &mpLayoutData->m_aUnicodeBoundRects : NULL;
2443 String* pDisplayText = bLayout ? &mpLayoutData->m_aDisplayText : NULL;
2444
2445 pDev->Push( PUSH_CLIPREGION );
2446 pDev->IntersectClipRegion( Rectangle( rPos, rSize ) );
2447
2448 // kein Image-RadioButton
2449 if ( !maImage )
2450 {
2451 if ( ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) ||
2452 ( HasImage() && ! (ImplGetButtonState() & BUTTON_DRAW_NOIMAGE) ) )
2453 {
2454 USHORT nTextStyle = Button::ImplGetTextStyle( aText, nWinStyle, nDrawFlags );
2455
2456 Size aSize( rSize );
2457 Point aPos( rPos );
2458
2459 aPos.X() += rImageSize.Width() + nImageSep;
2460 aSize.Width() -= rImageSize.Width() + nImageSep;
2461
2462 // if the text rect height is smaller than the height of the image
2463 // then for single lines the default should be centered text
2464 if( (nWinStyle & (WB_TOP|WB_VCENTER|WB_BOTTOM)) == 0 &&
2465 (rImageSize.Height() > rSize.Height() || ! (nWinStyle & WB_WORDBREAK) ) )
2466 {
2467 nTextStyle &= ~(TEXT_DRAW_TOP|TEXT_DRAW_BOTTOM);
2468 nTextStyle |= TEXT_DRAW_VCENTER;
2469 aSize.Height() = rImageSize.Height();
2470 }
2471
2472 ImplDrawAlignedImage( pDev, aPos, aSize, bLayout, 1,
2473 nDrawFlags, nTextStyle, NULL );
2474
2475 rMouseRect = Rectangle( aPos, aSize );
2476 rMouseRect.Left() = rPos.X();
2477
2478 rStateRect.Left() = rPos.X();
2479 rStateRect.Top() = rMouseRect.Top();
2480
2481 if ( aSize.Height() > rImageSize.Height() )
2482 rStateRect.Top() += ( aSize.Height() - rImageSize.Height() ) / 2;
2483 else
2484 {
2485 rStateRect.Top() -= ( rImageSize.Height() - aSize.Height() ) / 2;
2486 if( rStateRect.Top() < 0 )
2487 rStateRect.Top() = 0;
2488 }
2489
2490 rStateRect.Right() = rStateRect.Left() + rImageSize.Width()-1;
2491 rStateRect.Bottom() = rStateRect.Top() + rImageSize.Height()-1;
2492
2493 if ( rStateRect.Bottom() > rMouseRect.Bottom() )
2494 rMouseRect.Bottom() = rStateRect.Bottom();
2495 }
2496 else
2497 {
2498 if ( nWinStyle & WB_CENTER )
2499 rStateRect.Left() = rPos.X()+((rSize.Width()-rImageSize.Width())/2);
2500 else if ( nWinStyle & WB_RIGHT )
2501 rStateRect.Left() = rPos.X()+rSize.Width()-rImageSize.Width(); //-1;
2502 else
2503 rStateRect.Left() = rPos.X(); //+1;
2504 if ( nWinStyle & WB_VCENTER )
2505 rStateRect.Top() = rPos.Y()+((rSize.Height()-rImageSize.Height())/2);
2506 else if ( nWinStyle & WB_BOTTOM )
2507 rStateRect.Top() = rPos.Y()+rSize.Height()-rImageSize.Height(); //-1;
2508 else
2509 rStateRect.Top() = rPos.Y(); //+1;
2510 rStateRect.Right() = rStateRect.Left()+rImageSize.Width()-1;
2511 rStateRect.Bottom() = rStateRect.Top()+rImageSize.Height()-1;
2512 rMouseRect = rStateRect;
2513
2514 ImplSetFocusRect( rStateRect );
2515
2516 /* und oben -1, da CalcSize() auch Focus-Rechteck nicht mit einrechnet,
2517 da im Writer ansonsten die Images noch weiter oben haengen
2518 rFocusRect = rStateRect;
2519 rFocusRect.Left()--;
2520 rFocusRect.Top()--;
2521 rFocusRect.Right()++;
2522 rFocusRect.Bottom()++;
2523 */
2524 }
2525 }
2526 else
2527 {
2528 BOOL bTopImage = (nWinStyle & WB_TOP) != 0;
2529 Size aImageSize = maImage.GetSizePixel();
2530 Rectangle aImageRect( rPos, rSize );
2531 long nTextHeight = pDev->GetTextHeight();
2532 long nTextWidth = pDev->GetCtrlTextWidth( aText );
2533
2534 // Positionen und Groessen berechnen
2535 if ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) )
2536 {
2537 Size aTmpSize( (aImageSize.Width()+8), (aImageSize.Height()+8) );
2538 if ( bTopImage )
2539 {
2540 aImageRect.Left() = (rSize.Width()-aTmpSize.Width())/2;
2541 aImageRect.Top() = (rSize.Height()-(aTmpSize.Height()+nTextHeight+6))/2;
2542 }
2543 else
2544 aImageRect.Top() = (rSize.Height()-aTmpSize.Height())/2;
2545
2546 aImageRect.Right() = aImageRect.Left()+aTmpSize.Width();
2547 aImageRect.Bottom() = aImageRect.Top()+aTmpSize.Height();
2548
2549 // Text ausgeben
2550 Point aTxtPos = rPos;
2551 if ( bTopImage )
2552 {
2553 aTxtPos.X() += (rSize.Width()-nTextWidth)/2;
2554 aTxtPos.Y() += aImageRect.Bottom()+6;
2555 }
2556 else
2557 {
2558 aTxtPos.X() += aImageRect.Right()+8;
2559 aTxtPos.Y() += (rSize.Height()-nTextHeight)/2;
2560 }
2561 pDev->DrawCtrlText( aTxtPos, aText, 0, STRING_LEN, TEXT_DRAW_MNEMONIC, pVector, pDisplayText );
2562 }
2563
2564 rMouseRect = aImageRect;
2565 rStateRect = aImageRect;
2566 }
2567
2568 pDev->Pop();
2569 }
2570
2571 // -----------------------------------------------------------------------
2572
2573 void RadioButton::ImplDrawRadioButton( bool bLayout )
2574 {
2575 if( !bLayout )
2576 HideFocus();
2577
2578 Size aImageSize;
2579 if ( !maImage )
2580 aImageSize = ImplGetRadioImageSize();
2581 else
2582 aImageSize = maImage.GetSizePixel();
2583 aImageSize.Width() = CalcZoom( aImageSize.Width() );
2584 aImageSize.Height() = CalcZoom( aImageSize.Height() );
2585
2586 // Draw control text
2587 ImplDraw( this, 0, Point(), GetOutputSizePixel(),
2588 aImageSize, IMPL_SEP_BUTTON_IMAGE, maStateRect, maMouseRect, bLayout );
2589
2590 if( !bLayout || (IsNativeControlSupported(CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL)==TRUE) )
2591 {
2592 if ( !maImage && HasFocus() )
2593 ShowFocus( ImplGetFocusRect() );
2594
2595 ImplDrawRadioButtonState();
2596 }
2597 }
2598
2599 // -----------------------------------------------------------------------
2600
2601 void RadioButton::GetRadioButtonGroup( std::vector< RadioButton* >& io_rGroup, bool bIncludeThis ) const
2602 {
2603 // empty the list
2604 io_rGroup.clear();
2605
2606 // go back to first in group;
2607 Window* pFirst = const_cast<RadioButton*>(this);
2608 while( ( pFirst->GetStyle() & WB_GROUP ) == 0 )
2609 {
2610 Window* pWindow = pFirst->GetWindow( WINDOW_PREV );
2611 if( pWindow )
2612 pFirst = pWindow;
2613 else
2614 break;
2615 }
2616 // insert radiobuttons up to next group
2617 do
2618 {
2619 if( pFirst->GetType() == WINDOW_RADIOBUTTON )
2620 {
2621 if( pFirst != this || bIncludeThis )
2622 io_rGroup.push_back( static_cast<RadioButton*>(pFirst) );
2623 }
2624 pFirst = pFirst->GetWindow( WINDOW_NEXT );
2625 } while( pFirst && ( ( pFirst->GetStyle() & WB_GROUP ) == 0 ) );
2626 }
2627
2628 // -----------------------------------------------------------------------
2629
2630 void RadioButton::ImplUncheckAllOther()
2631 {
2632 mpWindowImpl->mnStyle |= WB_TABSTOP;
2633
2634 // Gruppe mit RadioButtons durchgehen und die gecheckten Buttons
2635 Window* pWindow;
2636 WinBits nStyle;
2637 if ( !(GetStyle() & WB_GROUP) )
2638 {
2639 pWindow = GetWindow( WINDOW_PREV );
2640 while ( pWindow )
2641 {
2642 nStyle = pWindow->GetStyle();
2643
2644 if ( pWindow->GetType() == WINDOW_RADIOBUTTON )
2645 {
2646 if ( ((RadioButton*)pWindow)->IsChecked() )
2647 {
2648 ImplDelData aDelData;
2649 pWindow->ImplAddDel( &aDelData );
2650 ((RadioButton*)pWindow)->SetState( FALSE );
2651 if ( aDelData.IsDelete() )
2652 return;
2653 pWindow->ImplRemoveDel( &aDelData );
2654 }
2655 // Um falsch gesetzt WB_TABSTOPS immer zu entfernen, nicht
2656 // innerhalb der if-Abfrage
2657 pWindow->mpWindowImpl->mnStyle &= ~WB_TABSTOP;
2658 }
2659
2660 if ( nStyle & WB_GROUP )
2661 break;
2662
2663 pWindow = pWindow->GetWindow( WINDOW_PREV );
2664 }
2665 }
2666
2667 pWindow = GetWindow( WINDOW_NEXT );
2668 while ( pWindow )
2669 {
2670 nStyle = pWindow->GetStyle();
2671
2672 if ( nStyle & WB_GROUP )
2673 break;
2674
2675 if ( pWindow->GetType() == WINDOW_RADIOBUTTON )
2676 {
2677 if ( ((RadioButton*)pWindow)->IsChecked() )
2678 {
2679 ImplDelData aDelData;
2680 pWindow->ImplAddDel( &aDelData );
2681 ((RadioButton*)pWindow)->SetState( FALSE );
2682 if ( aDelData.IsDelete() )
2683 return;
2684 pWindow->ImplRemoveDel( &aDelData );
2685 }
2686 // Um falsch gesetzt WB_TABSTOPS immer zu entfernen, nicht
2687 // innerhalb der if-Abfrage
2688 pWindow->mpWindowImpl->mnStyle &= ~WB_TABSTOP;
2689 }
2690
2691 pWindow = pWindow->GetWindow( WINDOW_NEXT );
2692 }
2693 }
2694
2695 // -----------------------------------------------------------------------
2696
2697 void RadioButton::ImplCallClick( BOOL bGrabFocus, USHORT nFocusFlags )
2698 {
2699 mbStateChanged = !mbChecked;
2700 mbChecked = TRUE;
2701 mpWindowImpl->mnStyle |= WB_TABSTOP;
2702 ImplInvalidateOrDrawRadioButtonState();
2703 ImplDelData aDelData;
2704 ImplAddDel( &aDelData );
2705 if ( mbRadioCheck )
2706 ImplUncheckAllOther();
2707 if ( aDelData.IsDelete() )
2708 return;
2709 if ( bGrabFocus )
2710 ImplGrabFocus( nFocusFlags );
2711 if ( aDelData.IsDelete() )
2712 return;
2713 if ( mbStateChanged )
2714 Toggle();
2715 if ( aDelData.IsDelete() )
2716 return;
2717 Click();
2718 if ( aDelData.IsDelete() )
2719 return;
2720 ImplRemoveDel( &aDelData );
2721 mbStateChanged = FALSE;
2722 }
2723
2724 // -----------------------------------------------------------------------
2725
2726 RadioButton::RadioButton( Window* pParent, WinBits nStyle ) :
2727 Button( WINDOW_RADIOBUTTON )
2728 {
2729 ImplInitRadioButtonData();
2730 ImplInit( pParent, nStyle );
2731 }
2732
2733 // -----------------------------------------------------------------------
2734
2735 RadioButton::RadioButton( Window* pParent, const ResId& rResId ) :
2736 Button( WINDOW_RADIOBUTTON )
2737 {
2738 ImplInitRadioButtonData();
2739 rResId.SetRT( RSC_RADIOBUTTON );
2740 WinBits nStyle = ImplInitRes( rResId );
2741 ImplInit( pParent, nStyle );
2742 ImplLoadRes( rResId );
2743
2744 if ( !(nStyle & WB_HIDE) )
2745 Show();
2746 }
2747
2748 // -----------------------------------------------------------------------
2749
2750 void RadioButton::ImplLoadRes( const ResId& rResId )
2751 {
2752 Button::ImplLoadRes( rResId );
2753
2754 //anderer Wert als Default ?
2755 USHORT nChecked = ReadShortRes();
2756 if ( nChecked )
2757 SetState( TRUE );
2758 }
2759
2760 // -----------------------------------------------------------------------
2761
2762 RadioButton::~RadioButton()
2763 {
2764 }
2765
2766 // -----------------------------------------------------------------------
2767
2768 void RadioButton::MouseButtonDown( const MouseEvent& rMEvt )
2769 {
2770 if ( rMEvt.IsLeft() && maMouseRect.IsInside( rMEvt.GetPosPixel() ) )
2771 {
2772 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
2773 ImplInvalidateOrDrawRadioButtonState();
2774 StartTracking();
2775 return;
2776 }
2777
2778 Button::MouseButtonDown( rMEvt );
2779 }
2780
2781 // -----------------------------------------------------------------------
2782
2783 void RadioButton::Tracking( const TrackingEvent& rTEvt )
2784 {
2785 if ( rTEvt.IsTrackingEnded() )
2786 {
2787 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
2788 {
2789 if ( !(GetStyle() & WB_NOPOINTERFOCUS) && !rTEvt.IsTrackingCanceled() )
2790 GrabFocus();
2791
2792 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
2793
2794 // Bei Abbruch kein Click-Handler rufen
2795 if ( !rTEvt.IsTrackingCanceled() )
2796 ImplCallClick();
2797 else
2798 ImplInvalidateOrDrawRadioButtonState();
2799 }
2800 }
2801 else
2802 {
2803 if ( maMouseRect.IsInside( rTEvt.GetMouseEvent().GetPosPixel() ) )
2804 {
2805 if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) )
2806 {
2807 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
2808 ImplInvalidateOrDrawRadioButtonState();
2809 }
2810 }
2811 else
2812 {
2813 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
2814 {
2815 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
2816 ImplInvalidateOrDrawRadioButtonState();
2817 }
2818 }
2819 }
2820 }
2821
2822 // -----------------------------------------------------------------------
2823
2824 void RadioButton::KeyInput( const KeyEvent& rKEvt )
2825 {
2826 KeyCode aKeyCode = rKEvt.GetKeyCode();
2827
2828 if ( !aKeyCode.GetModifier() && (aKeyCode.GetCode() == KEY_SPACE) )
2829 {
2830 if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) )
2831 {
2832 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
2833 ImplInvalidateOrDrawRadioButtonState();
2834 }
2835 }
2836 else if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_ESCAPE) )
2837 {
2838 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
2839 ImplInvalidateOrDrawRadioButtonState();
2840 }
2841 else
2842 Button::KeyInput( rKEvt );
2843 }
2844
2845 // -----------------------------------------------------------------------
2846
2847 void RadioButton::KeyUp( const KeyEvent& rKEvt )
2848 {
2849 KeyCode aKeyCode = rKEvt.GetKeyCode();
2850
2851 if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_SPACE) )
2852 {
2853 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
2854 ImplCallClick();
2855 }
2856 else
2857 Button::KeyUp( rKEvt );
2858 }
2859
2860 // -----------------------------------------------------------------------
2861
2862 void RadioButton::FillLayoutData() const
2863 {
2864 mpLayoutData = new vcl::ControlLayoutData();
2865 const_cast<RadioButton*>(this)->ImplDrawRadioButton( true );
2866 }
2867
2868 // -----------------------------------------------------------------------
2869
2870 void RadioButton::Paint( const Rectangle& )
2871 {
2872 ImplDrawRadioButton();
2873 }
2874
2875 // -----------------------------------------------------------------------
2876
2877 void RadioButton::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
2878 ULONG nFlags )
2879 {
2880 if ( !maImage )
2881 {
2882 MapMode aResMapMode( MAP_100TH_MM );
2883 Point aPos = pDev->LogicToPixel( rPos );
2884 Size aSize = pDev->LogicToPixel( rSize );
2885 Size aImageSize = pDev->LogicToPixel( Size( 300, 300 ), aResMapMode );
2886 Size aBrd1Size = pDev->LogicToPixel( Size( 20, 20 ), aResMapMode );
2887 Size aBrd2Size = pDev->LogicToPixel( Size( 60, 60 ), aResMapMode );
2888 Font aFont = GetDrawPixelFont( pDev );
2889 Rectangle aStateRect;
2890 Rectangle aMouseRect;
2891 Rectangle aFocusRect;
2892
2893 aImageSize.Width() = CalcZoom( aImageSize.Width() );
2894 aImageSize.Height() = CalcZoom( aImageSize.Height() );
2895 aBrd1Size.Width() = CalcZoom( aBrd1Size.Width() );
2896 aBrd1Size.Height() = CalcZoom( aBrd1Size.Height() );
2897 aBrd2Size.Width() = CalcZoom( aBrd2Size.Width() );
2898 aBrd2Size.Height() = CalcZoom( aBrd2Size.Height() );
2899
2900 if ( !aBrd1Size.Width() )
2901 aBrd1Size.Width() = 1;
2902 if ( !aBrd1Size.Height() )
2903 aBrd1Size.Height() = 1;
2904 if ( !aBrd2Size.Width() )
2905 aBrd2Size.Width() = 1;
2906 if ( !aBrd2Size.Height() )
2907 aBrd2Size.Height() = 1;
2908
2909 pDev->Push();
2910 pDev->SetMapMode();
2911 pDev->SetFont( aFont );
2912 if ( nFlags & WINDOW_DRAW_MONO )
2913 pDev->SetTextColor( Color( COL_BLACK ) );
2914 else
2915 pDev->SetTextColor( GetTextColor() );
2916 pDev->SetTextFillColor();
2917
2918 ImplDraw( pDev, nFlags, aPos, aSize,
2919 aImageSize, GetDrawPixel( pDev, IMPL_SEP_BUTTON_IMAGE ),
2920 aStateRect, aMouseRect );
2921
2922 Point aCenterPos = aStateRect.Center();
2923 long nRadX = aImageSize.Width()/2;
2924 long nRadY = aImageSize.Height()/2;
2925
2926 pDev->SetLineColor();
2927 pDev->SetFillColor( Color( COL_BLACK ) );
2928 pDev->DrawPolygon( Polygon( aCenterPos, nRadX, nRadY ) );
2929 nRadX -= aBrd1Size.Width();
2930 nRadY -= aBrd1Size.Height();
2931 pDev->SetFillColor( Color( COL_WHITE ) );
2932 pDev->DrawPolygon( Polygon( aCenterPos, nRadX, nRadY ) );
2933 if ( mbChecked )
2934 {
2935 nRadX -= aBrd1Size.Width();
2936 nRadY -= aBrd1Size.Height();
2937 if ( !nRadX )
2938 nRadX = 1;
2939 if ( !nRadY )
2940 nRadY = 1;
2941 pDev->SetFillColor( Color( COL_BLACK ) );
2942 pDev->DrawPolygon( Polygon( aCenterPos, nRadX, nRadY ) );
2943 }
2944
2945 pDev->Pop();
2946 }
2947 else
2948 {
2949 DBG_ERROR( "RadioButton::Draw() - not implemented for RadioButton with Image" );
2950 }
2951 }
2952
2953 // -----------------------------------------------------------------------
2954
2955 void RadioButton::Resize()
2956 {
2957 Control::Resize();
2958 Invalidate();
2959 }
2960
2961 // -----------------------------------------------------------------------
2962
2963 void RadioButton::GetFocus()
2964 {
2965 ShowFocus( ImplGetFocusRect() );
2966 SetInputContext( InputContext( GetFont() ) );
2967 Button::GetFocus();
2968 }
2969
2970 // -----------------------------------------------------------------------
2971
2972 void RadioButton::LoseFocus()
2973 {
2974 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
2975 {
2976 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
2977 ImplInvalidateOrDrawRadioButtonState();
2978 }
2979
2980 HideFocus();
2981 Button::LoseFocus();
2982 }
2983
2984 // -----------------------------------------------------------------------
2985
2986 void RadioButton::StateChanged( StateChangedType nType )
2987 {
2988 Button::StateChanged( nType );
2989
2990 if ( nType == STATE_CHANGE_STATE )
2991 {
2992 if ( IsReallyVisible() && IsUpdateMode() )
2993 Invalidate( maStateRect );
2994 }
2995 else if ( (nType == STATE_CHANGE_ENABLE) ||
2996 (nType == STATE_CHANGE_TEXT) ||
2997 (nType == STATE_CHANGE_IMAGE) ||
2998 (nType == STATE_CHANGE_DATA) ||
2999 (nType == STATE_CHANGE_UPDATEMODE) )
3000 {
3001 if ( IsUpdateMode() )
3002 Invalidate();
3003 }
3004 else if ( nType == STATE_CHANGE_STYLE )
3005 {
3006 SetStyle( ImplInitStyle( GetWindow( WINDOW_PREV ), GetStyle() ) );
3007
3008 if ( (GetPrevStyle() & RADIOBUTTON_VIEW_STYLE) !=
3009 (GetStyle() & RADIOBUTTON_VIEW_STYLE) )
3010 {
3011 if ( IsUpdateMode() )
3012 Invalidate();
3013 }
3014 }
3015 else if ( (nType == STATE_CHANGE_ZOOM) ||
3016 (nType == STATE_CHANGE_CONTROLFONT) )
3017 {
3018 ImplInitSettings( TRUE, FALSE, FALSE );
3019 Invalidate();
3020 }
3021 else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
3022 {
3023 ImplInitSettings( FALSE, TRUE, FALSE );
3024 Invalidate();
3025 }
3026 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
3027 {
3028 ImplInitSettings( FALSE, FALSE, TRUE );
3029 Invalidate();
3030 }
3031 }
3032
3033 // -----------------------------------------------------------------------
3034
3035 void RadioButton::DataChanged( const DataChangedEvent& rDCEvt )
3036 {
3037 Button::DataChanged( rDCEvt );
3038
3039 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
3040 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
3041 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
3042 (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
3043 {
3044 ImplInitSettings( TRUE, TRUE, TRUE );
3045 Invalidate();
3046 }
3047 }
3048
3049 // -----------------------------------------------------------------------
3050
3051 long RadioButton::PreNotify( NotifyEvent& rNEvt )
3052 {
3053 long nDone = 0;
3054 const MouseEvent* pMouseEvt = NULL;
3055
3056 if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL )
3057 {
3058 if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() )
3059 {
3060 // trigger redraw if mouse over state has changed
3061 if( IsNativeControlSupported(CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL) )
3062 {
3063 if( ( maMouseRect.IsInside( GetPointerPosPixel()) &&
3064 !maMouseRect.IsInside( GetLastPointerPosPixel()) ) ||
3065 ( maMouseRect.IsInside( GetLastPointerPosPixel()) &&
3066 !maMouseRect.IsInside( GetPointerPosPixel()) ) ||
3067 pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow() )
3068 {
3069 Invalidate( maStateRect );
3070 }
3071 }
3072 }
3073 }
3074
3075 return nDone ? nDone : Button::PreNotify(rNEvt);
3076 }
3077
3078 // -----------------------------------------------------------------------
3079
3080 void RadioButton::Toggle()
3081 {
3082 ImplCallEventListenersAndHandler( VCLEVENT_RADIOBUTTON_TOGGLE, maToggleHdl, this );
3083 }
3084
3085 // -----------------------------------------------------------------------
3086
3087 BOOL RadioButton::SetModeRadioImage( const Image& rImage, BmpColorMode eMode )
3088 {
3089 if( eMode == BMP_COLOR_NORMAL )
3090 {
3091 if ( rImage != maImage )
3092 {
3093 maImage = rImage;
3094 StateChanged( STATE_CHANGE_DATA );
3095 }
3096 }
3097 else if( eMode == BMP_COLOR_HIGHCONTRAST )
3098 {
3099 if( maImageHC != rImage )
3100 {
3101 maImageHC = rImage;
3102 StateChanged( STATE_CHANGE_DATA );
3103 }
3104 }
3105 else
3106 return FALSE;
3107
3108 return TRUE;
3109 }
3110
3111 // -----------------------------------------------------------------------
3112
3113 const Image& RadioButton::GetModeRadioImage( BmpColorMode eMode ) const
3114 {
3115 if( eMode == BMP_COLOR_HIGHCONTRAST )
3116 return maImageHC;
3117 else
3118 return maImage;
3119 }
3120
3121 // -----------------------------------------------------------------------
3122
3123 void RadioButton::SetState( BOOL bCheck )
3124 {
3125 // TabStop-Flag richtig mitfuehren
3126 if ( bCheck )
3127 mpWindowImpl->mnStyle |= WB_TABSTOP;
3128 else
3129 mpWindowImpl->mnStyle &= ~WB_TABSTOP;
3130
3131 if ( mbChecked != bCheck )
3132 {
3133 mbChecked = bCheck;
3134 StateChanged( STATE_CHANGE_STATE );
3135 Toggle();
3136 }
3137 }
3138
3139 // -----------------------------------------------------------------------
3140
3141 void RadioButton::Check( BOOL bCheck )
3142 {
3143 // TabStop-Flag richtig mitfuehren
3144 if ( bCheck )
3145 mpWindowImpl->mnStyle |= WB_TABSTOP;
3146 else
3147 mpWindowImpl->mnStyle &= ~WB_TABSTOP;
3148
3149 if ( mbChecked != bCheck )
3150 {
3151 mbChecked = bCheck;
3152 ImplDelData aDelData;
3153 ImplAddDel( &aDelData );
3154 StateChanged( STATE_CHANGE_STATE );
3155 if ( aDelData.IsDelete() )
3156 return;
3157 if ( bCheck && mbRadioCheck )
3158 ImplUncheckAllOther();
3159 if ( aDelData.IsDelete() )
3160 return;
3161 Toggle();
3162 ImplRemoveDel( &aDelData );
3163 }
3164 }
3165
3166 // -----------------------------------------------------------------------
3167
3168 Size RadioButton::ImplGetRadioImageSize() const
3169 {
3170 Size aSize;
3171 // why are IsNativeControlSupported and GetNativeControlRegion not const ?
3172 RadioButton* pThis = const_cast<RadioButton*>(this);
3173 bool bDefaultSize = true;
3174 if( pThis->IsNativeControlSupported( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL ) )
3175 {
3176 ImplControlValue aControlValue;
3177 // #i45896# workaround gcc3.3 temporary problem
3178 Region aCtrlRegion = Region( Rectangle( Point( 0, 0 ), GetSizePixel() ) );
3179 ControlState nState = CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED;
3180 Region aBoundingRgn, aContentRgn;
3181
3182 // get native size of a radio button
3183 if( pThis->GetNativeControlRegion( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion,
3184 nState, aControlValue, rtl::OUString(),
3185 aBoundingRgn, aContentRgn ) )
3186 {
3187 Rectangle aCont(aContentRgn.GetBoundRect());
3188 aSize = aCont.GetSize();
3189 bDefaultSize = false;
3190 }
3191 }
3192 if( bDefaultSize )
3193 aSize = GetRadioImage( GetSettings(), 0 ).GetSizePixel();
3194 return aSize;
3195 }
3196
3197 static void LoadThemedImageList (const StyleSettings &rStyleSettings,
3198 ImageList *pList, const ResId &rResId,
3199 USHORT nImages)
3200 {
3201 Color aColorAry1[6];
3202 Color aColorAry2[6];
3203 aColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 );
3204 aColorAry1[1] = Color( 0xFF, 0xFF, 0x00 );
3205 aColorAry1[2] = Color( 0xFF, 0xFF, 0xFF );
3206 aColorAry1[3] = Color( 0x80, 0x80, 0x80 );
3207 aColorAry1[4] = Color( 0x00, 0x00, 0x00 );
3208 aColorAry1[5] = Color( 0x00, 0xFF, 0x00 );
3209 aColorAry2[0] = rStyleSettings.GetFaceColor();
3210 aColorAry2[1] = rStyleSettings.GetWindowColor();
3211 aColorAry2[2] = rStyleSettings.GetLightColor();
3212 aColorAry2[3] = rStyleSettings.GetShadowColor();
3213 aColorAry2[4] = rStyleSettings.GetDarkShadowColor();
3214 aColorAry2[5] = rStyleSettings.GetWindowTextColor();
3215
3216 Color aMaskColor(0x00, 0x00, 0xFF );
3217 DBG_ASSERT( sizeof(aColorAry1) == sizeof(aColorAry2), "aColorAry1 must match aColorAry2" );
3218 // FIXME: do we want the mask for the checkbox ?
3219 pList->InsertFromHorizontalBitmap (rResId, nImages, &aMaskColor,
3220 aColorAry1, aColorAry2, sizeof(aColorAry1) / sizeof(Color));
3221 }
3222
3223 Image RadioButton::GetRadioImage( const AllSettings& rSettings, USHORT nFlags )
3224 {
3225 ImplSVData* pSVData = ImplGetSVData();
3226 const StyleSettings& rStyleSettings = rSettings.GetStyleSettings();
3227 USHORT nStyle = rStyleSettings.GetRadioButtonStyle() & STYLE_RADIOBUTTON_STYLE;
3228
3229 if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO )
3230 nStyle = STYLE_RADIOBUTTON_MONO;
3231
3232 if ( !pSVData->maCtrlData.mpRadioImgList ||
3233 (pSVData->maCtrlData.mnRadioStyle != nStyle) ||
3234 (pSVData->maCtrlData.mnLastRadioFColor != rStyleSettings.GetFaceColor().GetColor()) ||
3235 (pSVData->maCtrlData.mnLastRadioWColor != rStyleSettings.GetWindowColor().GetColor()) ||
3236 (pSVData->maCtrlData.mnLastRadioLColor != rStyleSettings.GetLightColor().GetColor()) )
3237 {
3238 if ( pSVData->maCtrlData.mpRadioImgList )
3239 delete pSVData->maCtrlData.mpRadioImgList;
3240
3241 pSVData->maCtrlData.mnLastRadioFColor = rStyleSettings.GetFaceColor().GetColor();
3242 pSVData->maCtrlData.mnLastRadioWColor = rStyleSettings.GetWindowColor().GetColor();
3243 pSVData->maCtrlData.mnLastRadioLColor = rStyleSettings.GetLightColor().GetColor();
3244
3245 Color pColorAry1[6];
3246 Color pColorAry2[6];
3247 pColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 );
3248 pColorAry1[1] = Color( 0xFF, 0xFF, 0x00 );
3249 pColorAry1[2] = Color( 0xFF, 0xFF, 0xFF );
3250 pColorAry1[3] = Color( 0x80, 0x80, 0x80 );
3251 pColorAry1[4] = Color( 0x00, 0x00, 0x00 );
3252 pColorAry1[5] = Color( 0x00, 0xFF, 0x00 );
3253 pColorAry2[0] = rStyleSettings.GetFaceColor();
3254 pColorAry2[1] = rStyleSettings.GetWindowColor();
3255 pColorAry2[2] = rStyleSettings.GetLightColor();
3256 pColorAry2[3] = rStyleSettings.GetShadowColor();
3257 pColorAry2[4] = rStyleSettings.GetDarkShadowColor();
3258 pColorAry2[5] = rStyleSettings.GetWindowTextColor();
3259
3260 ResMgr* pResMgr = ImplGetResMgr();
3261 pSVData->maCtrlData.mpRadioImgList = new ImageList();
3262 if( pResMgr )
3263 LoadThemedImageList( rStyleSettings,
3264 pSVData->maCtrlData.mpRadioImgList,
3265 ResId( SV_RESID_BITMAP_RADIO+nStyle, *pResMgr ), 6 );
3266 pSVData->maCtrlData.mnRadioStyle = nStyle;
3267 }
3268
3269 USHORT nId;
3270 if ( nFlags & BUTTON_DRAW_DISABLED )
3271 {
3272 if ( nFlags & BUTTON_DRAW_CHECKED )
3273 nId = 6;
3274 else
3275 nId = 5;
3276 }
3277 else if ( nFlags & BUTTON_DRAW_PRESSED )
3278 {
3279 if ( nFlags & BUTTON_DRAW_CHECKED )
3280 nId = 4;
3281 else
3282 nId = 3;
3283 }
3284 else
3285 {
3286 if ( nFlags & BUTTON_DRAW_CHECKED )
3287 nId = 2;
3288 else
3289 nId = 1;
3290 }
3291 return pSVData->maCtrlData.mpRadioImgList->GetImage( nId );
3292 }
3293
3294 // -----------------------------------------------------------------------
3295
3296 void RadioButton::ImplSetMinimumNWFSize()
3297 {
3298 Push( PUSH_MAPMODE );
3299 SetMapMode( MAP_PIXEL );
3300
3301 ImplControlValue aControlValue;
3302 Size aCurSize( GetSizePixel() );
3303 Region aCtrlRegion = Region( Rectangle( Point( 0, 0 ), aCurSize ) );
3304 Region aBoundingRgn, aContentRgn;
3305
3306 // get native size of a radiobutton
3307 if( GetNativeControlRegion( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion,
3308 CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED, aControlValue, rtl::OUString(),
3309 aBoundingRgn, aContentRgn ) )
3310 {
3311 Rectangle aCont(aContentRgn.GetBoundRect());
3312 Size aSize = aCont.GetSize();
3313
3314 if( aSize.Height() > aCurSize.Height() )
3315 {
3316 aCurSize.Height() = aSize.Height();
3317 SetSizePixel( aCurSize );
3318 }
3319 }
3320
3321 Pop();
3322 }
3323
3324 // -----------------------------------------------------------------------
3325
3326 Size RadioButton::CalcMinimumSize( long nMaxWidth ) const
3327 {
3328 Size aSize;
3329 if ( !maImage )
3330 aSize = ImplGetRadioImageSize();
3331 else
3332 aSize = maImage.GetSizePixel();
3333
3334 nMaxWidth -= aSize.Width();
3335
3336 XubString aText = GetText();
3337 if ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) )
3338 {
3339 // subtract what will be added later
3340 nMaxWidth-=2;
3341 nMaxWidth -= IMPL_SEP_BUTTON_IMAGE;
3342
3343 Size aTextSize = GetTextRect( Rectangle( Point(), Size( nMaxWidth > 0 ? nMaxWidth : 0x7fffffff, 0x7fffffff ) ),
3344 aText, FixedText::ImplGetTextStyle( GetStyle() ) ).GetSize();
3345 aSize.Width()+=2; // for focus rect
3346 aSize.Width() += IMPL_SEP_BUTTON_IMAGE;
3347 aSize.Width() += aTextSize.Width();
3348 if ( aSize.Height() < aTextSize.Height() )
3349 aSize.Height() = aTextSize.Height();
3350 }
3351 else if ( !maImage )
3352 {
3353 /* da ansonsten im Writer die Control zu weit oben haengen
3354 aSize.Width() += 2;
3355 aSize.Height() += 2;
3356 */
3357 }
3358
3359 return CalcWindowSize( aSize );
3360 }
3361
3362 // -----------------------------------------------------------------------
3363
3364 Size RadioButton::GetOptimalSize(WindowSizeType eType) const
3365 {
3366 switch (eType) {
3367 case WINDOWSIZE_MINIMUM:
3368 return CalcMinimumSize();
3369 default:
3370 return Button::GetOptimalSize( eType );
3371 }
3372 }
3373
3374 // =======================================================================
3375
3376 void CheckBox::ImplInitCheckBoxData()
3377 {
3378 meState = STATE_NOCHECK;
3379 meSaveValue = STATE_NOCHECK;
3380 mbTriState = FALSE;
3381 }
3382
3383 // -----------------------------------------------------------------------
3384
3385 void CheckBox::ImplInit( Window* pParent, WinBits nStyle )
3386 {
3387 nStyle = ImplInitStyle( pParent->GetWindow( WINDOW_LASTCHILD ), nStyle );
3388 Button::ImplInit( pParent, nStyle, NULL );
3389
3390 ImplInitSettings( TRUE, TRUE, TRUE );
3391 }
3392
3393 // -----------------------------------------------------------------------
3394
3395 WinBits CheckBox::ImplInitStyle( const Window* pPrevWindow, WinBits nStyle )
3396 {
3397 if ( !(nStyle & WB_NOTABSTOP) )
3398 nStyle |= WB_TABSTOP;
3399 if ( !(nStyle & WB_NOGROUP) &&
3400 (!pPrevWindow || (pPrevWindow->GetType() != WINDOW_CHECKBOX)) )
3401 nStyle |= WB_GROUP;
3402 return nStyle;
3403 }
3404
3405 // -----------------------------------------------------------------------
3406
3407 void CheckBox::ImplInitSettings( BOOL bFont,
3408 BOOL bForeground, BOOL bBackground )
3409 {
3410 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
3411
3412 if ( bFont )
3413 {
3414 Font aFont = rStyleSettings.GetRadioCheckFont();
3415 if ( IsControlFont() )
3416 aFont.Merge( GetControlFont() );
3417 SetZoomedPointFont( aFont );
3418 }
3419
3420 if ( bForeground || bFont )
3421 {
3422 Color aColor;
3423 if ( IsControlForeground() )
3424 aColor = GetControlForeground();
3425 else
3426 aColor = rStyleSettings.GetRadioCheckTextColor();
3427 SetTextColor( aColor );
3428 SetTextFillColor();
3429 }
3430
3431 if ( bBackground )
3432 {
3433 Window* pParent = GetParent();
3434 if ( !IsControlBackground() &&
3435 (pParent->IsChildTransparentModeEnabled() || IsNativeControlSupported( CTRL_CHECKBOX, PART_ENTIRE_CONTROL ) ) )
3436 {
3437 EnableChildTransparentMode( TRUE );
3438 SetParentClipMode( PARENTCLIPMODE_NOCLIP );
3439 SetPaintTransparent( TRUE );
3440 SetBackground();
3441 if( IsNativeControlSupported( CTRL_CHECKBOX, PART_ENTIRE_CONTROL ) )
3442 ImplGetWindowImpl()->mbUseNativeFocus = ImplGetSVData()->maNWFData.mbNoFocusRects;
3443 }
3444 else
3445 {
3446 EnableChildTransparentMode( FALSE );
3447 SetParentClipMode( 0 );
3448 SetPaintTransparent( FALSE );
3449
3450 if ( IsControlBackground() )
3451 SetBackground( GetControlBackground() );
3452 else
3453 SetBackground( pParent->GetBackground() );
3454 }
3455 }
3456 }
3457
3458 // -----------------------------------------------------------------------
3459
3460 void CheckBox::ImplLoadRes( const ResId& rResId )
3461 {
3462 Button::ImplLoadRes( rResId );
3463
3464 if ( rResId.GetRT() != RSC_TRISTATEBOX )
3465 {
3466 USHORT nChecked = ReadShortRes();
3467 //anderer Wert als Default ?
3468 if( nChecked )
3469 Check( TRUE );
3470 }
3471 }
3472
3473 // -----------------------------------------------------------------------
3474
3475 void CheckBox::ImplInvalidateOrDrawCheckBoxState()
3476 {
3477 if( ImplGetSVData()->maNWFData.mbCheckBoxNeedsErase )
3478 {
3479 if ( IsNativeControlSupported(CTRL_CHECKBOX, PART_ENTIRE_CONTROL) )
3480 {
3481 Invalidate();
3482 Update();
3483 return;
3484 }
3485 }
3486 ImplDrawCheckBoxState();
3487 }
3488
3489 void CheckBox::ImplDrawCheckBoxState()
3490 {
3491 bool bNativeOK = TRUE;
3492
3493 if ( (bNativeOK=IsNativeControlSupported(CTRL_CHECKBOX, PART_ENTIRE_CONTROL)) == TRUE )
3494 {
3495 ImplControlValue aControlValue( meState == STATE_CHECK ? BUTTONVALUE_ON : BUTTONVALUE_OFF, rtl::OUString(), 0 );
3496 Region aCtrlRegion( maStateRect );
3497 ControlState nState = 0;
3498
3499 if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED;
3500 if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT;
3501 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) nState |= CTRL_STATE_PRESSED;
3502 if ( IsEnabled() ) nState |= CTRL_STATE_ENABLED;
3503
3504 if ( meState == STATE_CHECK )
3505 aControlValue.setTristateVal( BUTTONVALUE_ON );
3506 else if ( meState == STATE_DONTKNOW )
3507 aControlValue.setTristateVal( BUTTONVALUE_MIXED );
3508
3509 if ( IsMouseOver() && maMouseRect.IsInside( GetPointerPosPixel() ) )
3510 nState |= CTRL_STATE_ROLLOVER;
3511
3512 bNativeOK = DrawNativeControl( CTRL_CHECKBOX, PART_ENTIRE_CONTROL, aCtrlRegion, nState,
3513 aControlValue, rtl::OUString() );
3514 }
3515
3516 if ( bNativeOK == FALSE )
3517 {
3518 USHORT nStyle = ImplGetButtonState();
3519 if ( !IsEnabled() )
3520 nStyle |= BUTTON_DRAW_DISABLED;
3521 if ( meState == STATE_DONTKNOW )
3522 nStyle |= BUTTON_DRAW_DONTKNOW;
3523 else if ( meState == STATE_CHECK )
3524 nStyle |= BUTTON_DRAW_CHECKED;
3525 Image aImage = GetCheckImage( GetSettings(), nStyle );
3526 if ( IsZoom() )
3527 DrawImage( maStateRect.TopLeft(), maStateRect.GetSize(), aImage );
3528 else
3529 DrawImage( maStateRect.TopLeft(), aImage );
3530 }
3531 }
3532
3533 // -----------------------------------------------------------------------
3534
3535 void CheckBox::ImplDraw( OutputDevice* pDev, ULONG nDrawFlags,
3536 const Point& rPos, const Size& rSize,
3537 const Size& rImageSize, long nImageSep,
3538 Rectangle& rStateRect, Rectangle& rMouseRect,
3539 bool bLayout )
3540 {
3541 WinBits nWinStyle = GetStyle();
3542 XubString aText( GetText() );
3543
3544 pDev->Push( PUSH_CLIPREGION | PUSH_LINECOLOR );
3545 pDev->IntersectClipRegion( Rectangle( rPos, rSize ) );
3546
3547 long nLineY = rPos.Y() + (rSize.Height()-1)/2;
3548 if ( ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) ||
3549 ( HasImage() && ! (ImplGetButtonState() & BUTTON_DRAW_NOIMAGE) ) )
3550 {
3551 USHORT nTextStyle = Button::ImplGetTextStyle( aText, nWinStyle, nDrawFlags );
3552
3553 Size aSize( rSize );
3554 Point aPos( rPos );
3555 aPos.X() += rImageSize.Width() + nImageSep;
3556 aSize.Width() -= rImageSize.Width() + nImageSep;
3557
3558 // if the text rect height is smaller than the height of the image
3559 // then for single lines the default should be centered text
3560 if( (nWinStyle & (WB_TOP|WB_VCENTER|WB_BOTTOM)) == 0 &&
3561 (rImageSize.Height() > rSize.Height() || ! (nWinStyle & WB_WORDBREAK) ) )
3562 {
3563 nTextStyle &= ~(TEXT_DRAW_TOP|TEXT_DRAW_BOTTOM);
3564 nTextStyle |= TEXT_DRAW_VCENTER;
3565 aSize.Height() = rImageSize.Height();
3566 }
3567
3568 ImplDrawAlignedImage( pDev, aPos, aSize, bLayout, 1,
3569 nDrawFlags, nTextStyle, NULL );
3570 nLineY = aPos.Y() + aSize.Height()/2;
3571
3572 rMouseRect = Rectangle( aPos, aSize );
3573 rMouseRect.Left() = rPos.X();
3574 rStateRect.Left() = rPos.X();
3575 rStateRect.Top() = rMouseRect.Top();
3576
3577 if ( aSize.Height() > rImageSize.Height() )
3578 rStateRect.Top() += ( aSize.Height() - rImageSize.Height() ) / 2;
3579 else
3580 {
3581 rStateRect.Top() -= ( rImageSize.Height() - aSize.Height() ) / 2;
3582 if( rStateRect.Top() < 0 )
3583 rStateRect.Top() = 0;
3584 }
3585
3586 rStateRect.Right() = rStateRect.Left()+rImageSize.Width()-1;
3587 rStateRect.Bottom() = rStateRect.Top()+rImageSize.Height()-1;
3588 if ( rStateRect.Bottom() > rMouseRect.Bottom() )
3589 rMouseRect.Bottom() = rStateRect.Bottom();
3590 }
3591 else
3592 {
3593 if ( nWinStyle & WB_CENTER )
3594 rStateRect.Left() = rPos.X()+((rSize.Width()-rImageSize.Width())/2);
3595 else if ( nWinStyle & WB_RIGHT )
3596 rStateRect.Left() = rPos.X()+rSize.Width()-rImageSize.Width();
3597 else
3598 rStateRect.Left() = rPos.X();
3599 if ( nWinStyle & WB_VCENTER )
3600 rStateRect.Top() = rPos.Y()+((rSize.Height()-rImageSize.Height())/2);
3601 else if ( nWinStyle & WB_BOTTOM )
3602 rStateRect.Top() = rPos.Y()+rSize.Height()-rImageSize.Height();
3603 else
3604 rStateRect.Top() = rPos.Y();
3605 rStateRect.Right() = rStateRect.Left()+rImageSize.Width()-1;
3606 rStateRect.Bottom() = rStateRect.Top()+rImageSize.Height()-1;
3607 // provide space for focusrect
3608 // note: this assumes that the control's size was adjusted
3609 // accordingly in Get/LoseFocus, so the onscreen position won't change
3610 if( HasFocus() )
3611 rStateRect.Move( 1, 1 );
3612 rMouseRect = rStateRect;
3613
3614 ImplSetFocusRect( rStateRect );
3615 }
3616
3617 const int nLineSpace = 4;
3618 if( (GetStyle() & WB_CBLINESTYLE) != 0 &&
3619 rMouseRect.Right()-1-nLineSpace < rPos.X()+rSize.Width() )
3620 {
3621 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
3622 if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO )
3623 SetLineColor( Color( COL_BLACK ) );
3624 else
3625 SetLineColor( rStyleSettings.GetShadowColor() );
3626 long nLineX = rMouseRect.Right()+nLineSpace;
3627 DrawLine( Point( nLineX, nLineY ), Point( rPos.X() + rSize.Width()-1, nLineY ) );
3628 if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
3629 {
3630 SetLineColor( rStyleSettings.GetLightColor() );
3631 DrawLine( Point( nLineX, nLineY+1 ), Point( rPos.X() + rSize.Width()-1, nLineY+1 ) );
3632 }
3633 }
3634
3635 pDev->Pop();
3636 }
3637
3638 // -----------------------------------------------------------------------
3639
3640 void CheckBox::ImplDrawCheckBox( bool bLayout )
3641 {
3642 Size aImageSize = ImplGetCheckImageSize();
3643 aImageSize.Width() = CalcZoom( aImageSize.Width() );
3644 aImageSize.Height() = CalcZoom( aImageSize.Height() );
3645
3646 if( !bLayout )
3647 HideFocus();
3648
3649 ImplDraw( this, 0, Point(), GetOutputSizePixel(), aImageSize,
3650 IMPL_SEP_BUTTON_IMAGE, maStateRect, maMouseRect, bLayout );
3651
3652 if( !bLayout )
3653 {
3654 ImplDrawCheckBoxState();
3655 if ( HasFocus() )
3656 ShowFocus( ImplGetFocusRect() );
3657 }
3658 }
3659
3660 // -----------------------------------------------------------------------
3661
3662 void CheckBox::ImplCheck()
3663 {
3664 TriState eNewState;
3665 if ( meState == STATE_NOCHECK )
3666 eNewState = STATE_CHECK;
3667 else if ( !mbTriState )
3668 eNewState = STATE_NOCHECK;
3669 else if ( meState == STATE_CHECK )
3670 eNewState = STATE_DONTKNOW;
3671 else
3672 eNewState = STATE_NOCHECK;
3673 meState = eNewState;
3674 ImplInvalidateOrDrawCheckBoxState();
3675
3676 ImplDelData aDelData;
3677 ImplAddDel( &aDelData );
3678 Toggle();
3679 if ( aDelData.IsDelete() )
3680 return;
3681 ImplRemoveDel( &aDelData );
3682 Click();
3683 }
3684
3685 // -----------------------------------------------------------------------
3686
3687 CheckBox::CheckBox( Window* pParent, WinBits nStyle ) :
3688 Button( WINDOW_CHECKBOX )
3689 {
3690 ImplInitCheckBoxData();
3691 ImplInit( pParent, nStyle );
3692 }
3693
3694 // -----------------------------------------------------------------------
3695
3696 CheckBox::CheckBox( Window* pParent, const ResId& rResId ) :
3697 Button( WINDOW_CHECKBOX )
3698 {
3699 ImplInitCheckBoxData();
3700 rResId.SetRT( RSC_CHECKBOX );
3701 WinBits nStyle = ImplInitRes( rResId );
3702 ImplInit( pParent, nStyle );
3703 ImplLoadRes( rResId );
3704
3705 if ( !(nStyle & WB_HIDE) )
3706 Show();
3707 }
3708
3709 // -----------------------------------------------------------------------
3710
3711 void CheckBox::MouseButtonDown( const MouseEvent& rMEvt )
3712 {
3713 if ( rMEvt.IsLeft() && maMouseRect.IsInside( rMEvt.GetPosPixel() ) )
3714 {
3715 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
3716 ImplInvalidateOrDrawCheckBoxState();
3717 StartTracking();
3718 return;
3719 }
3720
3721 Button::MouseButtonDown( rMEvt );
3722 }
3723
3724 // -----------------------------------------------------------------------
3725
3726 void CheckBox::Tracking( const TrackingEvent& rTEvt )
3727 {
3728 if ( rTEvt.IsTrackingEnded() )
3729 {
3730 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
3731 {
3732 if ( !(GetStyle() & WB_NOPOINTERFOCUS) && !rTEvt.IsTrackingCanceled() )
3733 GrabFocus();
3734
3735 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
3736
3737 // Bei Abbruch kein Click-Handler rufen
3738 if ( !rTEvt.IsTrackingCanceled() )
3739 ImplCheck();
3740 else
3741 ImplInvalidateOrDrawCheckBoxState();
3742 }
3743 }
3744 else
3745 {
3746 if ( maMouseRect.IsInside( rTEvt.GetMouseEvent().GetPosPixel() ) )
3747 {
3748 if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) )
3749 {
3750 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
3751 ImplInvalidateOrDrawCheckBoxState();
3752 }
3753 }
3754 else
3755 {
3756 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
3757 {
3758 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
3759 ImplInvalidateOrDrawCheckBoxState();
3760 }
3761 }
3762 }
3763 }
3764
3765 // -----------------------------------------------------------------------
3766
3767 void CheckBox::KeyInput( const KeyEvent& rKEvt )
3768 {
3769 KeyCode aKeyCode = rKEvt.GetKeyCode();
3770
3771 if ( !aKeyCode.GetModifier() && (aKeyCode.GetCode() == KEY_SPACE) )
3772 {
3773 if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) )
3774 {
3775 ImplGetButtonState() |= BUTTON_DRAW_PRESSED;
3776 ImplInvalidateOrDrawCheckBoxState();
3777 }
3778 }
3779 else if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_ESCAPE) )
3780 {
3781 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
3782 ImplInvalidateOrDrawCheckBoxState();
3783 }
3784 else
3785 Button::KeyInput( rKEvt );
3786 }
3787
3788 // -----------------------------------------------------------------------
3789
3790 void CheckBox::KeyUp( const KeyEvent& rKEvt )
3791 {
3792 KeyCode aKeyCode = rKEvt.GetKeyCode();
3793
3794 if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_SPACE) )
3795 {
3796 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
3797 ImplCheck();
3798 }
3799 else
3800 Button::KeyUp( rKEvt );
3801 }
3802
3803 // -----------------------------------------------------------------------
3804
3805 void CheckBox::FillLayoutData() const
3806 {
3807 mpLayoutData = new vcl::ControlLayoutData();
3808 const_cast<CheckBox*>(this)->ImplDrawCheckBox( true );
3809 }
3810
3811 // -----------------------------------------------------------------------
3812
3813 void CheckBox::Paint( const Rectangle& )
3814 {
3815 ImplDrawCheckBox();
3816 }
3817
3818 // -----------------------------------------------------------------------
3819
3820 void CheckBox::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
3821 ULONG nFlags )
3822 {
3823 MapMode aResMapMode( MAP_100TH_MM );
3824 Point aPos = pDev->LogicToPixel( rPos );
3825 Size aSize = pDev->LogicToPixel( rSize );
3826 Size aImageSize = pDev->LogicToPixel( Size( 300, 300 ), aResMapMode );
3827 Size aBrd1Size = pDev->LogicToPixel( Size( 20, 20 ), aResMapMode );
3828 Size aBrd2Size = pDev->LogicToPixel( Size( 30, 30 ), aResMapMode );
3829 long nCheckWidth = pDev->LogicToPixel( Size( 20, 20 ), aResMapMode ).Width();
3830 Font aFont = GetDrawPixelFont( pDev );
3831 Rectangle aStateRect;
3832 Rectangle aMouseRect;
3833
3834 aImageSize.Width() = CalcZoom( aImageSize.Width() );
3835 aImageSize.Height() = CalcZoom( aImageSize.Height() );
3836 aBrd1Size.Width() = CalcZoom( aBrd1Size.Width() );
3837 aBrd1Size.Height() = CalcZoom( aBrd1Size.Height() );
3838 aBrd2Size.Width() = CalcZoom( aBrd2Size.Width() );
3839 aBrd2Size.Height() = CalcZoom( aBrd2Size.Height() );
3840
3841 if ( !aBrd1Size.Width() )
3842 aBrd1Size.Width() = 1;
3843 if ( !aBrd1Size.Height() )
3844 aBrd1Size.Height() = 1;
3845 if ( !aBrd2Size.Width() )
3846 aBrd2Size.Width() = 1;
3847 if ( !aBrd2Size.Height() )
3848 aBrd2Size.Height() = 1;
3849 if ( !nCheckWidth )
3850 nCheckWidth = 1;
3851
3852 pDev->Push();
3853 pDev->SetMapMode();
3854 pDev->SetFont( aFont );
3855 if ( nFlags & WINDOW_DRAW_MONO )
3856 pDev->SetTextColor( Color( COL_BLACK ) );
3857 else
3858 pDev->SetTextColor( GetTextColor() );
3859 pDev->SetTextFillColor();
3860
3861 ImplDraw( pDev, nFlags, aPos, aSize,
3862 aImageSize, GetDrawPixel( pDev, IMPL_SEP_BUTTON_IMAGE ),
3863 aStateRect, aMouseRect, false );
3864
3865 pDev->SetLineColor();
3866 pDev->SetFillColor( Color( COL_BLACK ) );
3867 pDev->DrawRect( aStateRect );
3868 aStateRect.Left() += aBrd1Size.Width();
3869 aStateRect.Top() += aBrd1Size.Height();
3870 aStateRect.Right() -= aBrd1Size.Width();
3871 aStateRect.Bottom() -= aBrd1Size.Height();
3872 if ( meState == STATE_DONTKNOW )
3873 pDev->SetFillColor( Color( COL_LIGHTGRAY ) );
3874 else
3875 pDev->SetFillColor( Color( COL_WHITE ) );
3876 pDev->DrawRect( aStateRect );
3877
3878 if ( meState == STATE_CHECK )
3879 {
3880 aStateRect.Left() += aBrd2Size.Width();
3881 aStateRect.Top() += aBrd2Size.Height();
3882 aStateRect.Right() -= aBrd2Size.Width();
3883 aStateRect.Bottom() -= aBrd2Size.Height();
3884 Point aPos11( aStateRect.TopLeft() );
3885 Point aPos12( aStateRect.BottomRight() );
3886 Point aPos21( aStateRect.TopRight() );
3887 Point aPos22( aStateRect.BottomLeft() );
3888 Point aTempPos11( aPos11 );
3889 Point aTempPos12( aPos12 );
3890 Point aTempPos21( aPos21 );
3891 Point aTempPos22( aPos22 );
3892 pDev->SetLineColor( Color( COL_BLACK ) );
3893 long nDX = 0;
3894 for ( long i = 0; i < nCheckWidth; i++ )
3895 {
3896 if ( !(i % 2) )
3897 {
3898 aTempPos11.X() = aPos11.X()+nDX;
3899 aTempPos12.X() = aPos12.X()+nDX;
3900 aTempPos21.X() = aPos21.X()+nDX;
3901 aTempPos22.X() = aPos22.X()+nDX;
3902 }
3903 else
3904 {
3905 nDX++;
3906 aTempPos11.X() = aPos11.X()-nDX;
3907 aTempPos12.X() = aPos12.X()-nDX;
3908 aTempPos21.X() = aPos21.X()-nDX;
3909 aTempPos22.X() = aPos22.X()-nDX;
3910 }
3911 pDev->DrawLine( aTempPos11, aTempPos12 );
3912 pDev->DrawLine( aTempPos21, aTempPos22 );
3913 }
3914 }
3915
3916 pDev->Pop();
3917 }
3918
3919 // -----------------------------------------------------------------------
3920
3921 void CheckBox::Resize()
3922 {
3923 Control::Resize();
3924 Invalidate();
3925 }
3926
3927 // -----------------------------------------------------------------------
3928
3929 void CheckBox::GetFocus()
3930 {
3931 if ( !GetText().Len() || (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) )
3932 {
3933 // increase button size to have space for focus rect
3934 // checkboxes without text will draw focusrect around the check
3935 // See CheckBox::ImplDraw()
3936 Point aPos( GetPosPixel() );
3937 Size aSize( GetSizePixel() );
3938 aPos.Move(-1,-1);
3939 aSize.Height() += 2;
3940 aSize.Width() += 2;
3941 SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height(), WINDOW_POSSIZE_ALL );
3942 ImplDrawCheckBox();
3943 }
3944 else
3945 ShowFocus( ImplGetFocusRect() );
3946
3947 SetInputContext( InputContext( GetFont() ) );
3948 Button::GetFocus();
3949 }
3950
3951 // -----------------------------------------------------------------------
3952
3953 void CheckBox::LoseFocus()
3954 {
3955 if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED )
3956 {
3957 ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED;
3958 ImplInvalidateOrDrawCheckBoxState();
3959 }
3960
3961 HideFocus();
3962 Button::LoseFocus();
3963
3964 if ( !GetText().Len() || (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) )
3965 {
3966 // decrease button size again (see GetFocus())
3967 // checkboxes without text will draw focusrect around the check
3968 Point aPos( GetPosPixel() );
3969 Size aSize( GetSizePixel() );
3970 aPos.Move(1,1);
3971 aSize.Height() -= 2;
3972 aSize.Width() -= 2;
3973 SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height(), WINDOW_POSSIZE_ALL );
3974 ImplDrawCheckBox();
3975 }
3976 }
3977
3978 // -----------------------------------------------------------------------
3979
3980 void CheckBox::StateChanged( StateChangedType nType )
3981 {
3982 Button::StateChanged( nType );
3983
3984 if ( nType == STATE_CHANGE_STATE )
3985 {
3986 if ( IsReallyVisible() && IsUpdateMode() )
3987 Invalidate( maStateRect );
3988 }
3989 else if ( (nType == STATE_CHANGE_ENABLE) ||
3990 (nType == STATE_CHANGE_TEXT) ||
3991 (nType == STATE_CHANGE_IMAGE) ||
3992 (nType == STATE_CHANGE_DATA) ||
3993 (nType == STATE_CHANGE_UPDATEMODE) )
3994 {
3995 if ( IsUpdateMode() )
3996 Invalidate();
3997 }
3998 else if ( nType == STATE_CHANGE_STYLE )
3999 {
4000 SetStyle( ImplInitStyle( GetWindow( WINDOW_PREV ), GetStyle() ) );
4001
4002 if ( (GetPrevStyle() & CHECKBOX_VIEW_STYLE) !=
4003 (GetStyle() & CHECKBOX_VIEW_STYLE) )
4004 {
4005 if ( IsUpdateMode() )
4006 Invalidate();
4007 }
4008 }
4009 else if ( (nType == STATE_CHANGE_ZOOM) ||
4010 (nType == STATE_CHANGE_CONTROLFONT) )
4011 {
4012 ImplInitSettings( TRUE, FALSE, FALSE );
4013 Invalidate();
4014 }
4015 else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
4016 {
4017 ImplInitSettings( FALSE, TRUE, FALSE );
4018 Invalidate();
4019 }
4020 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
4021 {
4022 ImplInitSettings( FALSE, FALSE, TRUE );
4023 Invalidate();
4024 }
4025 }
4026
4027 // -----------------------------------------------------------------------
4028
4029 void CheckBox::DataChanged( const DataChangedEvent& rDCEvt )
4030 {
4031 Button::DataChanged( rDCEvt );
4032
4033 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
4034 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
4035 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
4036 (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
4037 {
4038 ImplInitSettings( TRUE, TRUE, TRUE );
4039 Invalidate();
4040 }
4041 }
4042
4043 // -----------------------------------------------------------------------
4044
4045 long CheckBox::PreNotify( NotifyEvent& rNEvt )
4046 {
4047 long nDone = 0;
4048 const MouseEvent* pMouseEvt = NULL;
4049
4050 if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL )
4051 {
4052 if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() )
4053 {
4054 // trigger redraw if mouse over state has changed
4055 if( IsNativeControlSupported(CTRL_CHECKBOX, PART_ENTIRE_CONTROL) )
4056 {
4057 if( ( maMouseRect.IsInside( GetPointerPosPixel()) &&
4058 !maMouseRect.IsInside( GetLastPointerPosPixel()) ) ||
4059 ( maMouseRect.IsInside( GetLastPointerPosPixel()) &&
4060 !maMouseRect.IsInside( GetPointerPosPixel()) ) ||
4061 pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow() )
4062 {
4063 Invalidate( maStateRect );
4064 }
4065 }
4066 }
4067 }
4068
4069 return nDone ? nDone : Button::PreNotify(rNEvt);
4070 }
4071
4072 // -----------------------------------------------------------------------
4073
4074 void CheckBox::Toggle()
4075 {
4076 ImplCallEventListenersAndHandler( VCLEVENT_CHECKBOX_TOGGLE, maToggleHdl, this );
4077 }
4078
4079 // -----------------------------------------------------------------------
4080
4081 void CheckBox::SetState( TriState eState )
4082 {
4083 if ( !mbTriState && (eState == STATE_DONTKNOW) )
4084 eState = STATE_NOCHECK;
4085
4086 if ( meState != eState )
4087 {
4088 meState = eState;
4089 StateChanged( STATE_CHANGE_STATE );
4090 Toggle();
4091 }
4092 }
4093
4094 // -----------------------------------------------------------------------
4095
4096 void CheckBox::EnableTriState( BOOL bTriState )
4097 {
4098 if ( mbTriState != bTriState )
4099 {
4100 mbTriState = bTriState;
4101
4102 if ( !bTriState && (meState == STATE_DONTKNOW) )
4103 SetState( STATE_NOCHECK );
4104 }
4105 }
4106
4107 // -----------------------------------------------------------------------
4108
4109 Size CheckBox::ImplGetCheckImageSize() const
4110 {
4111 Size aSize;
4112 // why are IsNativeControlSupported and GetNativeControlRegion not const ?
4113 CheckBox* pThis = const_cast<CheckBox*>(this);
4114 bool bDefaultSize = true;
4115 if( pThis->IsNativeControlSupported( CTRL_CHECKBOX, PART_ENTIRE_CONTROL ) )
4116 {
4117 ImplControlValue aControlValue;
4118 // #i45896# workaround gcc3.3 temporary problem
4119 Region aCtrlRegion = Region( Rectangle( Point( 0, 0 ), GetSizePixel() ) );
4120 ControlState nState = CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED;
4121 Region aBoundingRgn, aContentRgn;
4122
4123 // get native size of a check box
4124 if( pThis->GetNativeControlRegion( CTRL_CHECKBOX, PART_ENTIRE_CONTROL, aCtrlRegion,
4125 nState, aControlValue, rtl::OUString(),
4126 aBoundingRgn, aContentRgn ) )
4127 {
4128 Rectangle aCont(aContentRgn.GetBoundRect());
4129 aSize = aCont.GetSize();
4130 bDefaultSize = false;
4131 }
4132 }
4133 if( bDefaultSize )
4134 aSize = GetCheckImage( GetSettings(), 0 ).GetSizePixel();
4135 return aSize;
4136 }
4137
4138 Image CheckBox::GetCheckImage( const AllSettings& rSettings, USHORT nFlags )
4139 {
4140 ImplSVData* pSVData = ImplGetSVData();
4141 const StyleSettings& rStyleSettings = rSettings.GetStyleSettings();
4142 USHORT nStyle = rStyleSettings.GetCheckBoxStyle() & STYLE_CHECKBOX_STYLE;
4143
4144 if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO )
4145 nStyle = STYLE_CHECKBOX_MONO;
4146
4147 if ( !pSVData->maCtrlData.mpCheckImgList ||
4148 (pSVData->maCtrlData.mnCheckStyle != nStyle) ||
4149 (pSVData->maCtrlData.mnLastCheckFColor != rStyleSettings.GetFaceColor().GetColor()) ||
4150 (pSVData->maCtrlData.mnLastCheckWColor != rStyleSettings.GetWindowColor().GetColor()) ||
4151 (pSVData->maCtrlData.mnLastCheckLColor != rStyleSettings.GetLightColor().GetColor()) )
4152 {
4153 if ( pSVData->maCtrlData.mpCheckImgList )
4154 delete pSVData->maCtrlData.mpCheckImgList;
4155
4156 pSVData->maCtrlData.mnLastCheckFColor = rStyleSettings.GetFaceColor().GetColor();
4157 pSVData->maCtrlData.mnLastCheckWColor = rStyleSettings.GetWindowColor().GetColor();
4158 pSVData->maCtrlData.mnLastCheckLColor = rStyleSettings.GetLightColor().GetColor();
4159
4160 ResMgr* pResMgr = ImplGetResMgr();
4161 pSVData->maCtrlData.mpCheckImgList = new ImageList();
4162 if( pResMgr )
4163 LoadThemedImageList( rStyleSettings,
4164 pSVData->maCtrlData.mpCheckImgList,
4165 ResId( SV_RESID_BITMAP_CHECK+nStyle, *pResMgr ), 9 );
4166 pSVData->maCtrlData.mnCheckStyle = nStyle;
4167 }
4168
4169 USHORT nId;
4170 if ( nFlags & BUTTON_DRAW_DISABLED )
4171 {
4172 if ( nFlags & BUTTON_DRAW_DONTKNOW )
4173 nId = 9;
4174 else if ( nFlags & BUTTON_DRAW_CHECKED )
4175 nId = 6;
4176 else
4177 nId = 5;
4178 }
4179 else if ( nFlags & BUTTON_DRAW_PRESSED )
4180 {
4181 if ( nFlags & BUTTON_DRAW_DONTKNOW )
4182 nId = 8;
4183 else if ( nFlags & BUTTON_DRAW_CHECKED )
4184 nId = 4;
4185 else
4186 nId = 3;
4187 }
4188 else
4189 {
4190 if ( nFlags & BUTTON_DRAW_DONTKNOW )
4191 nId = 7;
4192 else if ( nFlags & BUTTON_DRAW_CHECKED )
4193 nId = 2;
4194 else
4195 nId = 1;
4196 }
4197 return pSVData->maCtrlData.mpCheckImgList->GetImage( nId );
4198 }
4199
4200 // -----------------------------------------------------------------------
4201
4202 void CheckBox::ImplSetMinimumNWFSize()
4203 {
4204 Push( PUSH_MAPMODE );
4205 SetMapMode( MAP_PIXEL );
4206
4207 ImplControlValue aControlValue;
4208 Size aCurSize( GetSizePixel() );
4209 Region aCtrlRegion = Region( Rectangle( Point( 0, 0 ), aCurSize ) );
4210 Region aBoundingRgn, aContentRgn;
4211
4212 // get native size of a radiobutton
4213 if( GetNativeControlRegion( CTRL_CHECKBOX, PART_ENTIRE_CONTROL, aCtrlRegion,
4214 CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED, aControlValue, rtl::OUString(),
4215 aBoundingRgn, aContentRgn ) )
4216 {
4217 Rectangle aCont(aContentRgn.GetBoundRect());
4218 Size aSize = aCont.GetSize();
4219
4220 if( aSize.Height() > aCurSize.Height() )
4221 {
4222 aCurSize.Height() = aSize.Height();
4223 SetSizePixel( aCurSize );
4224 }
4225 }
4226
4227 Pop();
4228 }
4229
4230 // -----------------------------------------------------------------------
4231
4232 Size CheckBox::CalcMinimumSize( long nMaxWidth ) const
4233 {
4234 Size aSize = ImplGetCheckImageSize();
4235 nMaxWidth -= aSize.Width();
4236
4237 XubString aText = GetText();
4238 if ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) )
4239 {
4240 // subtract what will be added later
4241 nMaxWidth-=2;
4242 nMaxWidth -= IMPL_SEP_BUTTON_IMAGE;
4243
4244 Size aTextSize = GetTextRect( Rectangle( Point(), Size( nMaxWidth > 0 ? nMaxWidth : 0x7fffffff, 0x7fffffff ) ),
4245 aText, FixedText::ImplGetTextStyle( GetStyle() ) ).GetSize();
4246 aSize.Width()+=2; // for focus rect
4247 aSize.Width() += IMPL_SEP_BUTTON_IMAGE;
4248 aSize.Width() += aTextSize.Width();
4249 if ( aSize.Height() < aTextSize.Height() )
4250 aSize.Height() = aTextSize.Height();
4251 }
4252 else
4253 {
4254 // is this still correct ? since the checkbox now
4255 // shows a focus rect it should be 2 pixels wider and longer
4256 /* da ansonsten im Writer die Control zu weit oben haengen
4257 aSize.Width() += 2;
4258 aSize.Height() += 2;
4259 */
4260 }
4261
4262 return CalcWindowSize( aSize );
4263 }
4264
4265 // -----------------------------------------------------------------------
4266
4267 Size CheckBox::GetOptimalSize(WindowSizeType eType) const
4268 {
4269 switch (eType) {
4270 case WINDOWSIZE_MINIMUM:
4271 return CalcMinimumSize();
4272 default:
4273 return Button::GetOptimalSize( eType );
4274 }
4275 }
4276
4277 // =======================================================================
4278
4279 ImageButton::ImageButton( WindowType nType ) :
4280 PushButton( nType )
4281 {
4282 ImplInitStyle();
4283 }
4284
4285 // -----------------------------------------------------------------------
4286
4287 ImageButton::ImageButton( Window* pParent, WinBits nStyle ) :
4288 PushButton( pParent, nStyle )
4289 {
4290 ImplInitStyle();
4291 }
4292
4293 // -----------------------------------------------------------------------
4294
4295 ImageButton::ImageButton( Window* pParent, const ResId& rResId ) :
4296 PushButton( pParent, rResId.SetRT( RSC_IMAGEBUTTON ) )
4297 {
4298 ULONG nObjMask = ReadLongRes();
4299
4300 if ( RSC_IMAGEBUTTON_IMAGE & nObjMask )
4301 {
4302 SetModeImage( Image( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) ) );
4303 IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
4304 }
4305
4306 if ( RSC_IMAGEBUTTON_SYMBOL & nObjMask )
4307 SetSymbol( (SymbolType)ReadLongRes() );
4308
4309 if ( RSC_IMAGEBUTTON_STATE & nObjMask )
4310 SetState( (TriState)ReadLongRes() );
4311
4312 ImplInitStyle();
4313 }
4314
4315 // -----------------------------------------------------------------------
4316
4317 ImageButton::~ImageButton()
4318 {
4319 }
4320
4321 // -----------------------------------------------------------------------
4322 void ImageButton::ImplInitStyle()
4323 {
4324 WinBits nStyle = GetStyle();
4325
4326 if ( ! ( nStyle & ( WB_RIGHT | WB_LEFT ) ) )
4327 nStyle |= WB_CENTER;
4328
4329 if ( ! ( nStyle & ( WB_TOP | WB_BOTTOM ) ) )
4330 nStyle |= WB_VCENTER;
4331
4332 SetStyle( nStyle );
4333 }
4334
4335 // =======================================================================
4336
4337 ImageRadioButton::ImageRadioButton( Window* pParent, WinBits nStyle ) :
4338 RadioButton( pParent, nStyle )
4339 {
4340 }
4341
4342 // -----------------------------------------------------------------------
4343
4344 ImageRadioButton::ImageRadioButton( Window* pParent, const ResId& rResId ) :
4345 RadioButton( pParent, rResId.SetRT( RSC_IMAGERADIOBUTTON ) )
4346 {
4347 ULONG nObjMask = ReadLongRes();
4348
4349 if ( RSC_IMAGERADIOBUTTON_IMAGE & nObjMask )
4350 {
4351 SetModeRadioImage( Image( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) ) );
4352 IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
4353 }
4354 }
4355
4356 // -----------------------------------------------------------------------
4357
4358 ImageRadioButton::~ImageRadioButton()
4359 {
4360 }
4361
4362 // =======================================================================
4363
4364 TriStateBox::TriStateBox( Window* pParent, WinBits nStyle ) :
4365 CheckBox( pParent, nStyle )
4366 {
4367 EnableTriState( TRUE );
4368 }
4369
4370 // -----------------------------------------------------------------------
4371
4372 TriStateBox::TriStateBox( Window* pParent, const ResId& rResId ) :
4373 CheckBox( pParent, rResId.SetRT( RSC_TRISTATEBOX ) )
4374 {
4375 EnableTriState( TRUE );
4376
4377 ULONG nTriState = ReadLongRes();
4378 USHORT bDisableTriState = ReadShortRes();
4379 //anderer Wert als Default ?
4380 if ( (TriState)nTriState != STATE_NOCHECK )
4381 SetState( (TriState)nTriState );
4382 if ( bDisableTriState )
4383 EnableTriState( FALSE );
4384 }
4385
4386 // -----------------------------------------------------------------------
4387
4388 TriStateBox::~TriStateBox()
4389 {
4390 }
vba interoperability for OOo