?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge the formfield patch from ooo-build
[ooovba.git] / vcl / source / control / fixed.cxx
blob3c53624dff149507d4a6f182f5b79df88010f920
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: fixed.cxx,v $
10 * $Revision: 1.25 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_vcl.hxx"
33 #include <vcl/decoview.hxx>
34 #include <vcl/event.hxx>
35 #include <vcl/fixed.hxx>
36 #include <vcl/controllayout.hxx>
37 #include <vcl/window.h>
38
39 #include <tools/rc.h>
40
41 // =======================================================================
42
43 #define FIXEDLINE_TEXT_BORDER 4
44
45 #define FIXEDTEXT_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_INFO | WB_PATHELLIPSIS)
50 #define FIXEDLINE_VIEW_STYLE (WB_3DLOOK | WB_NOLABEL)
51 #define FIXEDBITMAP_VIEW_STYLE (WB_3DLOOK | \
52 WB_LEFT | WB_CENTER | WB_RIGHT | \
53 WB_TOP | WB_VCENTER | WB_BOTTOM | \
54 WB_SCALE)
55 #define FIXEDIMAGE_VIEW_STYLE (WB_3DLOOK | \
56 WB_LEFT | WB_CENTER | WB_RIGHT | \
57 WB_TOP | WB_VCENTER | WB_BOTTOM | \
58 WB_SCALE)
59
60 // =======================================================================
61
62 static Point ImplCalcPos( WinBits nStyle, const Point& rPos,
63 const Size& rObjSize, const Size& rWinSize )
64 {
65 long nX;
66 long nY;
67
68 if ( nStyle & WB_LEFT )
69 nX = 0;
70 else if ( nStyle & WB_RIGHT )
71 nX = rWinSize.Width()-rObjSize.Width();
72 else
73 nX = (rWinSize.Width()-rObjSize.Width())/2;
74
75 if ( nStyle & WB_TOP )
76 nY = 0;
77 else if ( nStyle & WB_BOTTOM )
78 nY = rWinSize.Height()-rObjSize.Height();
79 else
80 nY = (rWinSize.Height()-rObjSize.Height())/2;
81
82 if ( nStyle & WB_TOPLEFTVISIBLE )
83 {
84 if ( nX < 0 )
85 nX = 0;
86 if ( nY < 0 )
87 nY = 0;
88 }
89
90 Point aPos( nX+rPos.X(), nY+rPos.Y() );
91 return aPos;
92 }
93
94 // =======================================================================
95
96 void FixedText::ImplInit( Window* pParent, WinBits nStyle )
97 {
98 nStyle = ImplInitStyle( nStyle );
99 Control::ImplInit( pParent, nStyle, NULL );
100 ImplInitSettings( TRUE, TRUE, TRUE );
101 }
102
103 // -----------------------------------------------------------------------
104
105 WinBits FixedText::ImplInitStyle( WinBits nStyle )
106 {
107 if ( !(nStyle & WB_NOGROUP) )
108 nStyle |= WB_GROUP;
109 return nStyle;
110 }
111
112 // -----------------------------------------------------------------------
113
114 void FixedText::ImplInitSettings( BOOL bFont,
115 BOOL bForeground, BOOL bBackground )
116 {
117 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
118
119 if ( bFont )
120 {
121 Font aFont;
122 if ( GetStyle() & WB_INFO )
123 aFont = rStyleSettings.GetInfoFont();
124 else
125 aFont = rStyleSettings.GetLabelFont();
126 if ( IsControlFont() )
127 aFont.Merge( GetControlFont() );
128 SetZoomedPointFont( aFont );
129 }
130
131 if ( bForeground || bFont )
132 {
133 Color aColor;
134 if ( IsControlForeground() )
135 aColor = GetControlForeground();
136 else
137 {
138 if ( GetStyle() & WB_INFO )
139 aColor = rStyleSettings.GetInfoTextColor();
140 else
141 aColor = rStyleSettings.GetLabelTextColor();
142 }
143 SetTextColor( aColor );
144 SetTextFillColor();
145 }
146
147 if ( bBackground )
148 {
149 Window* pParent = GetParent();
150 if ( pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
151 {
152 EnableChildTransparentMode( TRUE );
153 SetParentClipMode( PARENTCLIPMODE_NOCLIP );
154 SetPaintTransparent( TRUE );
155 SetBackground();
156 }
157 else
158 {
159 EnableChildTransparentMode( FALSE );
160 SetParentClipMode( 0 );
161 SetPaintTransparent( FALSE );
162
163 if ( IsControlBackground() )
164 SetBackground( GetControlBackground() );
165 else
166 SetBackground( pParent->GetBackground() );
167 }
168 }
169 }
170
171 // -----------------------------------------------------------------------
172
173 FixedText::FixedText( Window* pParent, WinBits nStyle ) :
174 Control( WINDOW_FIXEDTEXT )
175 {
176 ImplInit( pParent, nStyle );
177 }
178
179 // -----------------------------------------------------------------------
180
181 FixedText::FixedText( Window* pParent, const ResId& rResId ) :
182 Control( WINDOW_FIXEDTEXT )
183 {
184 rResId.SetRT( RSC_TEXT );
185 WinBits nStyle = ImplInitRes( rResId );
186 ImplInit( pParent, nStyle );
187 ImplLoadRes( rResId );
188
189 if ( !(nStyle & WB_HIDE) )
190 Show();
191 }
192
193 // -----------------------------------------------------------------------
194
195 FixedText::FixedText( Window* pParent, const ResId& rResId, bool bDisableAccessibleLabelForRelation ) :
196 Control( WINDOW_FIXEDTEXT )
197 {
198 rResId.SetRT( RSC_TEXT );
199 WinBits nStyle = ImplInitRes( rResId );
200 ImplInit( pParent, nStyle );
201 ImplLoadRes( rResId );
202 if ( bDisableAccessibleLabelForRelation )
203 ImplGetWindowImpl()->mbDisableAccessibleLabelForRelation = TRUE;
204
205 if ( !(nStyle & WB_HIDE) )
206 Show();
207 }
208
209 // -----------------------------------------------------------------------
210
211 USHORT FixedText::ImplGetTextStyle( WinBits nWinStyle )
212 {
213 USHORT nTextStyle = TEXT_DRAW_MNEMONIC | TEXT_DRAW_ENDELLIPSIS;
214
215 if( ! (nWinStyle & WB_NOMULTILINE) )
216 nTextStyle |= TEXT_DRAW_MULTILINE;
217
218 if ( nWinStyle & WB_RIGHT )
219 nTextStyle |= TEXT_DRAW_RIGHT;
220 else if ( nWinStyle & WB_CENTER )
221 nTextStyle |= TEXT_DRAW_CENTER;
222 else
223 nTextStyle |= TEXT_DRAW_LEFT;
224 if ( nWinStyle & WB_BOTTOM )
225 nTextStyle |= TEXT_DRAW_BOTTOM;
226 else if ( nWinStyle & WB_VCENTER )
227 nTextStyle |= TEXT_DRAW_VCENTER;
228 else
229 nTextStyle |= TEXT_DRAW_TOP;
230 if ( nWinStyle & WB_WORDBREAK )
231 {
232 nTextStyle |= TEXT_DRAW_WORDBREAK;
233 if ( (nWinStyle & WB_HYPHENATION ) == WB_HYPHENATION )
234 nTextStyle |= TEXT_DRAW_WORDBREAK_HYPHENATION;
235 }
236 if ( nWinStyle & WB_NOLABEL )
237 nTextStyle &= ~TEXT_DRAW_MNEMONIC;
238
239 return nTextStyle;
240 }
241
242 // -----------------------------------------------------------------------
243
244 void FixedText::ImplDraw( OutputDevice* pDev, ULONG nDrawFlags,
245 const Point& rPos, const Size& rSize,
246 bool bFillLayout
247 ) const
248 {
249 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
250 WinBits nWinStyle = GetStyle();
251 XubString aText( GetText() );
252 USHORT nTextStyle = FixedText::ImplGetTextStyle( nWinStyle );
253 Point aPos = rPos;
254
255 if ( nWinStyle & WB_EXTRAOFFSET )
256 aPos.X() += 2;
257
258 if ( nWinStyle & WB_PATHELLIPSIS )
259 {
260 nTextStyle &= ~(TEXT_DRAW_ENDELLIPSIS | TEXT_DRAW_MULTILINE | TEXT_DRAW_WORDBREAK);
261 nTextStyle |= TEXT_DRAW_PATHELLIPSIS;
262 }
263 if ( nDrawFlags & WINDOW_DRAW_NOMNEMONIC )
264 {
265 if ( nTextStyle & TEXT_DRAW_MNEMONIC )
266 {
267 aText = GetNonMnemonicString( aText );
268 nTextStyle &= ~TEXT_DRAW_MNEMONIC;
269 }
270 }
271 if ( !(nDrawFlags & WINDOW_DRAW_NODISABLE) )
272 {
273 if ( !IsEnabled() )
274 nTextStyle |= TEXT_DRAW_DISABLE;
275 }
276 if ( (nDrawFlags & WINDOW_DRAW_MONO) ||
277 (rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
278 nTextStyle |= TEXT_DRAW_MONO;
279
280 if( bFillLayout )
281 {
282 mpLayoutData->m_aDisplayText = String();
283 pDev->DrawText( Rectangle( aPos, rSize ),
284 aText,
285 nTextStyle,
286 &mpLayoutData->m_aUnicodeBoundRects,
287 &mpLayoutData->m_aDisplayText
288 );
289 }
290 else
291 pDev->DrawText( Rectangle( aPos, rSize ), aText, nTextStyle );
292 }
293
294 // -----------------------------------------------------------------------
295
296 void FixedText::Paint( const Rectangle& )
297 {
298 ImplDraw( this, 0, Point(), GetOutputSizePixel() );
299 }
300
301 // -----------------------------------------------------------------------
302
303 void FixedText::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
304 ULONG nFlags )
305 {
306 ImplInitSettings( TRUE, TRUE, TRUE );
307
308 Point aPos = pDev->LogicToPixel( rPos );
309 Size aSize = pDev->LogicToPixel( rSize );
310 Font aFont = GetDrawPixelFont( pDev );
311
312 pDev->Push();
313 pDev->SetMapMode();
314 pDev->SetFont( aFont );
315 if ( nFlags & WINDOW_DRAW_MONO )
316 pDev->SetTextColor( Color( COL_BLACK ) );
317 else
318 pDev->SetTextColor( GetTextColor() );
319 pDev->SetTextFillColor();
320
321 BOOL bBorder = !(nFlags & WINDOW_DRAW_NOBORDER ) && (GetStyle() & WB_BORDER);
322 BOOL bBackground = !(nFlags & WINDOW_DRAW_NOBACKGROUND) && IsControlBackground();
323 if ( bBorder || bBackground )
324 {
325 Rectangle aRect( aPos, aSize );
326 if ( bBorder )
327 {
328 ImplDrawFrame( pDev, aRect );
329 }
330 if ( bBackground )
331 {
332 pDev->SetFillColor( GetControlBackground() );
333 pDev->DrawRect( aRect );
334 }
335 }
336
337 ImplDraw( pDev, nFlags, aPos, aSize );
338 pDev->Pop();
339 }
340
341 // -----------------------------------------------------------------------
342
343 void FixedText::Resize()
344 {
345 Control::Resize();
346 Invalidate();
347 }
348
349 // -----------------------------------------------------------------------
350
351 void FixedText::StateChanged( StateChangedType nType )
352 {
353 Control::StateChanged( nType );
354
355 if ( (nType == STATE_CHANGE_ENABLE) ||
356 (nType == STATE_CHANGE_TEXT) ||
357 (nType == STATE_CHANGE_UPDATEMODE) )
358 {
359 if ( IsReallyVisible() && IsUpdateMode() )
360 Invalidate();
361 }
362 else if ( nType == STATE_CHANGE_STYLE )
363 {
364 SetStyle( ImplInitStyle( GetStyle() ) );
365 if ( (GetPrevStyle() & FIXEDTEXT_VIEW_STYLE) !=
366 (GetStyle() & FIXEDTEXT_VIEW_STYLE) )
367 {
368 ImplInitSettings( TRUE, FALSE, FALSE );
369 Invalidate();
370 }
371 }
372 else if ( (nType == STATE_CHANGE_ZOOM) ||
373 (nType == STATE_CHANGE_CONTROLFONT) )
374 {
375 ImplInitSettings( TRUE, FALSE, FALSE );
376 Invalidate();
377 }
378 else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
379 {
380 ImplInitSettings( FALSE, TRUE, FALSE );
381 Invalidate();
382 }
383 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
384 {
385 ImplInitSettings( FALSE, FALSE, TRUE );
386 Invalidate();
387 }
388 }
389
390 // -----------------------------------------------------------------------
391
392 void FixedText::DataChanged( const DataChangedEvent& rDCEvt )
393 {
394 Control::DataChanged( rDCEvt );
395
396 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
397 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
398 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
399 (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
400 {
401 ImplInitSettings( TRUE, TRUE, TRUE );
402 Invalidate();
403 }
404 }
405
406 // -----------------------------------------------------------------------
407
408 Size FixedText::CalcMinimumTextSize( Control const *pControl, long nMaxWidth )
409 {
410 USHORT nStyle = ImplGetTextStyle( pControl->GetStyle() );
411 if ( !( pControl->GetStyle() & WB_NOLABEL ) )
412 nStyle |= TEXT_DRAW_MNEMONIC;
413
414 Size aSize = pControl->GetTextRect( Rectangle( Point(), Size( (nMaxWidth ? nMaxWidth : 0x7fffffff), 0x7fffffff ) ),
415 pControl->GetText(), nStyle ).GetSize();
416
417 if ( pControl->GetStyle() & WB_EXTRAOFFSET )
418 aSize.Width() += 2;
419
420 // GetTextRect verkraftet keinen leeren String:
421 if ( aSize.Width() < 0 )
422 aSize.Width() = 0;
423 if ( aSize.Height() <= 0 )
424 aSize.Height() = pControl->GetTextHeight();
425
426 return aSize;
427 }
428
429 Size FixedText::CalcMinimumSize( long nMaxWidth ) const
430 {
431 return CalcWindowSize( CalcMinimumTextSize ( this, nMaxWidth ) );
432 }
433 // -----------------------------------------------------------------------
434
435 Size FixedText::GetOptimalSize(WindowSizeType eType) const
436 {
437 switch (eType) {
438 case WINDOWSIZE_MINIMUM:
439 return CalcMinimumSize();
440 default:
441 return Control::GetOptimalSize( eType );
442 }
443 }
444
445 // -----------------------------------------------------------------------
446
447 void FixedText::FillLayoutData() const
448 {
449 mpLayoutData = new vcl::ControlLayoutData();
450 ImplDraw( const_cast<FixedText*>(this), 0, Point(), GetOutputSizePixel(), true );
451 }
452
453 // =======================================================================
454
455 void FixedLine::ImplInit( Window* pParent, WinBits nStyle )
456 {
457 nStyle = ImplInitStyle( nStyle );
458 Control::ImplInit( pParent, nStyle, NULL );
459 ImplInitSettings( TRUE, TRUE, TRUE );
460 }
461
462 // -----------------------------------------------------------------------
463
464 WinBits FixedLine::ImplInitStyle( WinBits nStyle )
465 {
466 if ( !(nStyle & WB_NOGROUP) )
467 nStyle |= WB_GROUP;
468 return nStyle;
469 }
470
471 // -----------------------------------------------------------------------
472
473 void FixedLine::ImplInitSettings( BOOL bFont,
474 BOOL bForeground, BOOL bBackground )
475 {
476 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
477
478 if ( bFont )
479 {
480 Font aFont = rStyleSettings.GetGroupFont();
481 if ( IsControlFont() )
482 aFont.Merge( GetControlFont() );
483 SetZoomedPointFont( aFont );
484 }
485
486 if ( bForeground || bFont )
487 {
488 Color aColor;
489 if ( IsControlForeground() )
490 aColor = GetControlForeground();
491 else
492 aColor = rStyleSettings.GetGroupTextColor();
493 SetTextColor( aColor );
494 SetTextFillColor();
495 }
496
497 if ( bBackground )
498 {
499 Window* pParent = GetParent();
500 if ( pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
501 {
502 EnableChildTransparentMode( TRUE );
503 SetParentClipMode( PARENTCLIPMODE_NOCLIP );
504 SetPaintTransparent( TRUE );
505 SetBackground();
506 }
507 else
508 {
509 EnableChildTransparentMode( FALSE );
510 SetParentClipMode( 0 );
511 SetPaintTransparent( FALSE );
512
513 if ( IsControlBackground() )
514 SetBackground( GetControlBackground() );
515 else
516 SetBackground( pParent->GetBackground() );
517 }
518 }
519 }
520
521 // -----------------------------------------------------------------------
522
523 void FixedLine::ImplDraw( bool bLayout )
524 {
525 Size aOutSize = GetOutputSizePixel();
526 String aText = GetText();
527 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
528 WinBits nWinStyle = GetStyle();
529 MetricVector* pVector = bLayout ? &mpLayoutData->m_aUnicodeBoundRects : NULL;
530 String* pDisplayText = bLayout ? &mpLayoutData->m_aDisplayText : NULL;
531
532 if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO )
533 SetLineColor( Color( COL_BLACK ) );
534 else
535 SetLineColor( rStyleSettings.GetShadowColor() );
536
537 if ( !aText.Len() || (nWinStyle & WB_VERT) )
538 {
539 if( !pVector )
540 {
541 long nX = 0;
542 long nY = 0;
543
544 if ( nWinStyle & WB_VERT )
545 {
546 nX = (aOutSize.Width()-1)/2;
547 DrawLine( Point( nX, 0 ), Point( nX, aOutSize.Height()-1 ) );
548 }
549 else
550 {
551 nY = (aOutSize.Height()-1)/2;
552 DrawLine( Point( 0, nY ), Point( aOutSize.Width()-1, nY ) );
553 }
554
555 if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
556 {
557 SetLineColor( rStyleSettings.GetLightColor() );
558 if ( nWinStyle & WB_VERT )
559 DrawLine( Point( nX+1, 0 ), Point( nX+1, aOutSize.Height()-1 ) );
560 else
561 DrawLine( Point( 0, nY+1 ), Point( aOutSize.Width()-1, nY+1 ) );
562 }
563 }
564 }
565 else
566 {
567 USHORT nStyle = TEXT_DRAW_MNEMONIC | TEXT_DRAW_LEFT | TEXT_DRAW_VCENTER | TEXT_DRAW_ENDELLIPSIS;
568 Rectangle aRect( 0, 0, aOutSize.Width(), aOutSize.Height() );
569
570 if ( !IsEnabled() )
571 nStyle |= TEXT_DRAW_DISABLE;
572 if ( GetStyle() & WB_NOLABEL )
573 nStyle &= ~TEXT_DRAW_MNEMONIC;
574 if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO )
575 nStyle |= TEXT_DRAW_MONO;
576
577 aRect = GetTextRect( aRect, aText, nStyle );
578 DrawText( aRect, aText, nStyle, pVector, pDisplayText );
579
580 if( !pVector )
581 {
582 long nTop = aRect.Top() + ((aRect.GetHeight()-1)/2);
583 DrawLine( Point( aRect.Right()+FIXEDLINE_TEXT_BORDER, nTop ), Point( aOutSize.Width()-1, nTop ) );
584 if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
585 {
586 SetLineColor( rStyleSettings.GetLightColor() );
587 DrawLine( Point( aRect.Right()+FIXEDLINE_TEXT_BORDER, nTop+1 ), Point( aOutSize.Width()-1, nTop+1 ) );
588 }
589 }
590 }
591 }
592
593 // -----------------------------------------------------------------------
594
595 FixedLine::FixedLine( Window* pParent, WinBits nStyle ) :
596 Control( WINDOW_FIXEDLINE )
597 {
598 ImplInit( pParent, nStyle );
599 SetSizePixel( Size( 2, 2 ) );
600 }
601
602 // -----------------------------------------------------------------------
603
604 FixedLine::FixedLine( Window* pParent, const ResId& rResId ) :
605 Control( WINDOW_FIXEDLINE )
606 {
607 rResId.SetRT( RSC_FIXEDLINE );
608 WinBits nStyle = ImplInitRes( rResId );
609 ImplInit( pParent, nStyle );
610 ImplLoadRes( rResId );
611
612 if ( !(nStyle & WB_HIDE) )
613 Show();
614 }
615
616 // -----------------------------------------------------------------------
617
618 void FixedLine::FillLayoutData() const
619 {
620 mpLayoutData = new vcl::ControlLayoutData();
621 const_cast<FixedLine*>(this)->ImplDraw( true );
622 }
623
624
625 // -----------------------------------------------------------------------
626
627 void FixedLine::Paint( const Rectangle& )
628 {
629 ImplDraw();
630 }
631
632 // -----------------------------------------------------------------------
633
634 void FixedLine::Draw( OutputDevice*, const Point&, const Size&, ULONG )
635 {
636 }
637
638 // -----------------------------------------------------------------------
639
640 void FixedLine::Resize()
641 {
642 Control::Resize();
643 Invalidate();
644 }
645
646 // -----------------------------------------------------------------------
647
648 void FixedLine::StateChanged( StateChangedType nType )
649 {
650 Control::StateChanged( nType );
651
652 if ( (nType == STATE_CHANGE_ENABLE) ||
653 (nType == STATE_CHANGE_TEXT) ||
654 (nType == STATE_CHANGE_UPDATEMODE) )
655 {
656 if ( IsReallyVisible() && IsUpdateMode() )
657 Invalidate();
658 }
659 else if ( nType == STATE_CHANGE_STYLE )
660 {
661 SetStyle( ImplInitStyle( GetStyle() ) );
662 if ( (GetPrevStyle() & FIXEDLINE_VIEW_STYLE) !=
663 (GetStyle() & FIXEDLINE_VIEW_STYLE) )
664 Invalidate();
665 }
666 else if ( (nType == STATE_CHANGE_ZOOM) ||
667 (nType == STATE_CHANGE_STYLE) ||
668 (nType == STATE_CHANGE_CONTROLFONT) )
669 {
670 ImplInitSettings( TRUE, FALSE, FALSE );
671 Invalidate();
672 }
673 else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
674 {
675 ImplInitSettings( FALSE, TRUE, FALSE );
676 Invalidate();
677 }
678 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
679 {
680 ImplInitSettings( FALSE, FALSE, TRUE );
681 Invalidate();
682 }
683 }
684
685 // -----------------------------------------------------------------------
686
687 void FixedLine::DataChanged( const DataChangedEvent& rDCEvt )
688 {
689 Control::DataChanged( rDCEvt );
690
691 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
692 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
693 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
694 (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
695 {
696 ImplInitSettings( TRUE, TRUE, TRUE );
697 Invalidate();
698 }
699 }
700
701 // -----------------------------------------------------------------------
702
703 Size FixedLine::GetOptimalSize(WindowSizeType eType) const
704 {
705 switch (eType) {
706 case WINDOWSIZE_MINIMUM:
707 return CalcWindowSize( FixedText::CalcMinimumTextSize ( this ) );
708 default:
709 return Control::GetOptimalSize( eType );
710 }
711 }
712
713 // =======================================================================
714
715 void FixedBitmap::ImplInit( Window* pParent, WinBits nStyle )
716 {
717 nStyle = ImplInitStyle( nStyle );
718 Control::ImplInit( pParent, nStyle, NULL );
719 ImplInitSettings();
720 }
721
722 // -----------------------------------------------------------------------
723
724 WinBits FixedBitmap::ImplInitStyle( WinBits nStyle )
725 {
726 if ( !(nStyle & WB_NOGROUP) )
727 nStyle |= WB_GROUP;
728 return nStyle;
729 }
730
731 // -----------------------------------------------------------------------
732
733 void FixedBitmap::ImplInitSettings()
734 {
735 Window* pParent = GetParent();
736 if ( pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
737 {
738 EnableChildTransparentMode( TRUE );
739 SetParentClipMode( PARENTCLIPMODE_NOCLIP );
740 SetPaintTransparent( TRUE );
741 SetBackground();
742 }
743 else
744 {
745 EnableChildTransparentMode( FALSE );
746 SetParentClipMode( 0 );
747 SetPaintTransparent( FALSE );
748
749 if ( IsControlBackground() )
750 SetBackground( GetControlBackground() );
751 else
752 SetBackground( pParent->GetBackground() );
753 }
754 }
755
756 // -----------------------------------------------------------------------
757
758 void FixedBitmap::ImplLoadRes( const ResId& rResId )
759 {
760 Control::ImplLoadRes( rResId );
761
762 ULONG nObjMask = ReadLongRes();
763
764 if ( RSC_FIXEDBITMAP_BITMAP & nObjMask )
765 {
766 maBitmap = Bitmap( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) );
767 IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
768 }
769 }
770
771 // -----------------------------------------------------------------------
772
773 FixedBitmap::FixedBitmap( Window* pParent, WinBits nStyle ) :
774 Control( WINDOW_FIXEDBITMAP )
775 {
776 ImplInit( pParent, nStyle );
777 }
778
779 // -----------------------------------------------------------------------
780
781 FixedBitmap::FixedBitmap( Window* pParent, const ResId& rResId ) :
782 Control( WINDOW_FIXEDBITMAP )
783 {
784 rResId.SetRT( RSC_FIXEDBITMAP );
785 WinBits nStyle = ImplInitRes( rResId );
786 ImplInit( pParent, nStyle );
787 ImplLoadRes( rResId );
788
789 if ( !(nStyle & WB_HIDE) )
790 Show();
791 }
792
793 // -----------------------------------------------------------------------
794
795 FixedBitmap::~FixedBitmap()
796 {
797 }
798
799 // -----------------------------------------------------------------------
800
801 void FixedBitmap::ImplDraw( OutputDevice* pDev, ULONG /* nDrawFlags */,
802 const Point& rPos, const Size& rSize )
803 {
804 USHORT nStyle = 0;
805 Bitmap* pBitmap = &maBitmap;
806 Color aCol;
807 if( !!maBitmapHC )
808 {
809 if( GetSettings().GetStyleSettings().GetHighContrastMode() )
810 pBitmap = &maBitmapHC;
811 }
812
813 if( nStyle & IMAGE_DRAW_COLORTRANSFORM )
814 {
815 // only images support IMAGE_DRAW_COLORTRANSFORM
816 Image aImage( maBitmap );
817 if ( !(!aImage) )
818 {
819 if ( GetStyle() & WB_SCALE )
820 pDev->DrawImage( rPos, rSize, aImage, nStyle );
821 else
822 {
823 Point aPos = ImplCalcPos( GetStyle(), rPos, aImage.GetSizePixel(), rSize );
824 pDev->DrawImage( aPos, aImage, nStyle );
825 }
826 }
827 }
828 else
829 {
830 // Haben wir ueberhaupt eine Bitmap
831 if ( !(!(*pBitmap)) )
832 {
833 if ( GetStyle() & WB_SCALE )
834 pDev->DrawBitmap( rPos, rSize, *pBitmap );
835 else
836 {
837 Point aPos = ImplCalcPos( GetStyle(), rPos, pBitmap->GetSizePixel(), rSize );
838 pDev->DrawBitmap( aPos, *pBitmap );
839 }
840 }
841 }
842 }
843
844 // -----------------------------------------------------------------------
845
846 void FixedBitmap::Paint( const Rectangle& )
847 {
848 ImplDraw( this, 0, Point(), GetOutputSizePixel() );
849 }
850
851 // -----------------------------------------------------------------------
852
853 void FixedBitmap::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
854 ULONG nFlags )
855 {
856 Point aPos = pDev->LogicToPixel( rPos );
857 Size aSize = pDev->LogicToPixel( rSize );
858 Rectangle aRect( aPos, aSize );
859
860 pDev->Push();
861 pDev->SetMapMode();
862
863 // Border
864 if ( !(nFlags & WINDOW_DRAW_NOBORDER) && (GetStyle() & WB_BORDER) )
865 {
866 DecorationView aDecoView( pDev );
867 aRect = aDecoView.DrawFrame( aRect, FRAME_DRAW_DOUBLEIN );
868 }
869 pDev->IntersectClipRegion( aRect );
870 ImplDraw( pDev, nFlags, aRect.TopLeft(), aRect.GetSize() );
871
872 pDev->Pop();
873 }
874
875 // -----------------------------------------------------------------------
876
877 void FixedBitmap::Resize()
878 {
879 Control::Resize();
880 Invalidate();
881 }
882
883 // -----------------------------------------------------------------------
884
885 void FixedBitmap::StateChanged( StateChangedType nType )
886 {
887 Control::StateChanged( nType );
888
889 if ( (nType == STATE_CHANGE_DATA) ||
890 (nType == STATE_CHANGE_UPDATEMODE) )
891 {
892 if ( IsReallyVisible() && IsUpdateMode() )
893 Invalidate();
894 }
895 else if ( nType == STATE_CHANGE_STYLE )
896 {
897 SetStyle( ImplInitStyle( GetStyle() ) );
898 if ( (GetPrevStyle() & FIXEDBITMAP_VIEW_STYLE) !=
899 (GetStyle() & FIXEDBITMAP_VIEW_STYLE) )
900 Invalidate();
901 }
902 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
903 {
904 ImplInitSettings();
905 Invalidate();
906 }
907 }
908
909 // -----------------------------------------------------------------------
910
911 void FixedBitmap::DataChanged( const DataChangedEvent& rDCEvt )
912 {
913 Control::DataChanged( rDCEvt );
914
915 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
916 (rDCEvt.GetFlags() & SETTINGS_STYLE) )
917 {
918 ImplInitSettings();
919 Invalidate();
920 }
921 }
922
923 // -----------------------------------------------------------------------
924
925 void FixedBitmap::SetBitmap( const Bitmap& rBitmap )
926 {
927 maBitmap = rBitmap;
928 StateChanged( STATE_CHANGE_DATA );
929 }
930
931 // -----------------------------------------------------------------------
932
933 BOOL FixedBitmap::SetModeBitmap( const Bitmap& rBitmap, BmpColorMode eMode )
934 {
935 if( eMode == BMP_COLOR_NORMAL )
936 SetBitmap( rBitmap );
937 else if( eMode == BMP_COLOR_HIGHCONTRAST )
938 {
939 maBitmapHC = rBitmap;
940 StateChanged( STATE_CHANGE_DATA );
941 }
942 else
943 return FALSE;
944 return TRUE;
945 }
946
947 // -----------------------------------------------------------------------
948
949 const Bitmap& FixedBitmap::GetModeBitmap( BmpColorMode eMode) const
950 {
951 if( eMode == BMP_COLOR_HIGHCONTRAST )
952 return maBitmapHC;
953 else
954 return maBitmap;
955 }
956
957 // =======================================================================
958
959 void FixedImage::ImplInit( Window* pParent, WinBits nStyle )
960 {
961 nStyle = ImplInitStyle( nStyle );
962 mbInUserDraw = FALSE;
963 Control::ImplInit( pParent, nStyle, NULL );
964 ImplInitSettings();
965 }
966
967 // -----------------------------------------------------------------------
968
969 WinBits FixedImage::ImplInitStyle( WinBits nStyle )
970 {
971 if ( !(nStyle & WB_NOGROUP) )
972 nStyle |= WB_GROUP;
973 return nStyle;
974 }
975
976 // -----------------------------------------------------------------------
977
978 void FixedImage::ImplInitSettings()
979 {
980 Window* pParent = GetParent();
981 if ( pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
982 {
983 EnableChildTransparentMode( TRUE );
984 SetParentClipMode( PARENTCLIPMODE_NOCLIP );
985 SetPaintTransparent( TRUE );
986 SetBackground();
987 }
988 else
989 {
990 EnableChildTransparentMode( FALSE );
991 SetParentClipMode( 0 );
992 SetPaintTransparent( FALSE );
993
994 if ( IsControlBackground() )
995 SetBackground( GetControlBackground() );
996 else
997 SetBackground( pParent->GetBackground() );
998 }
999 }
1000
1001 // -----------------------------------------------------------------------
1002
1003 void FixedImage::ImplLoadRes( const ResId& rResId )
1004 {
1005 Control::ImplLoadRes( rResId );
1006
1007 ULONG nObjMask = ReadLongRes();
1008
1009 if ( RSC_FIXEDIMAGE_IMAGE & nObjMask )
1010 {
1011 maImage = Image( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) );
1012 IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
1013 }
1014 }
1015
1016 // -----------------------------------------------------------------------
1017
1018 FixedImage::FixedImage( Window* pParent, WinBits nStyle ) :
1019 Control( WINDOW_FIXEDIMAGE )
1020 {
1021 ImplInit( pParent, nStyle );
1022 }
1023
1024 // -----------------------------------------------------------------------
1025
1026 FixedImage::FixedImage( Window* pParent, const ResId& rResId ) :
1027 Control( WINDOW_FIXEDIMAGE )
1028 {
1029 rResId.SetRT( RSC_FIXEDIMAGE );
1030 WinBits nStyle = ImplInitRes( rResId );
1031 ImplInit( pParent, nStyle );
1032 ImplLoadRes( rResId );
1033
1034 if ( !(nStyle & WB_HIDE) )
1035 Show();
1036 }
1037
1038 // -----------------------------------------------------------------------
1039
1040 FixedImage::~FixedImage()
1041 {
1042 }
1043
1044 // -----------------------------------------------------------------------
1045
1046 void FixedImage::ImplDraw( OutputDevice* pDev, ULONG nDrawFlags,
1047 const Point& rPos, const Size& rSize )
1048 {
1049 USHORT nStyle = 0;
1050 if ( !(nDrawFlags & WINDOW_DRAW_NODISABLE) )
1051 {
1052 if ( !IsEnabled() )
1053 nStyle |= IMAGE_DRAW_DISABLE;
1054 }
1055
1056 Image *pImage = &maImage;
1057 Color aCol;
1058 if( !!maImageHC )
1059 {
1060 if( GetSettings().GetStyleSettings().GetHighContrastMode() )
1061 pImage = &maImageHC;
1062 }
1063
1064 // Haben wir ueberhaupt ein Image
1065 if ( !(!(*pImage)) )
1066 {
1067 if ( GetStyle() & WB_SCALE )
1068 pDev->DrawImage( rPos, rSize, *pImage, nStyle );
1069 else
1070 {
1071 Point aPos = ImplCalcPos( GetStyle(), rPos, pImage->GetSizePixel(), rSize );
1072 pDev->DrawImage( aPos, *pImage, nStyle );
1073 }
1074 }
1075
1076 mbInUserDraw = TRUE;
1077 UserDrawEvent aUDEvt( pDev, Rectangle( rPos, rSize ), 0, nStyle );
1078 UserDraw( aUDEvt );
1079 mbInUserDraw = FALSE;
1080 }
1081
1082 // -----------------------------------------------------------------------
1083
1084 void FixedImage::Paint( const Rectangle& )
1085 {
1086 ImplDraw( this, 0, Point(), GetOutputSizePixel() );
1087 }
1088
1089 // -----------------------------------------------------------------------
1090
1091 void FixedImage::UserDraw( const UserDrawEvent& )
1092 {
1093 }
1094
1095 // -----------------------------------------------------------------------
1096
1097 void FixedImage::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
1098 ULONG nFlags )
1099 {
1100 Point aPos = pDev->LogicToPixel( rPos );
1101 Size aSize = pDev->LogicToPixel( rSize );
1102 Rectangle aRect( aPos, aSize );
1103
1104 pDev->Push();
1105 pDev->SetMapMode();
1106
1107 // Border
1108 if ( !(nFlags & WINDOW_DRAW_NOBORDER) && (GetStyle() & WB_BORDER) )
1109 {
1110 ImplDrawFrame( pDev, aRect );
1111 }
1112 pDev->IntersectClipRegion( aRect );
1113 ImplDraw( pDev, nFlags, aRect.TopLeft(), aRect.GetSize() );
1114
1115 pDev->Pop();
1116 }
1117
1118 // -----------------------------------------------------------------------
1119
1120 void FixedImage::Resize()
1121 {
1122 Control::Resize();
1123 Invalidate();
1124 }
1125
1126 // -----------------------------------------------------------------------
1127
1128 void FixedImage::StateChanged( StateChangedType nType )
1129 {
1130 Control::StateChanged( nType );
1131
1132 if ( (nType == STATE_CHANGE_ENABLE) ||
1133 (nType == STATE_CHANGE_DATA) ||
1134 (nType == STATE_CHANGE_UPDATEMODE) )
1135 {
1136 if ( IsReallyVisible() && IsUpdateMode() )
1137 Invalidate();
1138 }
1139 else if ( nType == STATE_CHANGE_STYLE )
1140 {
1141 SetStyle( ImplInitStyle( GetStyle() ) );
1142 if ( (GetPrevStyle() & FIXEDIMAGE_VIEW_STYLE) !=
1143 (GetStyle() & FIXEDIMAGE_VIEW_STYLE) )
1144 Invalidate();
1145 }
1146 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1147 {
1148 ImplInitSettings();
1149 Invalidate();
1150 }
1151 }
1152
1153 // -----------------------------------------------------------------------
1154
1155 void FixedImage::DataChanged( const DataChangedEvent& rDCEvt )
1156 {
1157 Control::DataChanged( rDCEvt );
1158
1159 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1160 (rDCEvt.GetFlags() & SETTINGS_STYLE) )
1161 {
1162 ImplInitSettings();
1163 Invalidate();
1164 }
1165 }
1166
1167 // -----------------------------------------------------------------------
1168
1169 void FixedImage::SetImage( const Image& rImage )
1170 {
1171 if ( rImage != maImage )
1172 {
1173 maImage = rImage;
1174 StateChanged( STATE_CHANGE_DATA );
1175 }
1176 }
1177
1178 // -----------------------------------------------------------------------
1179
1180 BOOL FixedImage::SetModeImage( const Image& rImage, BmpColorMode eMode )
1181 {
1182 if( eMode == BMP_COLOR_NORMAL )
1183 SetImage( rImage );
1184 else if( eMode == BMP_COLOR_HIGHCONTRAST )
1185 {
1186 if( maImageHC != rImage )
1187 {
1188 maImageHC = rImage;
1189 StateChanged( STATE_CHANGE_DATA );
1190 }
1191 }
1192 else
1193 return FALSE;
1194 return TRUE;
1195 }
1196
1197 // -----------------------------------------------------------------------
1198
1199 const Image& FixedImage::GetModeImage( BmpColorMode eMode ) const
1200 {
1201 if( eMode == BMP_COLOR_HIGHCONTRAST )
1202 return maImageHC;
1203 else
1204 return maImage;
1205 }
1206
1207 // -----------------------------------------------------------------------
1208
1209 Point FixedImage::CalcImagePos( const Point& rPos,
1210 const Size& rObjSize, const Size& rWinSize )
1211 {
1212 return ImplCalcPos( GetStyle(), rPos, rObjSize, rWinSize );
1213 }
vba interoperability for OOo