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 : #include "tools/rc.h"
21 :
22 : #include "vcl/decoview.hxx"
23 : #include "vcl/dialog.hxx"
24 : #include "vcl/event.hxx"
25 : #include "vcl/fixed.hxx"
26 : #include "vcl/svapp.hxx"
27 : #include "vcl/settings.hxx"
28 :
29 : #include <comphelper/string.hxx>
30 : #include "controldata.hxx"
31 : #include "impimagetree.hxx"
32 : #include "window.h"
33 :
34 : #define FIXEDLINE_TEXT_BORDER 4
35 :
36 : #define FIXEDTEXT_VIEW_STYLE (WB_3DLOOK | \
37 : WB_LEFT | WB_CENTER | WB_RIGHT | \
38 : WB_TOP | WB_VCENTER | WB_BOTTOM | \
39 : WB_WORDBREAK | WB_NOLABEL | \
40 : WB_INFO | WB_PATHELLIPSIS)
41 : #define FIXEDLINE_VIEW_STYLE (WB_3DLOOK | WB_NOLABEL)
42 : #define FIXEDBITMAP_VIEW_STYLE (WB_3DLOOK | \
43 : WB_LEFT | WB_CENTER | WB_RIGHT | \
44 : WB_TOP | WB_VCENTER | WB_BOTTOM | \
45 : WB_SCALE)
46 : #define FIXEDIMAGE_VIEW_STYLE (WB_3DLOOK | \
47 : WB_LEFT | WB_CENTER | WB_RIGHT | \
48 : WB_TOP | WB_VCENTER | WB_BOTTOM | \
49 : WB_SCALE)
50 :
51 0 : static Point ImplCalcPos( WinBits nStyle, const Point& rPos,
52 : const Size& rObjSize, const Size& rWinSize )
53 : {
54 : long nX;
55 : long nY;
56 :
57 0 : if ( nStyle & WB_LEFT )
58 0 : nX = 0;
59 0 : else if ( nStyle & WB_RIGHT )
60 0 : nX = rWinSize.Width()-rObjSize.Width();
61 : else
62 0 : nX = (rWinSize.Width()-rObjSize.Width())/2;
63 :
64 0 : if ( nStyle & WB_TOP )
65 0 : nY = 0;
66 0 : else if ( nStyle & WB_BOTTOM )
67 0 : nY = rWinSize.Height()-rObjSize.Height();
68 : else
69 0 : nY = (rWinSize.Height()-rObjSize.Height())/2;
70 :
71 0 : if ( nStyle & WB_TOPLEFTVISIBLE )
72 : {
73 0 : if ( nX < 0 )
74 0 : nX = 0;
75 0 : if ( nY < 0 )
76 0 : nY = 0;
77 : }
78 :
79 0 : Point aPos( nX+rPos.X(), nY+rPos.Y() );
80 0 : return aPos;
81 : }
82 :
83 4261 : void FixedText::ImplInit( vcl::Window* pParent, WinBits nStyle )
84 : {
85 4261 : nStyle = ImplInitStyle( nStyle );
86 4261 : Control::ImplInit( pParent, nStyle, NULL );
87 4261 : ApplySettings(*this);
88 4261 : }
89 :
90 10791 : WinBits FixedText::ImplInitStyle( WinBits nStyle )
91 : {
92 10791 : if ( !(nStyle & WB_NOGROUP) )
93 10791 : nStyle |= WB_GROUP;
94 10791 : return nStyle;
95 : }
96 :
97 7067 : const vcl::Font& FixedText::GetCanonicalFont( const StyleSettings& _rStyle ) const
98 : {
99 7067 : return ( GetStyle() & WB_INFO ) ? _rStyle.GetInfoFont() : _rStyle.GetLabelFont();
100 : }
101 :
102 7061 : const Color& FixedText::GetCanonicalTextColor( const StyleSettings& _rStyle ) const
103 : {
104 7061 : return ( GetStyle() & WB_INFO ) ? _rStyle.GetInfoTextColor() : _rStyle.GetLabelTextColor();
105 : }
106 :
107 1643 : FixedText::FixedText( vcl::Window* pParent, WinBits nStyle )
108 : : Control(WINDOW_FIXEDTEXT)
109 : , m_nMaxWidthChars(-1)
110 : , m_nMinWidthChars(-1)
111 1643 : , m_pMnemonicWindow(NULL)
112 : {
113 1643 : ImplInit( pParent, nStyle );
114 1643 : }
115 :
116 2618 : FixedText::FixedText( vcl::Window* pParent, const ResId& rResId )
117 : : Control(WINDOW_FIXEDTEXT)
118 : , m_nMaxWidthChars(-1)
119 : , m_nMinWidthChars(-1)
120 2618 : , m_pMnemonicWindow(NULL)
121 : {
122 2618 : rResId.SetRT( RSC_TEXT );
123 2618 : WinBits nStyle = ImplInitRes( rResId );
124 2618 : ImplInit( pParent, nStyle );
125 2618 : ImplLoadRes( rResId );
126 :
127 2618 : if ( !(nStyle & WB_HIDE) )
128 2618 : Show();
129 2618 : }
130 :
131 3722 : DrawTextFlags FixedText::ImplGetTextStyle( WinBits nWinStyle )
132 : {
133 3722 : DrawTextFlags nTextStyle = DrawTextFlags::Mnemonic | DrawTextFlags::EndEllipsis;
134 :
135 3722 : if( ! (nWinStyle & WB_NOMULTILINE) )
136 3722 : nTextStyle |= DrawTextFlags::MultiLine;
137 :
138 3722 : if ( nWinStyle & WB_RIGHT )
139 0 : nTextStyle |= DrawTextFlags::Right;
140 3722 : else if ( nWinStyle & WB_CENTER )
141 459 : nTextStyle |= DrawTextFlags::Center;
142 : else
143 3263 : nTextStyle |= DrawTextFlags::Left;
144 3722 : if ( nWinStyle & WB_BOTTOM )
145 0 : nTextStyle |= DrawTextFlags::Bottom;
146 3722 : else if ( nWinStyle & WB_VCENTER )
147 3076 : nTextStyle |= DrawTextFlags::VCenter;
148 : else
149 646 : nTextStyle |= DrawTextFlags::Top;
150 3722 : if ( nWinStyle & WB_WORDBREAK )
151 : {
152 398 : nTextStyle |= DrawTextFlags::WordBreak;
153 398 : if ( (nWinStyle & WB_HYPHENATION ) == WB_HYPHENATION )
154 0 : nTextStyle |= DrawTextFlags::WordBreakHyphenation;
155 : }
156 3722 : if ( nWinStyle & WB_NOLABEL )
157 0 : nTextStyle &= ~DrawTextFlags::Mnemonic;
158 :
159 3722 : return nTextStyle;
160 : }
161 :
162 1182 : void FixedText::ImplDraw(OutputDevice* pDev, DrawFlags nDrawFlags,
163 : const Point& rPos, const Size& rSize,
164 : bool bFillLayout) const
165 : {
166 1182 : const StyleSettings& rStyleSettings = pDev->GetSettings().GetStyleSettings();
167 1182 : WinBits nWinStyle = GetStyle();
168 1182 : OUString aText(GetText());
169 1182 : DrawTextFlags nTextStyle = FixedText::ImplGetTextStyle( nWinStyle );
170 1182 : Point aPos = rPos;
171 :
172 1182 : if ( nWinStyle & WB_EXTRAOFFSET )
173 0 : aPos.X() += 2;
174 :
175 1182 : if ( nWinStyle & WB_PATHELLIPSIS )
176 : {
177 0 : nTextStyle &= ~DrawTextFlags(DrawTextFlags::EndEllipsis | DrawTextFlags::MultiLine | DrawTextFlags::WordBreak);
178 0 : nTextStyle |= DrawTextFlags::PathEllipsis;
179 : }
180 1182 : if ( nDrawFlags & DrawFlags::NoMnemonic )
181 : {
182 0 : if ( nTextStyle & DrawTextFlags::Mnemonic )
183 : {
184 0 : aText = GetNonMnemonicString( aText );
185 0 : nTextStyle &= ~DrawTextFlags::Mnemonic;
186 : }
187 : }
188 1182 : if ( !(nDrawFlags & DrawFlags::NoDisable) )
189 : {
190 1182 : if ( !IsEnabled() )
191 971 : nTextStyle |= DrawTextFlags::Disable;
192 : }
193 5910 : if ( (nDrawFlags & DrawFlags::Mono) ||
194 4728 : (rStyleSettings.GetOptions() & StyleSettingsOptions::Mono) )
195 0 : nTextStyle |= DrawTextFlags::Mono;
196 :
197 1182 : if( bFillLayout )
198 1 : (mpControlData->mpLayoutData->m_aDisplayText).clear();
199 :
200 1182 : Rectangle aRect( Rectangle( aPos, rSize ) );
201 : DrawControlText(*pDev, aRect, aText, nTextStyle,
202 : bFillLayout ? &mpControlData->mpLayoutData->m_aUnicodeBoundRects : NULL,
203 1182 : bFillLayout ? &mpControlData->mpLayoutData->m_aDisplayText : NULL);
204 1182 : }
205 :
206 7061 : void FixedText::ApplySettings(vcl::RenderContext& rRenderContext)
207 : {
208 7061 : Control::ApplySettings(rRenderContext);
209 :
210 7061 : vcl::Window* pParent = GetParent();
211 7061 : if (pParent->IsChildTransparentModeEnabled() && !IsControlBackground())
212 : {
213 2760 : EnableChildTransparentMode(true);
214 2760 : SetParentClipMode(ParentClipMode::NoClip);
215 2760 : SetPaintTransparent(true);
216 2760 : rRenderContext.SetBackground();
217 : }
218 : else
219 : {
220 4301 : EnableChildTransparentMode(false);
221 4301 : SetParentClipMode(ParentClipMode::NONE);
222 4301 : SetPaintTransparent(false);
223 :
224 4301 : if (IsControlBackground())
225 108 : rRenderContext.SetBackground(GetControlBackground());
226 : else
227 4193 : rRenderContext.SetBackground(pParent->GetBackground());
228 : }
229 7061 : }
230 :
231 1181 : void FixedText::Paint( vcl::RenderContext& rRenderContext, const Rectangle& )
232 : {
233 1181 : ImplDraw(&rRenderContext, DrawFlags::NONE, Point(), GetOutputSizePixel());
234 1181 : }
235 :
236 0 : void FixedText::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
237 : DrawFlags nFlags )
238 : {
239 0 : ApplySettings(*pDev);
240 :
241 0 : Point aPos = pDev->LogicToPixel( rPos );
242 0 : Size aSize = pDev->LogicToPixel( rSize );
243 0 : vcl::Font aFont = GetDrawPixelFont( pDev );
244 :
245 0 : pDev->Push();
246 0 : pDev->SetMapMode();
247 0 : pDev->SetFont( aFont );
248 0 : if ( nFlags & DrawFlags::Mono )
249 0 : pDev->SetTextColor( Color( COL_BLACK ) );
250 : else
251 0 : pDev->SetTextColor( GetTextColor() );
252 0 : pDev->SetTextFillColor();
253 :
254 0 : bool bBorder = !(nFlags & DrawFlags::NoBorder ) && (GetStyle() & WB_BORDER);
255 0 : bool bBackground = !(nFlags & DrawFlags::NoBackground) && IsControlBackground();
256 0 : if ( bBorder || bBackground )
257 : {
258 0 : Rectangle aRect( aPos, aSize );
259 0 : if ( bBorder )
260 : {
261 0 : ImplDrawFrame( pDev, aRect );
262 : }
263 0 : if ( bBackground )
264 : {
265 0 : pDev->SetFillColor( GetControlBackground() );
266 0 : pDev->DrawRect( aRect );
267 : }
268 : }
269 :
270 0 : ImplDraw( pDev, nFlags, aPos, aSize );
271 0 : pDev->Pop();
272 0 : }
273 :
274 9619 : void FixedText::Resize()
275 : {
276 9619 : Control::Resize();
277 9619 : Invalidate();
278 9619 : }
279 :
280 19088 : void FixedText::StateChanged( StateChangedType nType )
281 : {
282 19088 : Control::StateChanged( nType );
283 :
284 19088 : if ( (nType == StateChangedType::Enable) ||
285 13246 : (nType == StateChangedType::Text) ||
286 : (nType == StateChangedType::UpdateMode) )
287 : {
288 11684 : if ( IsReallyVisible() && IsUpdateMode() )
289 46 : Invalidate();
290 : }
291 13246 : else if ( nType == StateChangedType::Style )
292 : {
293 6530 : SetStyle( ImplInitStyle( GetStyle() ) );
294 13060 : if ( (GetPrevStyle() & FIXEDTEXT_VIEW_STYLE) !=
295 6530 : (GetStyle() & FIXEDTEXT_VIEW_STYLE) )
296 : {
297 1296 : ApplySettings(*this);
298 1296 : Invalidate();
299 : }
300 : }
301 6716 : else if ( (nType == StateChangedType::Zoom) ||
302 : (nType == StateChangedType::ControlFont) )
303 : {
304 221 : ApplySettings(*this);
305 221 : Invalidate();
306 : }
307 6495 : else if ( nType == StateChangedType::ControlForeground )
308 : {
309 64 : ApplySettings(*this);
310 64 : Invalidate();
311 : }
312 6431 : else if ( nType == StateChangedType::ControlBackground )
313 : {
314 63 : ApplySettings(*this);
315 63 : Invalidate();
316 : }
317 19088 : }
318 :
319 943 : void FixedText::DataChanged( const DataChangedEvent& rDCEvt )
320 : {
321 943 : Control::DataChanged( rDCEvt );
322 :
323 3772 : if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
324 3772 : (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
325 2829 : ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
326 3772 : (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
327 : {
328 943 : ApplySettings(*this);
329 943 : Invalidate();
330 : }
331 943 : }
332 :
333 1462 : Size FixedText::getTextDimensions(Control const *pControl, const OUString &rTxt, long nMaxWidth)
334 : {
335 1462 : DrawTextFlags nStyle = ImplGetTextStyle( pControl->GetStyle() );
336 1462 : if ( !( pControl->GetStyle() & WB_NOLABEL ) )
337 1462 : nStyle |= DrawTextFlags::Mnemonic;
338 :
339 : return pControl->GetTextRect(Rectangle( Point(), Size(nMaxWidth, 0x7fffffff)),
340 1462 : rTxt, nStyle).GetSize();
341 : }
342 :
343 1462 : Size FixedText::CalcMinimumTextSize( Control const *pControl, long nMaxWidth )
344 : {
345 1462 : Size aSize = getTextDimensions(pControl, pControl->GetText(), nMaxWidth);
346 :
347 1462 : if ( pControl->GetStyle() & WB_EXTRAOFFSET )
348 0 : aSize.Width() += 2;
349 :
350 : // GetTextRect cannot take an empty string
351 1462 : if ( aSize.Width() < 0 )
352 0 : aSize.Width() = 0;
353 1462 : if ( aSize.Height() <= 0 )
354 4 : aSize.Height() = pControl->GetTextHeight();
355 :
356 1462 : return aSize;
357 : }
358 :
359 1461 : Size FixedText::CalcMinimumSize( long nMaxWidth ) const
360 : {
361 1461 : return CalcWindowSize( CalcMinimumTextSize ( this, nMaxWidth ) );
362 : }
363 :
364 1445 : Size FixedText::GetOptimalSize() const
365 : {
366 1445 : sal_Int32 nMaxAvailWidth = 0x7fffffff;
367 1445 : const OUString &rTxt = GetText();
368 1445 : if (m_nMaxWidthChars != -1 && m_nMaxWidthChars < rTxt.getLength())
369 : {
370 : nMaxAvailWidth = getTextDimensions(this,
371 0 : rTxt.copy(0, m_nMaxWidthChars), 0x7fffffff).Width();
372 : }
373 1445 : Size aRet = CalcMinimumSize(nMaxAvailWidth);
374 1445 : if (m_nMinWidthChars != -1)
375 : {
376 0 : OUStringBuffer aBuf;
377 0 : comphelper::string::padToLength(aBuf, m_nMinWidthChars, 'x');
378 : Size aMinAllowed = getTextDimensions(this,
379 0 : aBuf.makeStringAndClear(), 0x7fffffff);
380 0 : if (aMinAllowed.Width() > aRet.Width())
381 0 : aRet = aMinAllowed;
382 : }
383 1445 : return aRet;
384 : }
385 :
386 1 : void FixedText::FillLayoutData() const
387 : {
388 1 : mpControlData->mpLayoutData = new vcl::ControlLayoutData();
389 1 : ImplDraw(const_cast<FixedText*>(this), DrawFlags::NONE, Point(), GetOutputSizePixel(), true);
390 : //const_cast<FixedText*>(this)->Invalidate();
391 1 : }
392 :
393 0 : void FixedText::setMaxWidthChars(sal_Int32 nWidth)
394 : {
395 0 : if (nWidth != m_nMaxWidthChars)
396 : {
397 0 : m_nMaxWidthChars = nWidth;
398 0 : queue_resize();
399 : }
400 0 : }
401 :
402 0 : void FixedText::setMinWidthChars(sal_Int32 nWidth)
403 : {
404 0 : if (nWidth != m_nMinWidthChars)
405 : {
406 0 : m_nMinWidthChars = nWidth;
407 0 : queue_resize();
408 : }
409 0 : }
410 :
411 7777 : bool FixedText::set_property(const OString &rKey, const OString &rValue)
412 : {
413 7777 : if (rKey == "max-width-chars")
414 0 : setMaxWidthChars(rValue.toInt32());
415 7777 : else if (rKey == "width-chars")
416 0 : setMinWidthChars(rValue.toInt32());
417 7777 : else if (rKey == "ellipsize")
418 : {
419 0 : WinBits nBits = GetStyle();
420 0 : nBits &= ~(WB_PATHELLIPSIS);
421 0 : if (rValue != "none")
422 : {
423 : SAL_WARN_IF(rValue != "end", "vcl.layout", "Only endellipsis support for now");
424 0 : nBits |= WB_PATHELLIPSIS;
425 : }
426 0 : SetStyle(nBits);
427 : }
428 : else
429 7777 : return Control::set_property(rKey, rValue);
430 0 : return true;
431 : }
432 :
433 6 : vcl::Window* FixedText::getAccessibleRelationLabelFor() const
434 : {
435 6 : vcl::Window *pWindow = Control::getAccessibleRelationLabelFor();
436 6 : if (pWindow)
437 0 : return pWindow;
438 6 : return get_mnemonic_widget();
439 : }
440 :
441 7647 : void FixedText::set_mnemonic_widget(vcl::Window *pWindow)
442 : {
443 7647 : if (pWindow == m_pMnemonicWindow)
444 13022 : return;
445 2272 : if (m_pMnemonicWindow)
446 : {
447 1136 : vcl::Window *pTempReEntryGuard = m_pMnemonicWindow;
448 1136 : m_pMnemonicWindow = NULL;
449 1136 : pTempReEntryGuard->remove_mnemonic_label(this);
450 : }
451 2272 : m_pMnemonicWindow = pWindow;
452 2272 : if (m_pMnemonicWindow)
453 1136 : m_pMnemonicWindow->add_mnemonic_label(this);
454 : }
455 :
456 12717 : FixedText::~FixedText()
457 : {
458 4239 : disposeOnce();
459 8478 : }
460 :
461 4239 : void FixedText::dispose()
462 : {
463 4239 : set_mnemonic_widget(NULL);
464 4239 : m_pMnemonicWindow.clear();
465 4239 : Control::dispose();
466 4239 : }
467 :
468 0 : SelectableFixedText::SelectableFixedText(vcl::Window* pParent, WinBits nStyle)
469 0 : : Edit(pParent, nStyle)
470 : {
471 : // no border
472 0 : SetBorderStyle( WindowBorderStyle::NOBORDER );
473 : // read-only
474 0 : SetReadOnly();
475 : // make it transparent
476 0 : SetPaintTransparent(true);
477 0 : SetControlBackground();
478 0 : }
479 :
480 0 : void SelectableFixedText::ApplySettings(vcl::RenderContext& rRenderContext)
481 : {
482 0 : rRenderContext.SetBackground();
483 0 : }
484 :
485 0 : void SelectableFixedText::LoseFocus()
486 : {
487 0 : Edit::LoseFocus();
488 : // clear cursor
489 0 : Invalidate();
490 0 : }
491 :
492 290 : void FixedLine::ImplInit( vcl::Window* pParent, WinBits nStyle )
493 : {
494 290 : nStyle = ImplInitStyle( nStyle );
495 290 : Control::ImplInit( pParent, nStyle, NULL );
496 290 : ApplySettings(*this);
497 290 : }
498 :
499 290 : WinBits FixedLine::ImplInitStyle( WinBits nStyle )
500 : {
501 290 : if ( !(nStyle & WB_NOGROUP) )
502 290 : nStyle |= WB_GROUP;
503 290 : return nStyle;
504 : }
505 :
506 395 : const vcl::Font& FixedLine::GetCanonicalFont( const StyleSettings& _rStyle ) const
507 : {
508 395 : return _rStyle.GetGroupFont();
509 : }
510 :
511 395 : const Color& FixedLine::GetCanonicalTextColor( const StyleSettings& _rStyle ) const
512 : {
513 395 : return _rStyle.GetGroupTextColor();
514 : }
515 :
516 13 : void FixedLine::ImplDraw(vcl::RenderContext& rRenderContext, bool bLayout)
517 : {
518 13 : Size aOutSize = rRenderContext.GetOutputSizePixel();
519 13 : OUString aText = GetText();
520 13 : WinBits nWinStyle = GetStyle();
521 13 : MetricVector* pVector = bLayout ? &mpControlData->mpLayoutData->m_aUnicodeBoundRects : NULL;
522 13 : OUString* pDisplayText = bLayout ? &mpControlData->mpLayoutData->m_aDisplayText : NULL;
523 :
524 26 : DecorationView aDecoView(&rRenderContext);
525 13 : if (aText.isEmpty())
526 : {
527 13 : if (!pVector)
528 : {
529 13 : if (nWinStyle & WB_VERT)
530 : {
531 6 : long nX = (aOutSize.Width() - 1) / 2;
532 6 : aDecoView.DrawSeparator(Point(nX, 0), Point(nX, aOutSize.Height() - 1));
533 : }
534 : else
535 : {
536 7 : long nY = (aOutSize.Height() - 1) / 2;
537 7 : aDecoView.DrawSeparator(Point(0, nY), Point(aOutSize.Width() - 1, nY), false);
538 : }
539 : }
540 : }
541 0 : else if (nWinStyle & WB_VERT)
542 : {
543 0 : long nWidth = rRenderContext.GetTextWidth(aText);
544 0 : rRenderContext.Push(PushFlags::FONT);
545 0 : vcl::Font aFont(rRenderContext.GetFont());
546 0 : aFont.SetOrientation(00);
547 0 : SetFont(aFont);
548 0 : Point aStartPt(aOutSize.Width() / 2, aOutSize.Height() - 1);
549 0 : if (nWinStyle & WB_VCENTER)
550 0 : aStartPt.Y() -= (aOutSize.Height() - nWidth) / 2;
551 0 : Point aTextPt(aStartPt);
552 0 : aTextPt.X() -= GetTextHeight() / 2;
553 0 : rRenderContext.DrawText(aTextPt, aText, 0, aText.getLength(), pVector, pDisplayText);
554 0 : rRenderContext.Pop();
555 0 : if (aOutSize.Height() - aStartPt.Y() > FIXEDLINE_TEXT_BORDER)
556 0 : aDecoView.DrawSeparator(Point(aStartPt.X(), aOutSize.Height() - 1),
557 0 : Point(aStartPt.X(), aStartPt.Y() + FIXEDLINE_TEXT_BORDER));
558 0 : if (aStartPt.Y() - nWidth - FIXEDLINE_TEXT_BORDER > 0)
559 0 : aDecoView.DrawSeparator(Point(aStartPt.X(), aStartPt.Y() - nWidth - FIXEDLINE_TEXT_BORDER),
560 0 : Point(aStartPt.X(), 0));
561 : }
562 : else
563 : {
564 0 : DrawTextFlags nStyle = DrawTextFlags::Mnemonic | DrawTextFlags::Left | DrawTextFlags::VCenter | DrawTextFlags::EndEllipsis;
565 0 : Rectangle aRect(0, 0, aOutSize.Width(), aOutSize.Height());
566 0 : const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
567 0 : if (nWinStyle & WB_CENTER)
568 0 : nStyle |= DrawTextFlags::Center;
569 :
570 0 : if (!IsEnabled())
571 0 : nStyle |= DrawTextFlags::Disable;
572 0 : if (GetStyle() & WB_NOLABEL)
573 0 : nStyle &= ~DrawTextFlags::Mnemonic;
574 0 : if (rStyleSettings.GetOptions() & StyleSettingsOptions::Mono)
575 0 : nStyle |= DrawTextFlags::Mono;
576 :
577 0 : DrawControlText(*this, aRect, aText, nStyle, pVector, pDisplayText);
578 :
579 0 : if (!pVector)
580 : {
581 0 : long nTop = aRect.Top() + ((aRect.GetHeight() - 1) / 2);
582 0 : aDecoView.DrawSeparator(Point(aRect.Right() + FIXEDLINE_TEXT_BORDER, nTop), Point(aOutSize.Width() - 1, nTop), false);
583 0 : if (aRect.Left() > FIXEDLINE_TEXT_BORDER)
584 0 : aDecoView.DrawSeparator(Point(0, nTop), Point(aRect.Left() - FIXEDLINE_TEXT_BORDER, nTop), false);
585 : }
586 13 : }
587 13 : }
588 :
589 290 : FixedLine::FixedLine( vcl::Window* pParent, WinBits nStyle ) :
590 290 : Control( WINDOW_FIXEDLINE )
591 : {
592 290 : ImplInit( pParent, nStyle );
593 290 : SetSizePixel( Size( 2, 2 ) );
594 290 : }
595 :
596 0 : FixedLine::FixedLine( vcl::Window* pParent, const ResId& rResId ) :
597 0 : Control( WINDOW_FIXEDLINE )
598 : {
599 0 : rResId.SetRT( RSC_FIXEDLINE );
600 0 : WinBits nStyle = ImplInitRes( rResId );
601 0 : ImplInit( pParent, nStyle );
602 0 : ImplLoadRes( rResId );
603 :
604 0 : if ( !(nStyle & WB_HIDE) )
605 0 : Show();
606 0 : }
607 :
608 0 : void FixedLine::FillLayoutData() const
609 : {
610 0 : mpControlData->mpLayoutData = new vcl::ControlLayoutData();
611 0 : const_cast<FixedLine*>(this)->Invalidate();
612 0 : }
613 :
614 395 : void FixedLine::ApplySettings(vcl::RenderContext& rRenderContext)
615 : {
616 395 : Control::ApplySettings(rRenderContext);
617 :
618 395 : vcl::Window* pParent = GetParent();
619 395 : if (pParent->IsChildTransparentModeEnabled() && !IsControlBackground())
620 : {
621 362 : EnableChildTransparentMode(true);
622 362 : SetParentClipMode(ParentClipMode::NoClip);
623 362 : SetPaintTransparent(true);
624 362 : rRenderContext.SetBackground();
625 : }
626 : else
627 : {
628 33 : EnableChildTransparentMode(false);
629 33 : SetParentClipMode(ParentClipMode::NONE);
630 33 : SetPaintTransparent(false);
631 :
632 33 : if (IsControlBackground())
633 0 : rRenderContext.SetBackground(GetControlBackground());
634 : else
635 33 : rRenderContext.SetBackground(pParent->GetBackground());
636 : }
637 395 : }
638 :
639 13 : void FixedLine::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
640 : {
641 13 : ImplDraw(rRenderContext);
642 13 : }
643 :
644 0 : void FixedLine::Draw( OutputDevice*, const Point&, const Size&, DrawFlags )
645 : {
646 0 : }
647 :
648 569 : void FixedLine::Resize()
649 : {
650 569 : Control::Resize();
651 569 : Invalidate();
652 569 : }
653 :
654 695 : void FixedLine::StateChanged( StateChangedType nType )
655 : {
656 695 : Control::StateChanged( nType );
657 :
658 695 : if ( (nType == StateChangedType::Enable) ||
659 565 : (nType == StateChangedType::Text) ||
660 : (nType == StateChangedType::UpdateMode) )
661 : {
662 260 : if ( IsReallyVisible() && IsUpdateMode() )
663 123 : Invalidate();
664 : }
665 565 : else if ( nType == StateChangedType::Style )
666 : {
667 0 : SetStyle( ImplInitStyle( GetStyle() ) );
668 0 : if ( (GetPrevStyle() & FIXEDLINE_VIEW_STYLE) !=
669 0 : (GetStyle() & FIXEDLINE_VIEW_STYLE) )
670 0 : Invalidate();
671 : }
672 565 : else if ( (nType == StateChangedType::Zoom) ||
673 565 : (nType == StateChangedType::Style) ||
674 : (nType == StateChangedType::ControlFont) )
675 : {
676 0 : ApplySettings(*this);
677 0 : Invalidate();
678 : }
679 565 : else if ( nType == StateChangedType::ControlForeground )
680 : {
681 0 : ApplySettings(*this);
682 0 : Invalidate();
683 : }
684 565 : else if ( nType == StateChangedType::ControlBackground )
685 : {
686 0 : ApplySettings(*this);
687 0 : Invalidate();
688 : }
689 695 : }
690 :
691 0 : void FixedLine::DataChanged( const DataChangedEvent& rDCEvt )
692 : {
693 0 : Control::DataChanged( rDCEvt );
694 :
695 0 : if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
696 0 : (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
697 0 : ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
698 0 : (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
699 : {
700 0 : ApplySettings(*this);
701 0 : Invalidate();
702 : }
703 0 : }
704 :
705 1 : Size FixedLine::GetOptimalSize() const
706 : {
707 1 : return CalcWindowSize( FixedText::CalcMinimumTextSize ( this, 0x7fffffff ) );
708 : }
709 :
710 0 : void FixedBitmap::ImplInit( vcl::Window* pParent, WinBits nStyle )
711 : {
712 0 : nStyle = ImplInitStyle( nStyle );
713 0 : Control::ImplInit( pParent, nStyle, NULL );
714 0 : ApplySettings(*this);
715 0 : }
716 :
717 0 : WinBits FixedBitmap::ImplInitStyle( WinBits nStyle )
718 : {
719 0 : if ( !(nStyle & WB_NOGROUP) )
720 0 : nStyle |= WB_GROUP;
721 0 : return nStyle;
722 : }
723 :
724 0 : FixedBitmap::FixedBitmap( vcl::Window* pParent, WinBits nStyle ) :
725 0 : Control( WINDOW_FIXEDBITMAP )
726 : {
727 0 : ImplInit( pParent, nStyle );
728 0 : }
729 :
730 0 : void FixedBitmap::ImplDraw( OutputDevice* pDev, DrawFlags /* nDrawFlags */,
731 : const Point& rPos, const Size& rSize )
732 : {
733 0 : Bitmap* pBitmap = &maBitmap;
734 :
735 : // do we have a Bitmap?
736 0 : if ( !(!(*pBitmap)) )
737 : {
738 0 : if ( GetStyle() & WB_SCALE )
739 0 : pDev->DrawBitmap( rPos, rSize, *pBitmap );
740 : else
741 : {
742 0 : Point aPos = ImplCalcPos( GetStyle(), rPos, pBitmap->GetSizePixel(), rSize );
743 0 : pDev->DrawBitmap( aPos, *pBitmap );
744 : }
745 : }
746 0 : }
747 :
748 0 : void FixedBitmap::ApplySettings(vcl::RenderContext& rRenderContext)
749 : {
750 0 : vcl::Window* pParent = GetParent();
751 0 : if (pParent->IsChildTransparentModeEnabled() && !IsControlBackground())
752 : {
753 0 : EnableChildTransparentMode(true);
754 0 : SetParentClipMode(ParentClipMode::NoClip);
755 0 : SetPaintTransparent(true);
756 0 : rRenderContext.SetBackground();
757 : }
758 : else
759 : {
760 0 : EnableChildTransparentMode(false);
761 0 : SetParentClipMode(ParentClipMode::NONE);
762 0 : SetPaintTransparent(false);
763 :
764 0 : if (IsControlBackground())
765 0 : rRenderContext.SetBackground(GetControlBackground());
766 : else
767 0 : rRenderContext.SetBackground(pParent->GetBackground());
768 : }
769 0 : }
770 :
771 0 : void FixedBitmap::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
772 : {
773 0 : ImplDraw(&rRenderContext, DrawFlags::NONE, Point(), GetOutputSizePixel());
774 0 : }
775 :
776 0 : void FixedBitmap::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
777 : DrawFlags nFlags )
778 : {
779 0 : Point aPos = pDev->LogicToPixel( rPos );
780 0 : Size aSize = pDev->LogicToPixel( rSize );
781 0 : Rectangle aRect( aPos, aSize );
782 :
783 0 : pDev->Push();
784 0 : pDev->SetMapMode();
785 :
786 : // Border
787 0 : if ( !(nFlags & DrawFlags::NoBorder) && (GetStyle() & WB_BORDER) )
788 : {
789 0 : DecorationView aDecoView( pDev );
790 0 : aRect = aDecoView.DrawFrame( aRect, DrawFrameStyle::DoubleIn );
791 : }
792 0 : pDev->IntersectClipRegion( aRect );
793 0 : ImplDraw( pDev, nFlags, aRect.TopLeft(), aRect.GetSize() );
794 :
795 0 : pDev->Pop();
796 0 : }
797 :
798 0 : void FixedBitmap::Resize()
799 : {
800 0 : Control::Resize();
801 0 : Invalidate();
802 0 : }
803 :
804 0 : void FixedBitmap::StateChanged( StateChangedType nType )
805 : {
806 0 : Control::StateChanged( nType );
807 :
808 0 : if ( (nType == StateChangedType::Data) ||
809 : (nType == StateChangedType::UpdateMode) )
810 : {
811 0 : if ( IsReallyVisible() && IsUpdateMode() )
812 0 : Invalidate();
813 : }
814 0 : else if ( nType == StateChangedType::Style )
815 : {
816 0 : SetStyle( ImplInitStyle( GetStyle() ) );
817 0 : if ( (GetPrevStyle() & FIXEDBITMAP_VIEW_STYLE) !=
818 0 : (GetStyle() & FIXEDBITMAP_VIEW_STYLE) )
819 0 : Invalidate();
820 : }
821 0 : else if ( nType == StateChangedType::ControlBackground )
822 : {
823 0 : ApplySettings(*this);
824 0 : Invalidate();
825 : }
826 0 : }
827 :
828 0 : void FixedBitmap::DataChanged( const DataChangedEvent& rDCEvt )
829 : {
830 0 : Control::DataChanged( rDCEvt );
831 :
832 0 : if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
833 0 : (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
834 : {
835 0 : ApplySettings(*this);
836 0 : Invalidate();
837 : }
838 0 : }
839 :
840 0 : void FixedBitmap::SetBitmap( const Bitmap& rBitmap )
841 : {
842 0 : maBitmap = rBitmap;
843 0 : CompatStateChanged( StateChangedType::Data );
844 0 : queue_resize();
845 0 : }
846 :
847 4866 : void FixedImage::ImplInit( vcl::Window* pParent, WinBits nStyle )
848 : {
849 4866 : nStyle = ImplInitStyle( nStyle );
850 4866 : mbInUserDraw = false;
851 4866 : Control::ImplInit( pParent, nStyle, NULL );
852 4866 : ApplySettings(*this);
853 4866 : }
854 :
855 4866 : WinBits FixedImage::ImplInitStyle( WinBits nStyle )
856 : {
857 4866 : if ( !(nStyle & WB_NOGROUP) )
858 4866 : nStyle |= WB_GROUP;
859 4866 : return nStyle;
860 : }
861 :
862 0 : void FixedImage::ImplLoadRes( const ResId& rResId )
863 : {
864 0 : Control::ImplLoadRes( rResId );
865 :
866 0 : sal_uLong nObjMask = ReadLongRes();
867 :
868 0 : if ( RSC_FIXEDIMAGE_IMAGE & nObjMask )
869 : {
870 0 : maImage = Image( ResId( static_cast<RSHEADER_TYPE*>(GetClassRes()), *rResId.GetResMgr() ) );
871 0 : IncrementRes( GetObjSizeRes( static_cast<RSHEADER_TYPE*>(GetClassRes()) ) );
872 : }
873 0 : }
874 :
875 4866 : FixedImage::FixedImage( vcl::Window* pParent, WinBits nStyle ) :
876 4866 : Control( WINDOW_FIXEDIMAGE )
877 : {
878 4866 : ImplInit( pParent, nStyle );
879 4866 : }
880 :
881 0 : FixedImage::FixedImage( vcl::Window* pParent, const ResId& rResId ) :
882 0 : Control( WINDOW_FIXEDIMAGE )
883 : {
884 0 : rResId.SetRT( RSC_FIXEDIMAGE );
885 0 : WinBits nStyle = ImplInitRes( rResId );
886 0 : ImplInit( pParent, nStyle );
887 0 : ImplLoadRes( rResId );
888 :
889 0 : if ( !(nStyle & WB_HIDE) )
890 0 : Show();
891 0 : }
892 :
893 0 : void FixedImage::ImplDraw( OutputDevice* pDev, DrawFlags nDrawFlags,
894 : const Point& rPos, const Size& rSize )
895 : {
896 0 : DrawImageFlags nStyle = DrawImageFlags::NONE;
897 0 : if ( !(nDrawFlags & DrawFlags::NoDisable) )
898 : {
899 0 : if ( !IsEnabled() )
900 0 : nStyle |= DrawImageFlags::Disable;
901 : }
902 :
903 0 : Image *pImage = &maImage;
904 :
905 : // do we have an image?
906 0 : if ( !(!(*pImage)) )
907 : {
908 0 : if ( GetStyle() & WB_SCALE )
909 0 : pDev->DrawImage( rPos, rSize, *pImage, nStyle );
910 : else
911 : {
912 0 : Point aPos = ImplCalcPos( GetStyle(), rPos, pImage->GetSizePixel(), rSize );
913 0 : pDev->DrawImage( aPos, *pImage, nStyle );
914 : }
915 : }
916 0 : }
917 :
918 5025 : void FixedImage::ApplySettings(vcl::RenderContext& rRenderContext)
919 : {
920 5025 : vcl::Window* pParent = GetParent();
921 5025 : if (pParent && pParent->IsChildTransparentModeEnabled() && !IsControlBackground())
922 : {
923 1861 : EnableChildTransparentMode(true);
924 1861 : SetParentClipMode(ParentClipMode::NoClip);
925 1861 : SetPaintTransparent(true);
926 1861 : rRenderContext.SetBackground();
927 : }
928 : else
929 : {
930 3164 : EnableChildTransparentMode(false);
931 3164 : SetParentClipMode(ParentClipMode::NONE);
932 3164 : SetPaintTransparent(false);
933 :
934 3164 : if (IsControlBackground())
935 0 : rRenderContext.SetBackground(GetControlBackground());
936 3164 : else if (pParent)
937 3164 : rRenderContext.SetBackground(pParent->GetBackground());
938 : }
939 5025 : }
940 :
941 :
942 0 : void FixedImage::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
943 : {
944 0 : ImplDraw(&rRenderContext, DrawFlags::NONE, Point(), GetOutputSizePixel());
945 0 : }
946 :
947 1690 : Size FixedImage::GetOptimalSize() const
948 : {
949 1690 : return maImage.GetSizePixel();
950 : }
951 :
952 0 : void FixedImage::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
953 : DrawFlags nFlags )
954 : {
955 0 : Point aPos = pDev->LogicToPixel( rPos );
956 0 : Size aSize = pDev->LogicToPixel( rSize );
957 0 : Rectangle aRect( aPos, aSize );
958 :
959 0 : pDev->Push();
960 0 : pDev->SetMapMode();
961 :
962 : // Border
963 0 : if ( !(nFlags & DrawFlags::NoBorder) && (GetStyle() & WB_BORDER) )
964 : {
965 0 : ImplDrawFrame( pDev, aRect );
966 : }
967 0 : pDev->IntersectClipRegion( aRect );
968 0 : ImplDraw( pDev, nFlags, aRect.TopLeft(), aRect.GetSize() );
969 :
970 0 : pDev->Pop();
971 0 : }
972 :
973 6544 : void FixedImage::Resize()
974 : {
975 6544 : Control::Resize();
976 6544 : Invalidate();
977 6544 : }
978 :
979 16942 : void FixedImage::StateChanged( StateChangedType nType )
980 : {
981 16942 : Control::StateChanged( nType );
982 :
983 16942 : if ( (nType == StateChangedType::Enable) ||
984 10704 : (nType == StateChangedType::Data) ||
985 : (nType == StateChangedType::UpdateMode) )
986 : {
987 12476 : if ( IsReallyVisible() && IsUpdateMode() )
988 1348 : Invalidate();
989 : }
990 10704 : else if ( nType == StateChangedType::Style )
991 : {
992 0 : SetStyle( ImplInitStyle( GetStyle() ) );
993 0 : if ( (GetPrevStyle() & FIXEDIMAGE_VIEW_STYLE) !=
994 0 : (GetStyle() & FIXEDIMAGE_VIEW_STYLE) )
995 0 : Invalidate();
996 : }
997 10704 : else if ( nType == StateChangedType::ControlBackground )
998 : {
999 0 : ApplySettings(*this);
1000 0 : Invalidate();
1001 : }
1002 16942 : }
1003 :
1004 160 : void FixedImage::DataChanged( const DataChangedEvent& rDCEvt )
1005 : {
1006 160 : Control::DataChanged( rDCEvt );
1007 :
1008 640 : if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
1009 640 : (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
1010 : {
1011 157 : ApplySettings(*this);
1012 157 : Invalidate();
1013 : }
1014 160 : }
1015 :
1016 4867 : void FixedImage::SetImage( const Image& rImage )
1017 : {
1018 4867 : if ( rImage != maImage )
1019 : {
1020 4856 : maImage = rImage;
1021 4856 : CompatStateChanged( StateChangedType::Data );
1022 4856 : queue_resize();
1023 : }
1024 4867 : }
1025 :
1026 0 : bool FixedImage::SetModeImage( const Image& rImage )
1027 : {
1028 0 : SetImage( rImage );
1029 0 : return true;
1030 : }
1031 :
1032 :
1033 1700 : Image FixedImage::loadThemeImage(const OString &rFileName)
1034 : {
1035 1700 : static ImplImageTreeSingletonRef aImageTree;
1036 : OUString sIconTheme =
1037 1700 : Application::GetSettings().GetStyleSettings().DetermineIconTheme();
1038 3400 : const OUString sFileName(OStringToOUString(rFileName, RTL_TEXTENCODING_UTF8));
1039 3400 : BitmapEx aBitmap;
1040 1700 : bool bSuccess = aImageTree->loadImage(sFileName, sIconTheme, aBitmap, true);
1041 : SAL_WARN_IF(!bSuccess, "vcl.layout", "Unable to load " << sFileName
1042 : << " from theme " << sIconTheme);
1043 3400 : return Image(aBitmap);
1044 : }
1045 :
1046 8479 : bool FixedImage::set_property(const OString &rKey, const OString &rValue)
1047 : {
1048 8479 : if (rKey == "pixbuf")
1049 : {
1050 1700 : SetImage(FixedImage::loadThemeImage(rValue));
1051 : }
1052 : else
1053 6779 : return Control::set_property(rKey, rValue);
1054 1700 : return true;
1055 801 : }
1056 :
1057 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
