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 <sfx2/dialoghelper.hxx>
21 : #include <sfx2/viewsh.hxx>
22 : #include <sfx2/printer.hxx>
23 : #include <vcl/builderfactory.hxx>
24 : #include <vcl/metric.hxx>
25 : #include <vcl/svapp.hxx>
26 : #include <vcl/settings.hxx>
27 : #include <unicode/uchar.h>
28 : #include <com/sun/star/uno/Reference.h>
29 : #include <com/sun/star/i18n/BreakIterator.hpp>
30 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
31 : #include <comphelper/processfactory.hxx>
32 :
33 : #include <com/sun/star/i18n/ScriptType.hpp>
34 :
35 : #include <vector>
36 : #include <deque>
37 : #include <svtools/colorcfg.hxx>
38 : #include <svtools/sampletext.hxx>
39 :
40 : #include <svx/fntctrl.hxx>
41 : #include <svx/dialogs.hrc>
42 : #include <svx/sdasitm.hxx>
43 :
44 : // Item set includes
45 : #include <svl/itemset.hxx>
46 : #include <svl/itempool.hxx>
47 : #include <svl/stritem.hxx>
48 : #include <svl/languageoptions.hxx>
49 :
50 : #include <editeng/colritem.hxx>
51 : #include <editeng/fontitem.hxx>
52 : #include <editeng/editids.hrc>
53 : #include <editeng/postitem.hxx>
54 : #include <editeng/udlnitem.hxx>
55 : #include <editeng/crossedoutitem.hxx>
56 : #include <editeng/contouritem.hxx>
57 : #include <editeng/wghtitem.hxx>
58 : #include <editeng/fhgtitem.hxx>
59 : #include <editeng/shdditem.hxx>
60 : #include <editeng/escapementitem.hxx>
61 : #include <editeng/wrlmitem.hxx>
62 : #include <editeng/cmapitem.hxx>
63 : #include <editeng/kernitem.hxx>
64 : #include <editeng/brushitem.hxx>
65 : #include <editeng/emphasismarkitem.hxx>
66 : #include <editeng/charreliefitem.hxx>
67 : #include <editeng/twolinesitem.hxx>
68 : #include <editeng/charscaleitem.hxx>
69 : #include <editeng/langitem.hxx>
70 :
71 : //TODO: remove this and calculate off the actual size of text, not
72 : //an arbitrary number of characters
73 : #define TEXT_WIDTH 80
74 : #define ISITEMSET rSet.GetItemState(nWhich)>=SfxItemState::DEFAULT
75 :
76 : using namespace ::com::sun::star::uno;
77 : using namespace ::com::sun::star::lang;
78 : using ::com::sun::star::i18n::XBreakIterator;
79 : using ::com::sun::star::i18n::BreakIterator;
80 :
81 :
82 : // small helper functions to set fonts
83 :
84 : namespace
85 : {
86 0 : void scaleFontWidth(vcl::Font& rFont, vcl::RenderContext& rRenderContext,long& n100PercentFont)
87 : {
88 0 : rFont.SetWidth(0);
89 0 : n100PercentFont = rRenderContext.GetFontMetric(rFont).GetWidth();
90 0 : }
91 :
92 0 : void initFont(vcl::Font& rFont)
93 : {
94 0 : rFont.SetTransparent(true);
95 0 : rFont.SetAlign(ALIGN_BASELINE);
96 0 : }
97 :
98 0 : void setFontSize(vcl::Font& rFont)
99 : {
100 0 : Size aSize(rFont.GetSize());
101 0 : aSize.Height() = (aSize.Height() * 3) / 5;
102 0 : aSize.Width() = (aSize.Width() * 3) / 5;
103 0 : rFont.SetSize(aSize);
104 0 : }
105 :
106 0 : void calcFontHeightAnyAscent(vcl::RenderContext& rRenderContext, const vcl::Font& rFont, long& nHeight, long& nAscent)
107 : {
108 0 : if (!nHeight)
109 : {
110 0 : rRenderContext.SetFont(rFont);
111 0 : FontMetric aMetric(rRenderContext.GetFontMetric());
112 0 : nHeight = aMetric.GetLineHeight();
113 0 : nAscent = aMetric.GetAscent();
114 : }
115 0 : }
116 :
117 0 : void setFont(const SvxFont& rNewFont, SvxFont& rImplFont)
118 : {
119 0 : rImplFont = rNewFont;
120 0 : rImplFont.SetTransparent(true);
121 0 : rImplFont.SetAlign(ALIGN_BASELINE);
122 0 : }
123 :
124 : } // end anonymous namespace
125 :
126 : class FontPrevWin_Impl
127 : {
128 : friend class SvxFontPrevWindow;
129 :
130 : SvxFont maFont;
131 : VclPtr<Printer> mpPrinter;
132 : bool mbDelPrinter;
133 :
134 : Reference <XBreakIterator> mxBreak;
135 : std::vector<sal_uIntPtr> maTextWidth;
136 : std::deque<sal_Int32> maScriptChg;
137 : std::vector<sal_uInt16> maScriptType;
138 : SvxFont maCJKFont;
139 : SvxFont maCTLFont;
140 : OUString maText;
141 : OUString maScriptText;
142 : Color* mpColor;
143 : Color* mpBackColor;
144 : long mnAscent;
145 : sal_Unicode mcStartBracket;
146 : sal_Unicode mcEndBracket;
147 :
148 : long mn100PercentFontWidth; // initial -1 -> not set yet
149 : long mn100PercentFontWidthCJK;
150 : long mn100PercentFontWidthCTL;
151 : sal_uInt16 mnFontWidthScale;
152 :
153 : bool mbSelection : 1;
154 : bool mbGetSelection : 1;
155 : bool mbUseResText : 1;
156 : bool mbPreviewBackgroundToCharacter : 1;
157 : bool mbTwoLines : 1;
158 : bool mbUseFontNameAsText : 1;
159 : bool mbTextInited : 1;
160 :
161 : bool m_bCJKEnabled;
162 : bool m_bCTLEnabled;
163 :
164 :
165 : public:
166 0 : inline FontPrevWin_Impl() :
167 : mpPrinter(nullptr),
168 : mbDelPrinter(false),
169 : mpColor(nullptr),
170 : mpBackColor(0),
171 : mnAscent(0),
172 : mcStartBracket(0),
173 : mcEndBracket(0),
174 : mnFontWidthScale(100),
175 : mbSelection(false),
176 : mbGetSelection(false),
177 : mbUseResText(false),
178 : mbPreviewBackgroundToCharacter(false),
179 : mbTwoLines(false),
180 : mbUseFontNameAsText(false),
181 0 : mbTextInited(false)
182 : {
183 0 : SvtLanguageOptions aLanguageOptions;
184 0 : m_bCJKEnabled = aLanguageOptions.IsAnyEnabled();
185 0 : m_bCTLEnabled = aLanguageOptions.IsCTLFontEnabled();
186 :
187 0 : Invalidate100PercentFontWidth();
188 0 : }
189 :
190 0 : inline ~FontPrevWin_Impl()
191 0 : {
192 0 : delete mpColor;
193 0 : delete mpBackColor;
194 0 : if (mbDelPrinter)
195 0 : mpPrinter.disposeAndClear();
196 0 : }
197 :
198 : void CheckScript();
199 : Size CalcTextSize(vcl::RenderContext& rRenderContext, OutputDevice* pPrinter, const SvxFont& rFont);
200 : void DrawPrev(vcl::RenderContext& rRenderContext, Printer* pPrinter, Point& rPt, const SvxFont& rFont);
201 :
202 : bool SetFontWidthScale(sal_uInt16 nScaleInPercent);
203 : inline void Invalidate100PercentFontWidth();
204 : inline bool Is100PercentFontWidthValid() const;
205 : void ScaleFontWidth(vcl::RenderContext& rRenderContext);
206 : // scales rNonCJKFont and aCJKFont depending on nFontWidthScale and
207 : // sets the 100%-Font-Widths
208 : };
209 :
210 0 : inline void FontPrevWin_Impl::Invalidate100PercentFontWidth()
211 : {
212 0 : mn100PercentFontWidth = mn100PercentFontWidthCJK = mn100PercentFontWidthCTL = -1;
213 0 : }
214 :
215 0 : inline bool FontPrevWin_Impl::Is100PercentFontWidthValid() const
216 : {
217 : DBG_ASSERT( ( mn100PercentFontWidth == -1 && mn100PercentFontWidthCJK == -1 ) ||
218 : ( mn100PercentFontWidth != -1 && mn100PercentFontWidthCJK != -1 ) ||
219 : ( mn100PercentFontWidth == -1 && mn100PercentFontWidthCTL == -1 ) ||
220 : ( mn100PercentFontWidth != -1 && mn100PercentFontWidthCTL != -1 ),
221 : "*FontPrevWin_Impl::Is100PercentFontWidthValid(): 100PercentFontWidth's not synchronous" );
222 0 : return mn100PercentFontWidth != -1;
223 : }
224 :
225 : /*
226 : * evalutates the scripttypes of the actual string.
227 : * Afterwards the positions of script change are notified in aScriptChg,
228 : * the scripttypes in aScriptType.
229 : * The aTextWidth array will be filled with zero.
230 : */
231 0 : void FontPrevWin_Impl::CheckScript()
232 : {
233 : assert(!maText.isEmpty()); // must have a preview text here!
234 0 : if (maText == maScriptText)
235 : {
236 0 : return; // already initialized
237 : }
238 :
239 0 : maScriptText = maText;
240 :
241 0 : maScriptChg.clear();
242 0 : maScriptType.clear();
243 0 : maTextWidth.clear();
244 :
245 0 : if (!mxBreak.is())
246 : {
247 0 : Reference<XComponentContext> xContext = ::comphelper::getProcessComponentContext();
248 0 : mxBreak = BreakIterator::create(xContext);
249 : }
250 :
251 0 : sal_uInt16 nScript = 0;
252 0 : sal_Int32 nChg = 0;
253 :
254 0 : while (nChg < maText.getLength())
255 : {
256 0 : nScript = mxBreak->getScriptType(maText, nChg);
257 0 : nChg = mxBreak->endOfScript(maText, nChg, nScript);
258 0 : if (nChg < maText.getLength() && nChg > 0 &&
259 : (css::i18n::ScriptType::WEAK ==
260 0 : mxBreak->getScriptType(maText, nChg - 1)))
261 : {
262 0 : int8_t nType = u_charType(maText[nChg]);
263 0 : if (nType == U_NON_SPACING_MARK || nType == U_ENCLOSING_MARK ||
264 : nType == U_COMBINING_SPACING_MARK)
265 : {
266 0 : maScriptChg.push_back(nChg - 1);
267 : }
268 : else
269 : {
270 0 : maScriptChg.push_back(nChg);
271 : }
272 : }
273 : else
274 : {
275 0 : maScriptChg.push_back(nChg);
276 : }
277 0 : maScriptType.push_back(nScript);
278 0 : maTextWidth.push_back(0);
279 : }
280 : }
281 :
282 : /*
283 : * Size FontPrevWin_Impl::CalcTextSize(..)
284 : * fills the aTextWidth array with the text width of every part
285 : * of the actual string without a script change inside.
286 : * For Latin parts the given rFont will be used,
287 : * for Asian parts the aCJKFont.
288 : * The returned size contains the whole string.
289 : * The member nAscent is calculated to the maximal ascent of all used fonts.
290 : */
291 :
292 0 : Size FontPrevWin_Impl::CalcTextSize(vcl::RenderContext& rRenderContext, OutputDevice* _pPrinter, const SvxFont& rInFont)
293 : {
294 : sal_uInt16 nScript;
295 0 : sal_uInt16 nIdx = 0;
296 0 : sal_Int32 nStart = 0;
297 : sal_Int32 nEnd;
298 0 : size_t nCnt = maScriptChg.size();
299 :
300 0 : if (nCnt)
301 : {
302 0 : nEnd = maScriptChg[nIdx];
303 0 : nScript = maScriptType[nIdx];
304 : }
305 : else
306 : {
307 0 : nEnd = maText.getLength();
308 0 : nScript = css::i18n::ScriptType::LATIN;
309 : }
310 0 : long nTxtWidth = 0;
311 0 : long nCJKHeight = 0;
312 0 : long nCTLHeight = 0;
313 0 : long nHeight = 0;
314 0 : mnAscent = 0;
315 0 : long nCJKAscent = 0;
316 0 : long nCTLAscent = 0;
317 :
318 : do
319 : {
320 : const SvxFont& rFont = (nScript == css::i18n::ScriptType::ASIAN) ?
321 : maCJKFont :
322 : ((nScript == css::i18n::ScriptType::COMPLEX) ?
323 : maCTLFont :
324 0 : rInFont);
325 0 : sal_uIntPtr nWidth = rFont.GetTextSize(_pPrinter, maText, nStart, nEnd - nStart).Width();
326 0 : if (nIdx >= maTextWidth.size())
327 0 : break;
328 :
329 0 : maTextWidth[nIdx++] = nWidth;
330 0 : nTxtWidth += nWidth;
331 :
332 0 : switch (nScript)
333 : {
334 : case css::i18n::ScriptType::ASIAN:
335 0 : calcFontHeightAnyAscent(rRenderContext, maCJKFont, nCJKHeight, nCJKAscent);
336 0 : break;
337 : case css::i18n::ScriptType::COMPLEX:
338 0 : calcFontHeightAnyAscent(rRenderContext, maCTLFont, nCTLHeight, nCTLAscent);
339 0 : break;
340 : default:
341 0 : calcFontHeightAnyAscent(rRenderContext, rFont, nHeight, mnAscent);
342 : }
343 :
344 0 : if (nEnd < maText.getLength() && nIdx < nCnt)
345 : {
346 0 : nStart = nEnd;
347 0 : nEnd = maScriptChg[nIdx];
348 0 : nScript = maScriptType[nIdx];
349 : }
350 : else
351 0 : break;
352 : }
353 : while(true);
354 :
355 0 : nHeight -= mnAscent;
356 0 : nCJKHeight -= nCJKAscent;
357 0 : nCTLHeight -= nCTLAscent;
358 :
359 0 : if (nHeight < nCJKHeight)
360 0 : nHeight = nCJKHeight;
361 :
362 0 : if (mnAscent < nCJKAscent)
363 0 : mnAscent = nCJKAscent;
364 :
365 0 : if (nHeight < nCTLHeight)
366 0 : nHeight = nCTLHeight;
367 :
368 0 : if (mnAscent < nCTLAscent)
369 0 : mnAscent = nCTLAscent;
370 :
371 0 : nHeight += mnAscent;
372 :
373 0 : Size aTxtSize(nTxtWidth, nHeight);
374 0 : return aTxtSize;
375 : }
376 :
377 : /*
378 : * void FontPrevWin_Impl::DrawPrev(..)
379 : * calls SvxFont::DrawPrev(..) for every part of the string without a script
380 : * change inside, for Asian parts the aCJKFont will be used, otherwise the
381 : * given rFont.
382 : */
383 :
384 0 : void FontPrevWin_Impl::DrawPrev(vcl::RenderContext& rRenderContext, Printer* _pPrinter, Point &rPt, const SvxFont& rInFont)
385 : {
386 0 : vcl::Font aOldFont = _pPrinter->GetFont();
387 : sal_uInt16 nScript;
388 0 : sal_uInt16 nIdx = 0;
389 0 : sal_Int32 nStart = 0;
390 : sal_Int32 nEnd;
391 0 : size_t nCnt = maScriptChg.size();
392 0 : if (nCnt)
393 : {
394 0 : nEnd = maScriptChg[nIdx];
395 0 : nScript = maScriptType[nIdx];
396 : }
397 : else
398 : {
399 0 : nEnd = maText.getLength();
400 0 : nScript = css::i18n::ScriptType::LATIN;
401 : }
402 : do
403 : {
404 : const SvxFont& rFont = (nScript == css::i18n::ScriptType::ASIAN)
405 : ? maCJKFont
406 : : ((nScript == css::i18n::ScriptType::COMPLEX)
407 : ? maCTLFont
408 0 : : rInFont);
409 0 : _pPrinter->SetFont(rFont);
410 :
411 0 : rFont.DrawPrev(&rRenderContext, _pPrinter, rPt, maText, nStart, nEnd - nStart);
412 :
413 0 : rPt.X() += maTextWidth[nIdx++];
414 0 : if (nEnd < maText.getLength() && nIdx < nCnt)
415 : {
416 0 : nStart = nEnd;
417 0 : nEnd = maScriptChg[nIdx];
418 0 : nScript = maScriptType[nIdx];
419 : }
420 : else
421 0 : break;
422 : }
423 : while(true);
424 0 : _pPrinter->SetFont(aOldFont);
425 0 : }
426 :
427 :
428 :
429 0 : bool FontPrevWin_Impl::SetFontWidthScale(sal_uInt16 nScale)
430 : {
431 0 : if (mnFontWidthScale != nScale)
432 : {
433 0 : mnFontWidthScale = nScale;
434 0 : return true;
435 : }
436 :
437 0 : return false;
438 : }
439 :
440 0 : void FontPrevWin_Impl::ScaleFontWidth(vcl::RenderContext& rOutDev)
441 : {
442 0 : if (!Is100PercentFontWidthValid())
443 : {
444 0 : scaleFontWidth(maFont, rOutDev, mn100PercentFontWidth);
445 0 : scaleFontWidth(maCJKFont, rOutDev, mn100PercentFontWidthCJK);
446 0 : scaleFontWidth(maCTLFont, rOutDev, mn100PercentFontWidthCTL);
447 : }
448 :
449 0 : maFont.SetWidth(mn100PercentFontWidth * mnFontWidthScale / 100);
450 0 : maCJKFont.SetWidth(mn100PercentFontWidthCJK * mnFontWidthScale / 100);
451 0 : maCTLFont.SetWidth(mn100PercentFontWidthCTL * mnFontWidthScale / 100);
452 0 : }
453 :
454 0 : void SvxFontPrevWindow::ResetSettings(bool bForeground, bool bBackground)
455 : {
456 0 : mbResetForeground = bForeground;
457 0 : mbResetBackground = bBackground;
458 0 : Invalidate();
459 0 : }
460 :
461 0 : void SvxFontPrevWindow::ApplySettings(vcl::RenderContext& rRenderContext)
462 : {
463 0 : const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
464 :
465 0 : if (mbResetForeground)
466 : {
467 0 : svtools::ColorConfig aColorConfig;
468 0 : Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor);
469 :
470 0 : if (IsControlForeground())
471 0 : aTextColor = GetControlForeground();
472 0 : rRenderContext.SetTextColor(aTextColor);
473 0 : mbResetForeground = false;
474 : }
475 :
476 0 : if (mbResetBackground)
477 : {
478 0 : if (IsControlBackground())
479 0 : rRenderContext.SetBackground(GetControlBackground());
480 : else
481 0 : rRenderContext.SetBackground(rStyleSettings.GetWindowColor());
482 0 : mbResetBackground = false;
483 : }
484 0 : }
485 :
486 0 : void SvxFontPrevWindow::Init()
487 : {
488 0 : pImpl.reset(new FontPrevWin_Impl);
489 0 : SfxViewShell* pSh = SfxViewShell::Current();
490 :
491 0 : if (pSh)
492 0 : pImpl->mpPrinter = pSh->GetPrinter();
493 :
494 0 : if (!pImpl->mpPrinter)
495 : {
496 0 : pImpl->mpPrinter = VclPtr<Printer>::Create();
497 0 : pImpl->mbDelPrinter = true;
498 : }
499 0 : SetMapMode(MapMode(MAP_TWIP));
500 0 : initFont(pImpl->maFont);
501 0 : initFont(pImpl->maCJKFont);
502 0 : initFont(pImpl->maCTLFont);
503 :
504 0 : ResetSettings(true, true);
505 :
506 0 : SetBorderStyle(WindowBorderStyle::MONO);
507 0 : }
508 :
509 0 : SvxFontPrevWindow::SvxFontPrevWindow(vcl::Window* pParent, const ResId& rId)
510 : : Window(pParent, rId)
511 : , mbResetForeground(true)
512 0 : , mbResetBackground(true)
513 : {
514 0 : Init();
515 0 : }
516 :
517 0 : SvxFontPrevWindow::SvxFontPrevWindow(vcl::Window* pParent, WinBits nStyle)
518 : : Window(pParent, nStyle)
519 : , mbResetForeground(true)
520 0 : , mbResetBackground(true)
521 : {
522 0 : Init();
523 0 : }
524 :
525 0 : VCL_BUILDER_DECL_FACTORY(SvxFontPrevWindow)
526 : {
527 0 : WinBits nWinStyle = 0;
528 0 : OString sBorder = VclBuilder::extractCustomProperty(rMap);
529 0 : if (!sBorder.isEmpty())
530 0 : nWinStyle |= WB_BORDER;
531 0 : rRet = VclPtr<SvxFontPrevWindow>::Create(pParent, nWinStyle);
532 0 : }
533 :
534 0 : SvxFontPrevWindow::~SvxFontPrevWindow()
535 : {
536 0 : disposeOnce();
537 0 : }
538 :
539 0 : void SvxFontPrevWindow::dispose()
540 : {
541 0 : pImpl.reset();
542 0 : vcl::Window::dispose();
543 0 : }
544 :
545 0 : SvxFont& SvxFontPrevWindow::GetCTLFont()
546 : {
547 0 : return pImpl->maCTLFont;
548 : }
549 :
550 0 : SvxFont& SvxFontPrevWindow::GetCJKFont()
551 : {
552 0 : return pImpl->maCJKFont;
553 : }
554 :
555 0 : void SvxFontPrevWindow::StateChanged( StateChangedType nType )
556 : {
557 0 : if (nType == StateChangedType::ControlForeground)
558 0 : ResetSettings(true, false);
559 0 : else if (nType == StateChangedType::ControlBackground)
560 0 : ResetSettings(false, true);
561 :
562 0 : Window::StateChanged(nType);
563 0 : Invalidate();
564 0 : }
565 :
566 0 : void SvxFontPrevWindow::DataChanged( const DataChangedEvent& rDCEvt )
567 : {
568 0 : if ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
569 0 : ResetSettings(true, true);
570 : else
571 0 : Window::DataChanged( rDCEvt );
572 0 : }
573 :
574 0 : SvxFont& SvxFontPrevWindow::GetFont()
575 : {
576 0 : pImpl->Invalidate100PercentFontWidth(); // because the user might change the size
577 0 : return pImpl->maFont;
578 : }
579 :
580 0 : const SvxFont& SvxFontPrevWindow::GetFont() const
581 : {
582 0 : return pImpl->maFont;
583 : }
584 :
585 0 : void SvxFontPrevWindow::SetPreviewText( const OUString& rString )
586 : {
587 0 : pImpl->maText = rString;
588 0 : pImpl->mbTextInited = true;
589 0 : }
590 :
591 0 : void SvxFontPrevWindow::SetFontNameAsPreviewText()
592 : {
593 0 : pImpl->mbUseFontNameAsText = true;
594 0 : }
595 :
596 0 : void SvxFontPrevWindow::SetFont( const SvxFont& rNormalOutFont, const SvxFont& rCJKOutFont, const SvxFont& rCTLFont )
597 : {
598 0 : setFont(rNormalOutFont, pImpl->maFont);
599 0 : setFont(rCJKOutFont, pImpl->maCJKFont);
600 0 : setFont(rCTLFont, pImpl->maCTLFont);
601 :
602 0 : pImpl->Invalidate100PercentFontWidth();
603 0 : Invalidate();
604 0 : }
605 :
606 0 : void SvxFontPrevWindow::SetColor(const Color &rColor)
607 : {
608 0 : delete pImpl->mpColor;
609 0 : pImpl->mpColor = new Color(rColor);
610 0 : Invalidate();
611 0 : }
612 :
613 0 : void SvxFontPrevWindow::ResetColor()
614 : {
615 0 : delete pImpl->mpColor;
616 0 : pImpl->mpColor = 0;
617 0 : Invalidate();
618 0 : }
619 :
620 0 : void SvxFontPrevWindow::SetBackColor(const Color &rColor)
621 : {
622 0 : delete pImpl->mpBackColor;
623 0 : pImpl->mpBackColor = new Color(rColor);
624 0 : Invalidate();
625 0 : }
626 :
627 0 : void SvxFontPrevWindow::UseResourceText(bool bUse)
628 : {
629 0 : pImpl->mbUseResText = bUse;
630 0 : }
631 :
632 0 : void SvxFontPrevWindow::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
633 : {
634 0 : ApplySettings(rRenderContext);
635 :
636 0 : Printer* pPrinter = pImpl->mpPrinter;
637 0 : const SvxFont& rFont = pImpl->maFont;
638 0 : const SvxFont& rCJKFont = pImpl->maCJKFont;
639 0 : const SvxFont& rCTLFont = pImpl->maCTLFont;
640 :
641 0 : if (!IsEnabled())
642 : {
643 0 : const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
644 0 : const Size aLogSize(rRenderContext.GetOutputSize());
645 :
646 0 : Rectangle aRect(Point(0, 0), aLogSize);
647 0 : rRenderContext.SetLineColor();
648 0 : rRenderContext.SetFillColor(rStyleSettings.GetWindowColor());
649 0 : rRenderContext.DrawRect(aRect);
650 : }
651 : else
652 : {
653 0 : if (pImpl->mbUseResText)
654 0 : pImpl->maText = GetText();
655 0 : else if (!pImpl->mbSelection && !pImpl->mbTextInited)
656 : {
657 : using namespace css::i18n::ScriptType;
658 :
659 0 : SfxViewShell* pSh = SfxViewShell::Current();
660 :
661 0 : if (pSh && !pImpl->mbGetSelection && !pImpl->mbUseFontNameAsText)
662 : {
663 0 : pImpl->maText = pSh->GetSelectionText();
664 0 : pImpl->mbGetSelection = true;
665 0 : pImpl->mbSelection = !pImpl->maText.isEmpty();
666 : }
667 :
668 0 : if (!pImpl->mbSelection || pImpl->mbUseFontNameAsText)
669 : {
670 : //If we're showing multiple sample texts, then they're all
671 : //sample texts. If only showing Latin, continue to use
672 : //the fontname as the preview
673 0 : if ((pImpl->m_bCJKEnabled) || (pImpl->m_bCTLEnabled))
674 0 : pImpl->maText = makeRepresentativeTextForFont(LATIN, rFont);
675 : else
676 0 : pImpl->maText = rFont.GetName();
677 :
678 0 : if (pImpl->m_bCJKEnabled)
679 : {
680 0 : if (!pImpl->maText.isEmpty())
681 0 : pImpl->maText += " ";
682 0 : pImpl->maText += makeRepresentativeTextForFont(ASIAN, rCJKFont);
683 :
684 : }
685 0 : if (pImpl->m_bCTLEnabled)
686 : {
687 0 : if (!pImpl->maText.isEmpty())
688 0 : pImpl->maText += " ";
689 0 : pImpl->maText += makeRepresentativeTextForFont(COMPLEX, rCTLFont);
690 : }
691 : }
692 :
693 0 : if (pImpl->maText.isEmpty())
694 0 : pImpl->maText = GetText();
695 :
696 0 : if (pImpl->maText.isEmpty())
697 : { // fdo#58427: still no text? let's try that one...
698 0 : pImpl->maText = makeRepresentativeTextForFont(LATIN, rFont);
699 : }
700 :
701 : // remove line feeds and carriage returns from string
702 0 : bool bNotEmpty = false;
703 0 : for (sal_Int32 i = 0; i < pImpl->maText.getLength(); ++i)
704 : {
705 0 : if (0xa == pImpl->maText[i] || 0xd == pImpl->maText[i])
706 0 : pImpl->maText = pImpl->maText.replaceAt(i, 1, " ");
707 : else
708 0 : bNotEmpty = true;
709 : }
710 0 : if (!bNotEmpty)
711 0 : pImpl->maText = GetText();
712 :
713 0 : if (pImpl->maText.getLength() > (TEXT_WIDTH - 1))
714 : {
715 0 : sal_Int32 nSpaceIdx = pImpl->maText.indexOf(" ", TEXT_WIDTH);
716 0 : if (nSpaceIdx != -1)
717 0 : pImpl->maText = pImpl->maText.copy(0, nSpaceIdx);
718 : }
719 : }
720 :
721 : // calculate text width scaling
722 0 : pImpl->ScaleFontWidth(rRenderContext);
723 :
724 0 : pImpl->CheckScript();
725 0 : Size aTxtSize = pImpl->CalcTextSize(rRenderContext, pPrinter, rFont);
726 :
727 0 : const Size aLogSize(rRenderContext.GetOutputSize());
728 :
729 0 : long nX = aLogSize.Width() / 2 - aTxtSize.Width() / 2;
730 0 : long nY = aLogSize.Height() / 2 - aTxtSize.Height() / 2;
731 :
732 0 : if (nY + pImpl->mnAscent > aLogSize.Height())
733 0 : nY = aLogSize.Height() - pImpl->mnAscent;
734 :
735 0 : if (pImpl->mpBackColor)
736 : {
737 0 : Rectangle aRect(Point(0, 0), aLogSize);
738 0 : Color aLineCol = rRenderContext.GetLineColor();
739 0 : Color aFillCol = rRenderContext.GetFillColor();
740 0 : rRenderContext.SetLineColor();
741 0 : rRenderContext.SetFillColor(*pImpl->mpBackColor);
742 0 : rRenderContext.DrawRect(aRect);
743 0 : rRenderContext.SetLineColor(aLineCol);
744 0 : rRenderContext.SetFillColor(aFillCol);
745 : }
746 0 : if (pImpl->mpColor)
747 : {
748 0 : Rectangle aRect(Point(nX, nY), aTxtSize);
749 0 : Color aLineCol = rRenderContext.GetLineColor();
750 0 : Color aFillCol = rRenderContext.GetFillColor();
751 0 : rRenderContext.SetLineColor();
752 0 : rRenderContext.SetFillColor(*pImpl->mpColor);
753 0 : rRenderContext.DrawRect(aRect);
754 0 : rRenderContext.SetLineColor(aLineCol);
755 0 : rRenderContext.SetFillColor(aFillCol);
756 : }
757 :
758 0 : long nStdAscent = pImpl->mnAscent;
759 0 : nY += nStdAscent;
760 :
761 0 : if (IsTwoLines())
762 : {
763 0 : SvxFont aSmallFont(rFont);
764 0 : Size aOldSize = pImpl->maCJKFont.GetSize();
765 0 : setFontSize(aSmallFont);
766 0 : setFontSize(pImpl->maCJKFont);
767 :
768 0 : long nStartBracketWidth = 0;
769 0 : long nEndBracketWidth = 0;
770 0 : long nTextWidth = 0;
771 0 : if (pImpl->mcStartBracket)
772 : {
773 0 : OUString sBracket(pImpl->mcStartBracket);
774 0 : nStartBracketWidth = rFont.GetTextSize(pPrinter, sBracket).Width();
775 : }
776 0 : if (pImpl->mcEndBracket)
777 : {
778 0 : OUString sBracket(pImpl->mcEndBracket);
779 0 : nEndBracketWidth = rFont.GetTextSize(pPrinter, sBracket).Width();
780 : }
781 0 : nTextWidth = pImpl->CalcTextSize(rRenderContext, pPrinter, aSmallFont).Width();
782 0 : long nResultWidth = nStartBracketWidth;
783 0 : nResultWidth += nEndBracketWidth;
784 0 : nResultWidth += nTextWidth;
785 :
786 0 : long _nX = (aLogSize.Width() - nResultWidth) / 2;
787 0 : rRenderContext.DrawLine(Point(0, nY), Point(_nX, nY));
788 0 : rRenderContext.DrawLine(Point(_nX + nResultWidth, nY), Point(aLogSize.Width(), nY));
789 :
790 0 : long nSmallAscent = pImpl->mnAscent;
791 0 : long nOffset = (nStdAscent - nSmallAscent) / 2;
792 :
793 0 : if (pImpl->mcStartBracket)
794 : {
795 0 : OUString sBracket(pImpl->mcStartBracket);
796 0 : rFont.DrawPrev(&rRenderContext, pPrinter, Point(_nX, nY - nOffset - 4), sBracket);
797 0 : _nX += nStartBracketWidth;
798 : }
799 :
800 0 : Point aTmpPoint1(_nX, nY - nSmallAscent - 2);
801 0 : Point aTmpPoint2(_nX, nY);
802 0 : pImpl->DrawPrev(rRenderContext, pPrinter, aTmpPoint1, aSmallFont);
803 0 : pImpl->DrawPrev(rRenderContext, pPrinter, aTmpPoint2, aSmallFont);
804 :
805 0 : _nX += nTextWidth;
806 0 : if (pImpl->mcEndBracket)
807 : {
808 0 : Point aTmpPoint( _nX + 1, nY - nOffset - 4);
809 0 : OUString sBracket(pImpl->mcEndBracket);
810 0 : rFont.DrawPrev(&rRenderContext, pPrinter, aTmpPoint, sBracket);
811 : }
812 0 : pImpl->maCJKFont.SetSize(aOldSize);
813 : }
814 : else
815 : {
816 :
817 0 : Color aLineCol = rRenderContext.GetLineColor();
818 :
819 0 : rRenderContext.SetLineColor(rFont.GetColor());
820 0 : rRenderContext.DrawLine(Point(0, nY), Point(nX, nY));
821 0 : rRenderContext.DrawLine(Point(nX + aTxtSize.Width(), nY), Point(aLogSize.Width(), nY));
822 0 : rRenderContext.SetLineColor(aLineCol);
823 :
824 0 : Point aTmpPoint(nX, nY);
825 0 : pImpl->DrawPrev(rRenderContext, pPrinter, aTmpPoint, rFont);
826 : }
827 : }
828 0 : }
829 :
830 0 : bool SvxFontPrevWindow::IsTwoLines() const
831 : {
832 0 : return pImpl->mbTwoLines;
833 : }
834 :
835 0 : void SvxFontPrevWindow::SetTwoLines(bool bSet)
836 : {
837 0 : pImpl->mbTwoLines = bSet;
838 0 : }
839 :
840 0 : void SvxFontPrevWindow::SetBrackets(sal_Unicode cStart, sal_Unicode cEnd)
841 : {
842 0 : pImpl->mcStartBracket = cStart;
843 0 : pImpl->mcEndBracket = cEnd;
844 0 : }
845 :
846 0 : void SvxFontPrevWindow::SetFontWidthScale( sal_uInt16 n )
847 : {
848 0 : if (pImpl->SetFontWidthScale(n))
849 0 : Invalidate();
850 0 : }
851 :
852 0 : void SvxFontPrevWindow::AutoCorrectFontColor()
853 : {
854 0 : Color aFontColor( GetTextColor() );
855 :
856 0 : if (COL_AUTO == pImpl->maFont.GetColor().GetColor())
857 0 : pImpl->maFont.SetColor(aFontColor);
858 :
859 0 : if (COL_AUTO == pImpl->maCJKFont.GetColor().GetColor())
860 0 : pImpl->maCJKFont.SetColor(aFontColor);
861 :
862 0 : if (COL_AUTO == pImpl->maCTLFont.GetColor().GetColor())
863 0 : pImpl->maCTLFont.SetColor(aFontColor);
864 0 : }
865 :
866 0 : static bool GetWhich (const SfxItemSet& rSet, sal_uInt16 nSlot, sal_uInt16& rWhich)
867 : {
868 0 : rWhich = rSet.GetPool()->GetWhich(nSlot, true);
869 0 : return rSet.GetItemState(rWhich) >= SfxItemState::DEFAULT;
870 : }
871 :
872 0 : static void SetPrevFont(const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont)
873 : {
874 : sal_uInt16 nWhich;
875 0 : if (GetWhich(rSet, nSlot, nWhich))
876 : {
877 0 : const SvxFontItem& rFontItem = static_cast<const SvxFontItem&>(rSet.Get(nWhich));
878 0 : rFont.SetFamily(rFontItem.GetFamily());
879 0 : rFont.SetName(rFontItem.GetFamilyName());
880 0 : rFont.SetPitch(rFontItem.GetPitch());
881 0 : rFont.SetCharSet(rFontItem.GetCharSet());
882 0 : rFont.SetStyleName(rFontItem.GetStyleName());
883 : }
884 0 : }
885 :
886 0 : static void SetPrevFontStyle( const SfxItemSet& rSet, sal_uInt16 nPosture, sal_uInt16 nWeight, SvxFont& rFont )
887 : {
888 : sal_uInt16 nWhich;
889 0 : if( GetWhich( rSet, nPosture, nWhich ) )
890 : {
891 0 : const SvxPostureItem& rItem = static_cast<const SvxPostureItem&>( rSet.Get( nWhich ) );
892 0 : rFont.SetItalic( ( FontItalic ) rItem.GetValue() != ITALIC_NONE ? ITALIC_NORMAL : ITALIC_NONE );
893 : }
894 :
895 0 : if( GetWhich( rSet, nWeight, nWhich ) )
896 : {
897 0 : const SvxWeightItem& rItem = static_cast<const SvxWeightItem&>( rSet.Get( nWhich ) );
898 0 : rFont.SetWeight( ( FontWeight ) rItem.GetValue() != WEIGHT_NORMAL ? WEIGHT_BOLD : WEIGHT_NORMAL );
899 : }
900 0 : }
901 :
902 0 : void SvxFontPrevWindow::SetFontSize( const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont )
903 : {
904 : sal_uInt16 nWhich;
905 : long nH;
906 0 : if (GetWhich(rSet, nSlot, nWhich))
907 : {
908 0 : nH = LogicToLogic(static_cast<const SvxFontHeightItem&>(rSet.Get(nWhich)).GetHeight(),
909 0 : (MapUnit) rSet.GetPool()->GetMetric(nWhich),
910 0 : MAP_TWIP);
911 : }
912 : else
913 0 : nH = 240;// as default 12pt
914 :
915 0 : rFont.SetSize(Size(0, nH));
916 0 : }
917 :
918 0 : void SvxFontPrevWindow::SetFontLang(const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont)
919 : {
920 : sal_uInt16 nWhich;
921 : LanguageType nLang;
922 0 : if( GetWhich( rSet, nSlot, nWhich ) )
923 0 : nLang = static_cast<const SvxLanguageItem&>(rSet.Get(nWhich)).GetLanguage();
924 : else
925 0 : nLang = LANGUAGE_NONE;
926 0 : rFont.SetLanguage(nLang);
927 0 : }
928 :
929 0 : static void SetPrevFontEscapement(SvxFont& rFont, sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc)
930 : {
931 0 : rFont.SetPropr(nProp);
932 0 : rFont.SetProprRel(nEscProp);
933 0 : rFont.SetEscapement(nEsc);
934 0 : }
935 :
936 0 : void SvxFontPrevWindow::SetFromItemSet(const SfxItemSet &rSet, bool bPreviewBackgroundToCharacter)
937 : {
938 : sal_uInt16 nWhich;
939 0 : SvxFont& rFont = GetFont();
940 0 : SvxFont& rCJKFont = GetCJKFont();
941 0 : SvxFont& rCTLFont = GetCTLFont();
942 :
943 : // Preview string
944 0 : if( GetWhich( rSet, SID_CHAR_DLG_PREVIEW_STRING, nWhich ) )
945 : {
946 0 : const SfxStringItem& rItem = static_cast<const SfxStringItem&>( rSet.Get( nWhich ) );
947 0 : OUString aString = rItem.GetValue();
948 0 : if( !aString.isEmpty() )
949 0 : SetPreviewText( aString );
950 : else
951 0 : SetFontNameAsPreviewText();
952 : }
953 :
954 : // Underline
955 : FontUnderline eUnderline;
956 0 : if( GetWhich( rSet, SID_ATTR_CHAR_UNDERLINE, nWhich ) )
957 : {
958 0 : const SvxUnderlineItem& rItem = static_cast<const SvxUnderlineItem&>( rSet.Get( nWhich ) );
959 0 : eUnderline = ( FontUnderline ) rItem.GetValue();
960 0 : SetTextLineColor( rItem.GetColor() );
961 : }
962 : else
963 0 : eUnderline = UNDERLINE_NONE;
964 :
965 0 : rFont.SetUnderline( eUnderline );
966 0 : rCJKFont.SetUnderline( eUnderline );
967 0 : rCTLFont.SetUnderline( eUnderline );
968 :
969 : // Overline
970 : FontUnderline eOverline;
971 0 : if( GetWhich( rSet, SID_ATTR_CHAR_OVERLINE, nWhich ) )
972 : {
973 0 : const SvxOverlineItem& rItem = static_cast<const SvxOverlineItem&>( rSet.Get( nWhich ) );
974 0 : eOverline = ( FontUnderline ) rItem.GetValue();
975 0 : SetOverlineColor( rItem.GetColor() );
976 : }
977 : else
978 0 : eOverline = UNDERLINE_NONE;
979 :
980 0 : rFont.SetOverline( eOverline );
981 0 : rCJKFont.SetOverline( eOverline );
982 0 : rCTLFont.SetOverline( eOverline );
983 :
984 : // Strikeout
985 : FontStrikeout eStrikeout;
986 0 : if( GetWhich( rSet, SID_ATTR_CHAR_STRIKEOUT, nWhich ) )
987 : {
988 0 : const SvxCrossedOutItem& rItem = static_cast<const SvxCrossedOutItem&>( rSet.Get( nWhich ) );
989 0 : eStrikeout = ( FontStrikeout ) rItem.GetValue();
990 : }
991 : else
992 0 : eStrikeout = STRIKEOUT_NONE;
993 :
994 0 : rFont.SetStrikeout( eStrikeout );
995 0 : rCJKFont.SetStrikeout( eStrikeout );
996 0 : rCTLFont.SetStrikeout( eStrikeout );
997 :
998 : // WordLineMode
999 0 : if( GetWhich( rSet, SID_ATTR_CHAR_WORDLINEMODE, nWhich ) )
1000 : {
1001 0 : const SvxWordLineModeItem& rItem = static_cast<const SvxWordLineModeItem&>( rSet.Get( nWhich ) );
1002 0 : rFont.SetWordLineMode( rItem.GetValue() );
1003 0 : rCJKFont.SetWordLineMode( rItem.GetValue() );
1004 0 : rCTLFont.SetWordLineMode( rItem.GetValue() );
1005 : }
1006 :
1007 : // Emphasis
1008 0 : if( GetWhich( rSet, SID_ATTR_CHAR_EMPHASISMARK, nWhich ) )
1009 : {
1010 0 : const SvxEmphasisMarkItem& rItem = static_cast<const SvxEmphasisMarkItem&>( rSet.Get( nWhich ) );
1011 0 : FontEmphasisMark eMark = rItem.GetEmphasisMark();
1012 0 : rFont.SetEmphasisMark( eMark );
1013 0 : rCJKFont.SetEmphasisMark( eMark );
1014 0 : rCTLFont.SetEmphasisMark( eMark );
1015 : }
1016 :
1017 : // Relief
1018 0 : if( GetWhich( rSet, SID_ATTR_CHAR_RELIEF, nWhich ) )
1019 : {
1020 0 : const SvxCharReliefItem& rItem = static_cast<const SvxCharReliefItem&>( rSet.Get( nWhich ) );
1021 0 : FontRelief eFontRelief = ( FontRelief ) rItem.GetValue();
1022 0 : rFont.SetRelief( eFontRelief );
1023 0 : rCJKFont.SetRelief( eFontRelief );
1024 0 : rCTLFont.SetRelief( eFontRelief );
1025 : }
1026 :
1027 : // Effects
1028 0 : if( GetWhich( rSet, SID_ATTR_CHAR_CASEMAP, nWhich ) )
1029 : {
1030 0 : const SvxCaseMapItem& rItem = static_cast<const SvxCaseMapItem&>( rSet.Get( nWhich ) );
1031 0 : SvxCaseMap eCaseMap = ( SvxCaseMap ) rItem.GetValue();
1032 0 : rFont.SetCaseMap( eCaseMap );
1033 0 : rCJKFont.SetCaseMap( eCaseMap );
1034 : // #i78474# small caps do not exist in CTL fonts
1035 0 : rCTLFont.SetCaseMap( eCaseMap == SVX_CASEMAP_KAPITAELCHEN ? SVX_CASEMAP_NOT_MAPPED : eCaseMap );
1036 : }
1037 :
1038 : // Outline
1039 0 : if( GetWhich( rSet, SID_ATTR_CHAR_CONTOUR, nWhich ) )
1040 : {
1041 0 : const SvxContourItem& rItem = static_cast<const SvxContourItem&>( rSet.Get( nWhich ) );
1042 0 : bool bOutline = rItem.GetValue();
1043 0 : rFont.SetOutline( bOutline );
1044 0 : rCJKFont.SetOutline( bOutline );
1045 0 : rCTLFont.SetOutline( bOutline );
1046 : }
1047 :
1048 : // Shadow
1049 0 : if( GetWhich( rSet, SID_ATTR_CHAR_SHADOWED, nWhich ) )
1050 : {
1051 0 : const SvxShadowedItem& rItem = static_cast<const SvxShadowedItem&>( rSet.Get( nWhich ) );
1052 0 : bool bShadow = rItem.GetValue();
1053 0 : rFont.SetShadow( bShadow );
1054 0 : rCJKFont.SetShadow( bShadow );
1055 0 : rCTLFont.SetShadow( bShadow );
1056 : }
1057 :
1058 : // Background
1059 : bool bTransparent;
1060 0 : if( GetWhich( rSet, bPreviewBackgroundToCharacter ? SID_ATTR_BRUSH : SID_ATTR_BRUSH_CHAR, nWhich ) )
1061 : {
1062 0 : const SvxBrushItem& rBrush = static_cast<const SvxBrushItem&>( rSet.Get( nWhich ) );
1063 0 : const Color& rColor = rBrush.GetColor();
1064 0 : bTransparent = rColor.GetTransparency() > 0;
1065 0 : rFont.SetFillColor( rColor );
1066 0 : rCJKFont.SetFillColor( rColor );
1067 0 : rCTLFont.SetFillColor( rColor );
1068 : }
1069 : else
1070 0 : bTransparent = TRUE;
1071 :
1072 0 : rFont.SetTransparent( bTransparent );
1073 0 : rCJKFont.SetTransparent( bTransparent );
1074 0 : rCTLFont.SetTransparent( bTransparent );
1075 :
1076 0 : Color aBackCol( COL_TRANSPARENT );
1077 0 : if( !bPreviewBackgroundToCharacter )
1078 : {
1079 0 : if( GetWhich( rSet, SID_ATTR_BRUSH, nWhich ) )
1080 : {
1081 0 : const SvxBrushItem& rBrush = static_cast<const SvxBrushItem&>( rSet.Get( nWhich ) );
1082 0 : if( GPOS_NONE == rBrush.GetGraphicPos() )
1083 0 : aBackCol = rBrush.GetColor();
1084 : }
1085 : }
1086 0 : SetBackColor( aBackCol );
1087 :
1088 : // Font
1089 0 : SetPrevFont( rSet, SID_ATTR_CHAR_FONT, rFont );
1090 0 : SetPrevFont( rSet, SID_ATTR_CHAR_CJK_FONT, rCJKFont );
1091 0 : SetPrevFont( rSet, SID_ATTR_CHAR_CTL_FONT, rCTLFont );
1092 :
1093 : // Style
1094 0 : SetPrevFontStyle( rSet, SID_ATTR_CHAR_POSTURE, SID_ATTR_CHAR_WEIGHT, rFont );
1095 0 : SetPrevFontStyle( rSet, SID_ATTR_CHAR_CJK_POSTURE, SID_ATTR_CHAR_CJK_WEIGHT, rCJKFont );
1096 0 : SetPrevFontStyle( rSet, SID_ATTR_CHAR_CTL_POSTURE, SID_ATTR_CHAR_CTL_WEIGHT, rCTLFont );
1097 :
1098 : // Size
1099 0 : SetFontSize( rSet, SID_ATTR_CHAR_FONTHEIGHT, rFont );
1100 0 : SetFontSize( rSet, SID_ATTR_CHAR_CJK_FONTHEIGHT, rCJKFont );
1101 0 : SetFontSize( rSet, SID_ATTR_CHAR_CTL_FONTHEIGHT, rCTLFont );
1102 :
1103 : // Language
1104 0 : SetFontLang( rSet, SID_ATTR_CHAR_LANGUAGE, rFont );
1105 0 : SetFontLang( rSet, SID_ATTR_CHAR_CJK_LANGUAGE, rCJKFont );
1106 0 : SetFontLang( rSet, SID_ATTR_CHAR_CTL_LANGUAGE, rCTLFont );
1107 :
1108 : // Color
1109 0 : if( GetWhich( rSet, SID_ATTR_CHAR_COLOR, nWhich ) )
1110 : {
1111 0 : const SvxColorItem& rItem = static_cast<const SvxColorItem&>( rSet.Get( nWhich ) );
1112 0 : Color aCol( rItem.GetValue() );
1113 0 : rFont.SetColor( aCol );
1114 :
1115 0 : rCJKFont.SetColor( aCol );
1116 0 : rCTLFont.SetColor( aCol );
1117 :
1118 0 : AutoCorrectFontColor(); // handle color COL_AUTO
1119 : }
1120 :
1121 : // Kerning
1122 0 : if( GetWhich( rSet, SID_ATTR_CHAR_KERNING, nWhich ) )
1123 : {
1124 0 : const SvxKerningItem& rItem = static_cast<const SvxKerningItem&>( rSet.Get( nWhich ) );
1125 : short nKern = ( short )
1126 0 : LogicToLogic( rItem.GetValue(), ( MapUnit ) rSet.GetPool()->GetMetric( nWhich ), MAP_TWIP );
1127 0 : rFont.SetFixKerning( nKern );
1128 0 : rCJKFont.SetFixKerning( nKern );
1129 0 : rCTLFont.SetFixKerning( nKern );
1130 : }
1131 :
1132 : // Escapement
1133 0 : const sal_uInt8 nProp = 100;
1134 : short nEsc;
1135 : sal_uInt8 nEscProp;
1136 0 : if( GetWhich( rSet, SID_ATTR_CHAR_ESCAPEMENT, nWhich ) )
1137 : {
1138 0 : const SvxEscapementItem& rItem = static_cast<const SvxEscapementItem&>( rSet.Get( nWhich ) );
1139 0 : nEsc = rItem.GetEsc();
1140 0 : nEscProp = rItem.GetProp();
1141 :
1142 0 : if( nEsc == DFLT_ESC_AUTO_SUPER )
1143 0 : nEsc = DFLT_ESC_SUPER;
1144 0 : else if( nEsc == DFLT_ESC_AUTO_SUB )
1145 0 : nEsc = DFLT_ESC_SUB;
1146 : }
1147 : else
1148 : {
1149 0 : nEsc = 0;
1150 0 : nEscProp = 100;
1151 : }
1152 0 : SetPrevFontEscapement( rFont, nProp, nEscProp, nEsc );
1153 0 : SetPrevFontEscapement( rCJKFont, nProp, nEscProp, nEsc );
1154 0 : SetPrevFontEscapement( rCTLFont, nProp, nEscProp, nEsc );
1155 :
1156 : // Font width scale
1157 0 : if( GetWhich( rSet, SID_ATTR_CHAR_SCALEWIDTH, nWhich ) )
1158 : {
1159 0 : const SvxCharScaleWidthItem&rItem = static_cast<const SvxCharScaleWidthItem&>( rSet.Get( nWhich ) );
1160 0 : SetFontWidthScale( rItem.GetValue() );
1161 : }
1162 :
1163 0 : Invalidate();
1164 0 : }
1165 :
1166 0 : void SvxFontPrevWindow::Init(const SfxItemSet& rSet)
1167 : {
1168 0 : SvxFont& rFont = GetFont();
1169 0 : SvxFont& rCJKFont = GetCJKFont();
1170 0 : SvxFont& rCTLFont = GetCTLFont();
1171 :
1172 0 : initFont(rFont);
1173 0 : initFont(rCJKFont);
1174 0 : initFont(rCTLFont);
1175 0 : ResetSettings(true, true);
1176 :
1177 : sal_uInt16 nWhich;
1178 0 : nWhich = rSet.GetPool()->GetWhich( SID_CHAR_DLG_PREVIEW_STRING );
1179 0 : if (ISITEMSET)
1180 : {
1181 0 : const SfxStringItem& rItem = static_cast<const SfxStringItem&>( rSet.Get( nWhich ) );
1182 0 : OUString aString = rItem.GetValue();
1183 0 : if( !aString.isEmpty() )
1184 0 : SetPreviewText( aString );
1185 : else
1186 0 : SetFontNameAsPreviewText();
1187 : }
1188 :
1189 : // Underline
1190 : FontUnderline eUnderline;
1191 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_UNDERLINE );
1192 0 : if( ISITEMSET )
1193 : {
1194 0 : const SvxUnderlineItem& rItem = static_cast<const SvxUnderlineItem&>( rSet.Get( nWhich ) );
1195 0 : eUnderline = ( FontUnderline ) rItem.GetValue();
1196 0 : SetTextLineColor( rItem.GetColor() );
1197 : }
1198 : else
1199 0 : eUnderline = UNDERLINE_NONE;
1200 :
1201 0 : rFont.SetUnderline( eUnderline );
1202 0 : rCJKFont.SetUnderline( eUnderline );
1203 0 : rCTLFont.SetUnderline( eUnderline );
1204 :
1205 : // Overline
1206 : FontUnderline eOverline;
1207 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_OVERLINE );
1208 0 : if( ISITEMSET )
1209 : {
1210 0 : const SvxOverlineItem& rItem = static_cast<const SvxOverlineItem&>( rSet.Get( nWhich ) );
1211 0 : eOverline = ( FontUnderline ) rItem.GetValue();
1212 0 : SetOverlineColor( rItem.GetColor() );
1213 : }
1214 : else
1215 0 : eOverline = UNDERLINE_NONE;
1216 :
1217 0 : rFont.SetOverline( eOverline );
1218 0 : rCJKFont.SetOverline( eOverline );
1219 0 : rCTLFont.SetOverline( eOverline );
1220 :
1221 : // Strikeout
1222 : FontStrikeout eStrikeout;
1223 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_STRIKEOUT );
1224 0 : if( ISITEMSET )
1225 : {
1226 0 : const SvxCrossedOutItem& rItem = static_cast<const SvxCrossedOutItem&>( rSet.Get( nWhich ) );
1227 0 : eStrikeout = ( FontStrikeout ) rItem.GetValue();
1228 : }
1229 : else
1230 0 : eStrikeout = STRIKEOUT_NONE;
1231 :
1232 0 : rFont.SetStrikeout( eStrikeout );
1233 0 : rCJKFont.SetStrikeout( eStrikeout );
1234 0 : rCTLFont.SetStrikeout( eStrikeout );
1235 :
1236 : // WordLineMode
1237 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_WORDLINEMODE );
1238 0 : if( ISITEMSET )
1239 : {
1240 0 : const SvxWordLineModeItem& rItem = static_cast<const SvxWordLineModeItem&>( rSet.Get( nWhich ) );
1241 0 : rFont.SetWordLineMode( rItem.GetValue() );
1242 0 : rCJKFont.SetWordLineMode( rItem.GetValue() );
1243 0 : rCTLFont.SetWordLineMode( rItem.GetValue() );
1244 : }
1245 :
1246 : // Emphasis
1247 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_EMPHASISMARK );
1248 0 : if( ISITEMSET )
1249 : {
1250 0 : const SvxEmphasisMarkItem& rItem = static_cast<const SvxEmphasisMarkItem&>( rSet.Get( nWhich ) );
1251 0 : FontEmphasisMark eMark = rItem.GetEmphasisMark();
1252 0 : rFont.SetEmphasisMark( eMark );
1253 0 : rCJKFont.SetEmphasisMark( eMark );
1254 0 : rCTLFont.SetEmphasisMark( eMark );
1255 : }
1256 :
1257 : // Relief
1258 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_RELIEF );
1259 0 : if( ISITEMSET )
1260 : {
1261 0 : const SvxCharReliefItem& rItem = static_cast<const SvxCharReliefItem&>( rSet.Get( nWhich ) );
1262 0 : FontRelief eFontRelief = ( FontRelief ) rItem.GetValue();
1263 0 : rFont.SetRelief( eFontRelief );
1264 0 : rCJKFont.SetRelief( eFontRelief );
1265 0 : rCTLFont.SetRelief( eFontRelief );
1266 : }
1267 :
1268 : // Effects
1269 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_CASEMAP );
1270 0 : if( ISITEMSET )
1271 : {
1272 0 : const SvxCaseMapItem& rItem = static_cast<const SvxCaseMapItem&>( rSet.Get( nWhich ) );
1273 0 : SvxCaseMap eCaseMap = ( SvxCaseMap ) rItem.GetValue();
1274 0 : rFont.SetCaseMap( eCaseMap );
1275 0 : rCJKFont.SetCaseMap( eCaseMap );
1276 : // #i78474# small caps do not exist in CTL fonts
1277 0 : rCTLFont.SetCaseMap( eCaseMap == SVX_CASEMAP_KAPITAELCHEN ? SVX_CASEMAP_NOT_MAPPED : eCaseMap );
1278 : }
1279 :
1280 : // Outline
1281 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_CONTOUR );
1282 0 : if( ISITEMSET )
1283 : {
1284 0 : const SvxContourItem& rItem = static_cast<const SvxContourItem&>( rSet.Get( nWhich ) );
1285 0 : bool bOutline = rItem.GetValue();
1286 0 : rFont.SetOutline( bOutline );
1287 0 : rCJKFont.SetOutline( bOutline );
1288 0 : rCTLFont.SetOutline( bOutline );
1289 : }
1290 :
1291 : // Shadow
1292 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_SHADOWED );
1293 0 : if( ISITEMSET )
1294 : {
1295 0 : const SvxShadowedItem& rItem = static_cast<const SvxShadowedItem&>( rSet.Get( nWhich ) );
1296 0 : bool bShadow = rItem.GetValue();
1297 0 : rFont.SetShadow( bShadow );
1298 0 : rCJKFont.SetShadow( bShadow );
1299 0 : rCTLFont.SetShadow( bShadow );
1300 : }
1301 :
1302 : // Background
1303 : bool bTransparent;
1304 0 : nWhich = rSet.GetPool()->GetWhich(pImpl->mbPreviewBackgroundToCharacter ? SID_ATTR_BRUSH : SID_ATTR_BRUSH_CHAR);
1305 0 : if (ISITEMSET)
1306 : {
1307 0 : const SvxBrushItem& rBrush = static_cast<const SvxBrushItem&>( rSet.Get( nWhich ) );
1308 0 : const Color& rColor = rBrush.GetColor();
1309 0 : bTransparent = rColor.GetTransparency() > 0;
1310 0 : rFont.SetFillColor(rColor);
1311 0 : rCJKFont.SetFillColor(rColor);
1312 0 : rCTLFont.SetFillColor(rColor);
1313 : }
1314 : else
1315 0 : bTransparent = true;
1316 :
1317 0 : rFont.SetTransparent( bTransparent );
1318 0 : rCJKFont.SetTransparent( bTransparent );
1319 0 : rCTLFont.SetTransparent( bTransparent );
1320 :
1321 0 : Color aBackCol( COL_TRANSPARENT );
1322 0 : if (!pImpl->mbPreviewBackgroundToCharacter)
1323 : {
1324 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_BRUSH );
1325 0 : if (ISITEMSET)
1326 : {
1327 0 : const SvxBrushItem& rBrush = static_cast<const SvxBrushItem&>(rSet.Get(nWhich));
1328 0 : if (GPOS_NONE == rBrush.GetGraphicPos())
1329 0 : aBackCol = rBrush.GetColor();
1330 : }
1331 : }
1332 0 : SetBackColor(aBackCol);
1333 :
1334 : // Font
1335 0 : SetFont(rSet, SID_ATTR_CHAR_FONT, rFont);
1336 0 : SetFont(rSet, SID_ATTR_CHAR_CJK_FONT, rCJKFont);
1337 0 : SetFont(rSet, SID_ATTR_CHAR_CTL_FONT, rCTLFont);
1338 :
1339 : // Style
1340 0 : SetFontStyle(rSet, SID_ATTR_CHAR_POSTURE, SID_ATTR_CHAR_WEIGHT, rFont);
1341 0 : SetFontStyle(rSet, SID_ATTR_CHAR_CJK_POSTURE, SID_ATTR_CHAR_CJK_WEIGHT, rCJKFont);
1342 0 : SetFontStyle(rSet, SID_ATTR_CHAR_CTL_POSTURE, SID_ATTR_CHAR_CTL_WEIGHT, rCTLFont);
1343 :
1344 : // Size
1345 0 : SetFontSize(rSet, SID_ATTR_CHAR_FONTHEIGHT, rFont);
1346 0 : SetFontSize(rSet, SID_ATTR_CHAR_CJK_FONTHEIGHT, rCJKFont);
1347 0 : SetFontSize(rSet, SID_ATTR_CHAR_CTL_FONTHEIGHT, rCTLFont);
1348 :
1349 : // Language
1350 0 : SetFontLang( rSet, SID_ATTR_CHAR_LANGUAGE, rFont );
1351 0 : SetFontLang( rSet, SID_ATTR_CHAR_CJK_LANGUAGE, rCJKFont );
1352 0 : SetFontLang( rSet, SID_ATTR_CHAR_CTL_LANGUAGE, rCTLFont );
1353 :
1354 : // Color
1355 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_COLOR );
1356 0 : if( ISITEMSET )
1357 : {
1358 0 : const SvxColorItem& rItem = static_cast<const SvxColorItem&>( rSet.Get( nWhich ) );
1359 0 : Color aCol( rItem.GetValue() );
1360 0 : rFont.SetColor( aCol );
1361 0 : rCJKFont.SetColor( aCol );
1362 0 : rCTLFont.SetColor( aCol );
1363 :
1364 0 : AutoCorrectFontColor(); // handle color COL_AUTO
1365 : }
1366 :
1367 : // Kerning
1368 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_KERNING );
1369 0 : if( ISITEMSET )
1370 : {
1371 0 : const SvxKerningItem& rItem = static_cast<const SvxKerningItem&>( rSet.Get( nWhich ) );
1372 : short nKern = ( short )
1373 0 : LogicToLogic( rItem.GetValue(), ( MapUnit ) rSet.GetPool()->GetMetric( nWhich ), MAP_TWIP );
1374 0 : rFont.SetFixKerning( nKern );
1375 0 : rCJKFont.SetFixKerning( nKern );
1376 0 : rCTLFont.SetFixKerning( nKern );
1377 : }
1378 :
1379 : // Escapement
1380 0 : nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_ESCAPEMENT );
1381 0 : const sal_uInt8 nProp = 100;
1382 : short nEsc;
1383 : sal_uInt8 nEscProp;
1384 0 : if( ISITEMSET )
1385 : {
1386 0 : const SvxEscapementItem& rItem = static_cast<const SvxEscapementItem&>( rSet.Get( nWhich ) );
1387 0 : nEsc = rItem.GetEsc();
1388 0 : nEscProp = rItem.GetProp();
1389 :
1390 0 : if( nEsc == DFLT_ESC_AUTO_SUPER )
1391 0 : nEsc = DFLT_ESC_SUPER;
1392 0 : else if( nEsc == DFLT_ESC_AUTO_SUB )
1393 0 : nEsc = DFLT_ESC_SUB;
1394 : }
1395 : else
1396 : {
1397 0 : nEsc = 0;
1398 0 : nEscProp = 100;
1399 : }
1400 :
1401 0 : SetFontEscapement( nProp, nEscProp, nEsc );
1402 :
1403 : // Font width scale
1404 0 : SetFontWidthScale( rSet );
1405 :
1406 0 : Invalidate();
1407 0 : }
1408 :
1409 0 : void SvxFontPrevWindow::SetFont( const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont )
1410 : {
1411 0 : sal_uInt16 nWhich = rSet.GetPool()->GetWhich( nSlot );
1412 0 : if( ISITEMSET )
1413 : {
1414 0 : const SvxFontItem& rFontItem = static_cast<const SvxFontItem&>( rSet.Get(nWhich) );
1415 0 : rFont.SetFamily( rFontItem.GetFamily() );
1416 0 : rFont.SetName( rFontItem.GetFamilyName() );
1417 0 : rFont.SetPitch( rFontItem.GetPitch() );
1418 0 : rFont.SetCharSet( rFontItem.GetCharSet() );
1419 0 : rFont.SetStyleName( rFontItem.GetStyleName() );
1420 : }
1421 0 : }
1422 :
1423 0 : void SvxFontPrevWindow::SetFontStyle( const SfxItemSet& rSet, sal_uInt16 nPosture, sal_uInt16 nWeight, SvxFont& rFont )
1424 : {
1425 0 : sal_uInt16 nWhich = rSet.GetPool()->GetWhich( nPosture );
1426 0 : if( ISITEMSET )
1427 : {
1428 0 : const SvxPostureItem& rItem = static_cast<const SvxPostureItem&>( rSet.Get( nWhich ) );
1429 0 : rFont.SetItalic( ( FontItalic ) rItem.GetValue() != ITALIC_NONE ? ITALIC_NORMAL : ITALIC_NONE );
1430 : }
1431 :
1432 0 : nWhich = rSet.GetPool()->GetWhich( nWeight );
1433 0 : if( ISITEMSET )
1434 : {
1435 0 : const SvxWeightItem& rItem = static_cast<const SvxWeightItem&>( rSet.Get( nWhich ) );
1436 0 : rFont.SetWeight( ( FontWeight ) rItem.GetValue() != WEIGHT_NORMAL ? WEIGHT_BOLD : WEIGHT_NORMAL );
1437 : }
1438 0 : }
1439 :
1440 0 : void SvxFontPrevWindow::SetFontWidthScale( const SfxItemSet& rSet )
1441 : {
1442 0 : sal_uInt16 nWhich = rSet.GetPool()->GetWhich( SID_ATTR_CHAR_SCALEWIDTH );
1443 0 : if( ISITEMSET )
1444 : {
1445 0 : const SvxCharScaleWidthItem& rItem = static_cast<const SvxCharScaleWidthItem&>( rSet.Get( nWhich ) );
1446 :
1447 0 : SetFontWidthScale( rItem.GetValue() );
1448 : }
1449 0 : }
1450 :
1451 : namespace
1452 : {
1453 0 : void setFontEscapement(SvxFont& rFont, sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc)
1454 : {
1455 0 : rFont.SetPropr(nProp);
1456 0 : rFont.SetProprRel(nEscProp);
1457 0 : rFont.SetEscapement(nEsc);
1458 0 : }
1459 : }
1460 :
1461 0 : void SvxFontPrevWindow::SetFontEscapement(sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc)
1462 : {
1463 0 : setFontEscapement(GetFont(), nProp, nEscProp, nEsc);
1464 0 : setFontEscapement(GetCJKFont(), nProp, nEscProp, nEsc);
1465 0 : setFontEscapement(GetCTLFont(), nProp, nEscProp, nEsc);
1466 0 : Invalidate();
1467 0 : }
1468 :
1469 0 : Size SvxFontPrevWindow::GetOptimalSize() const
1470 : {
1471 0 : return getPreviewStripSize(this);
1472 390 : }
1473 :
1474 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
