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