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