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