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