xref: /aoo41x/main/svtools/source/control/ctrlbox.cxx (revision 5900e8ec) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svtools.hxx"
26 
27 #define _CTRLBOX_CXX
28 #include <tools/debug.hxx>
29 #include <vcl/svapp.hxx>
30 #include <vcl/field.hxx>
31 #include <comphelper/processfactory.hxx>
32 #include <unotools/charclass.hxx>
33 
34 #include <svtools/svtdata.hxx>
35 #include <svtools/svtools.hrc>
36 #include <svtools/ctrlbox.hxx>
37 #include <svtools/ctrltool.hxx>
38 
39 #include <vcl/i18nhelp.hxx>
40 
41 #define IMGTEXTSPACE    2
42 #define EXTRAFONTSIZE   5
43 
44 static sal_Unicode aImplSymbolFontText[] = {0xF021,0xF032,0xF043,0xF054,0xF065,0xF076,0xF0B7,0xF0C8,0};
45 static sal_Unicode aImplStarSymbolText[] = {0x2706,0x2704,0x270D,0xE033,0x2211,0x2288,0};
46 
47 // ========================================================================
48 // ColorListBox
49 // ========================================================================
50 
51 // --------------------
52 // - ImplColorListData -
53 // --------------------
54 
55 struct ImplColorListData
56 {
57     Color       aColor;
58     sal_Bool        bColor;
59 
60                 ImplColorListData() : aColor( COL_BLACK ) { bColor = sal_False; }
61                 ImplColorListData( const Color& rColor ) : aColor( rColor ) { bColor = sal_True; }
62 };
63 
64 DECLARE_LIST( ImpColorList, ImplColorListData* )
65 
66 // -----------------------------------------------------------------------
67 
68 void ColorListBox::ImplInit()
69 {
70     pColorList = new ImpColorList( 256, 64 );
71     aImageSize.Width()  = GetTextWidth( XubString( RTL_CONSTASCII_USTRINGPARAM( "xxx" ) ) );
72     aImageSize.Height() = GetTextHeight();
73     aImageSize.Height() -= 2;
74 
75     EnableUserDraw( sal_True );
76     SetUserItemSize( aImageSize );
77 }
78 
79 // -----------------------------------------------------------------------
80 
81 void ColorListBox::ImplDestroyColorEntries()
82 {
83     for ( sal_uInt16 n = (sal_uInt16) pColorList->Count(); n; )
84     {
85         ImplColorListData* pData = pColorList->GetObject( --n );
86         delete pData;
87     }
88     pColorList->Clear();
89 }
90 
91 // -----------------------------------------------------------------------
92 
93 ColorListBox::ColorListBox( Window* pParent, WinBits nWinStyle ) :
94     ListBox( pParent, nWinStyle )
95 {
96     ImplInit();
97 }
98 
99 // -----------------------------------------------------------------------
100 
101 ColorListBox::ColorListBox( Window* pParent, const ResId& rResId ) :
102     ListBox( pParent, rResId )
103 {
104     ImplInit();
105 }
106 
107 // -----------------------------------------------------------------------
108 
109 ColorListBox::~ColorListBox()
110 {
111     ImplDestroyColorEntries();
112     delete pColorList;
113 }
114 
115 // -----------------------------------------------------------------------
116 
117 sal_uInt16 ColorListBox::InsertEntry( const XubString& rStr, sal_uInt16 nPos )
118 {
119     nPos = ListBox::InsertEntry( rStr, nPos );
120     if ( nPos != LISTBOX_ERROR )
121     {
122         ImplColorListData* pData = new ImplColorListData;
123         pColorList->Insert( pData, nPos );
124     }
125     return nPos;
126 }
127 
128 // -----------------------------------------------------------------------
129 
130 sal_uInt16 ColorListBox::InsertEntry( const Color& rColor, const XubString& rStr,
131                                 sal_uInt16 nPos )
132 {
133     nPos = ListBox::InsertEntry( rStr, nPos );
134     if ( nPos != LISTBOX_ERROR )
135     {
136         ImplColorListData* pData = new ImplColorListData( rColor );
137         pColorList->Insert( pData, nPos );
138     }
139     return nPos;
140 }
141 
142 // -----------------------------------------------------------------------
143 
144 void ColorListBox::InsertAutomaticEntry()
145 {
146     // insert the "Automatic"-entry always on the first position
147     InsertEntry( Color( COL_AUTO ), SvtResId( STR_SVT_AUTOMATIC_COLOR ), 0 );
148 }
149 
150 // -----------------------------------------------------------------------
151 
152 void ColorListBox::RemoveEntry( sal_uInt16 nPos )
153 {
154     ListBox::RemoveEntry( nPos );
155     delete pColorList->Remove( nPos );
156 }
157 
158 // -----------------------------------------------------------------------
159 
160 void ColorListBox::Clear()
161 {
162     ImplDestroyColorEntries();
163     ListBox::Clear();
164 }
165 
166 // -----------------------------------------------------------------------
167 
168 void ColorListBox::CopyEntries( const ColorListBox& rBox )
169 {
170     // Liste leeren
171     ImplDestroyColorEntries();
172 
173     // Daten kopieren
174     sal_uInt16 nCount = (sal_uInt16) rBox.pColorList->Count();
175     for ( sal_uInt16 n = 0; n < nCount; n++ )
176     {
177         ImplColorListData* pData = rBox.pColorList->GetObject( n );
178         sal_uInt16 nPos = InsertEntry( rBox.GetEntry( n ), LISTBOX_APPEND );
179         if ( nPos != LISTBOX_ERROR )
180             pColorList->Insert( new ImplColorListData( *pData ), nPos );
181     }
182 }
183 
184 // -----------------------------------------------------------------------
185 
186 sal_uInt16 ColorListBox::GetEntryPos( const Color& rColor ) const
187 {
188     for( sal_uInt16 n = (sal_uInt16) pColorList->Count(); n; )
189     {
190         ImplColorListData* pData = pColorList->GetObject( --n );
191         if ( pData->bColor && ( pData->aColor == rColor ) )
192             return n;
193     }
194     return LISTBOX_ENTRY_NOTFOUND;
195 }
196 
197 // -----------------------------------------------------------------------
198 
199 Color ColorListBox::GetEntryColor( sal_uInt16 nPos ) const
200 {
201     Color aColor;
202     ImplColorListData* pData = pColorList->GetObject( nPos );
203     if ( pData && pData->bColor )
204         aColor = pData->aColor;
205     return aColor;
206 }
207 
208 // -----------------------------------------------------------------------
209 
210 void ColorListBox::UserDraw( const UserDrawEvent& rUDEvt )
211 {
212     ImplColorListData* pData = pColorList->GetObject( rUDEvt.GetItemId() );
213     if ( pData )
214     {
215         if ( pData->bColor )
216         {
217             Point aPos( rUDEvt.GetRect().TopLeft() );
218             aPos.X() += 2;
219             aPos.Y() += ( rUDEvt.GetRect().GetHeight() - aImageSize.Height() ) / 2;
220             rUDEvt.GetDevice()->Push();
221             rUDEvt.GetDevice()->SetFillColor( pData->aColor );
222             rUDEvt.GetDevice()->SetLineColor( rUDEvt.GetDevice()->GetTextColor() );
223             rUDEvt.GetDevice()->DrawRect( Rectangle( aPos, aImageSize ) );
224             rUDEvt.GetDevice()->Pop();
225             ListBox::DrawEntry( rUDEvt, sal_False, sal_True, sal_False );
226         }
227         else
228             ListBox::DrawEntry( rUDEvt, sal_False, sal_True, sal_True );
229     }
230     else
231         ListBox::DrawEntry( rUDEvt, sal_True, sal_True, sal_False );
232 }
233 
234 // =======================================================================
235 // LineListBox
236 // =======================================================================
237 
238 // -------------------
239 // - ImpListListData -
240 // -------------------
241 
242 struct ImpLineListData
243 {
244     long    nLine1;
245     long    nLine2;
246     long    nDistance;
247 };
248 
249 DECLARE_LIST( ImpLineList, ImpLineListData* )
250 
251 // -----------------------------------------------------------------------
252 
253 inline const Color& LineListBox::GetPaintColor( void ) const
254 {
255 	return maPaintCol;
256 }
257 
258 // -----------------------------------------------------------------------
259 
260 void LineListBox::ImpGetLine( long nLine1, long nLine2, long nDistance,
261                             Bitmap& rBmp, XubString& rStr )
262 {
263     Size aSize = GetOutputSizePixel();
264     aSize.Width() -= 20;
265     aSize.Width() -= aTxtSize.Width();
266     aSize.Height() = aTxtSize.Height();
267 
268     // SourceUnit nach Twips
269     if ( eSourceUnit == FUNIT_POINT )
270     {
271         nLine1      *= 20;
272         nLine2      *= 20;
273         nDistance   *= 20;
274     }
275     else if ( eSourceUnit == FUNIT_MM )
276     {
277         nLine1      *= 14440;
278         nLine1      /= 254;
279         nLine2      *= 14440;
280         nLine2      /= 254;
281         nDistance   *= 14440;
282         nDistance   /= 254;
283     }
284 
285     // Linien malen
286     aSize = aVirDev.PixelToLogic( aSize );
287     long nPix = aVirDev.PixelToLogic( Size( 0, 1 ) ).Height();
288     long n1 = nLine1 / 100;
289     long n2 = nLine2 / 100;
290     long nDist  = nDistance / 100;
291     n1 += nPix-1;
292     n1 -= n1%nPix;
293     if ( n2 )
294     {
295         nDist += nPix-1;
296         nDist -= nDist%nPix;
297         n2    += nPix-1;
298         n2    -= n2%nPix;
299     }
300     long nVirHeight = n1+nDist+n2;
301     if ( nVirHeight > aSize.Height() )
302         aSize.Height() = nVirHeight;
303     // negative Breiten muss und darf man nicht painten
304     if ( aSize.Width() > 0 )
305     {
306         Size aVirSize = aVirDev.LogicToPixel( aSize );
307         if ( aVirDev.GetOutputSizePixel() != aVirSize )
308             aVirDev.SetOutputSizePixel( aVirSize );
309         aVirDev.SetFillColor( GetSettings().GetStyleSettings().GetFieldColor() );
310         aVirDev.DrawRect( Rectangle( Point(), aSize ) );
311 
312         aVirDev.SetFillColor( GetPaintColor() );
313         aVirDev.DrawRect( Rectangle( 0, 0, aSize.Width(), n1-nPix ) );
314         if ( n2 )
315         {
316             aVirDev.DrawRect( Rectangle( 0, n1+nDist,
317                                          aSize.Width(), n1+nDist+n2-nPix ) );
318         }
319         rBmp = aVirDev.GetBitmap( Point(), Size( aSize.Width(), n1+nDist+n2 ) );
320     }
321     // Twips nach Unit
322     if ( eUnit == FUNIT_POINT )
323     {
324         nLine1      /= 20;
325         nLine2      /= 20;
326         nDistance   /= 20;
327         rStr.AssignAscii( " pt" );
328     }
329     else if ( eUnit == FUNIT_MM )
330     {
331         nLine1      *= 254;
332         nLine1      /= 14400;
333         nLine2      *= 254;
334         nLine2      /= 14400;
335         nDistance   *= 254;
336         nDistance   /= 14400;
337         rStr.AssignAscii( " mm" );
338     }
339 
340     String aNum( GetSettings().GetLocaleI18nHelper().GetNum( nLine1+nLine2+nDistance, 2 ) );
341     rStr.Insert( aNum, 0 );
342 }
343 
344 // -----------------------------------------------------------------------
345 
346 void LineListBox::ImplInit()
347 {
348     aTxtSize.Width()  = GetTextWidth( XubString( RTL_CONSTASCII_USTRINGPARAM( "99,99 mm" ) ) );
349     aTxtSize.Height() = GetTextHeight();
350     pLineList   = new ImpLineList;
351     eUnit       = FUNIT_POINT;
352     eSourceUnit = FUNIT_POINT;
353 
354     aVirDev.SetLineColor();
355     aVirDev.SetMapMode( MapMode( MAP_TWIP ) );
356 
357 	UpdatePaintLineColor();
358 }
359 
360 // -----------------------------------------------------------------------
361 
362 LineListBox::LineListBox( Window* pParent, WinBits nWinStyle ) :
363     ListBox( pParent, nWinStyle ),
364     aColor( COL_BLACK ),
365 	maPaintCol( COL_BLACK )
366 {
367     ImplInit();
368 }
369 
370 // -----------------------------------------------------------------------
371 
372 LineListBox::LineListBox( Window* pParent, const ResId& rResId ) :
373     ListBox( pParent, rResId ),
374     aColor( COL_BLACK ),
375 	maPaintCol( COL_BLACK )
376 {
377     ImplInit();
378 }
379 
380 // -----------------------------------------------------------------------
381 
382 LineListBox::~LineListBox()
383 {
384     sal_uLong n = 0;
385     sal_uLong nCount = pLineList->Count();
386     while ( n < nCount )
387     {
388         ImpLineListData* pData = pLineList->GetObject( n );
389         if ( pData )
390             delete pData;
391         n++;
392     }
393     delete pLineList;
394 }
395 
396 // -----------------------------------------------------------------------
397 
398 sal_uInt16 LineListBox::InsertEntry( const XubString& rStr, sal_uInt16 nPos )
399 {
400     nPos = ListBox::InsertEntry( rStr, nPos );
401     if ( nPos != LISTBOX_ERROR )
402         pLineList->Insert( NULL, nPos );
403     return nPos;
404 }
405 
406 // -----------------------------------------------------------------------
407 
408 sal_uInt16 LineListBox::InsertEntry( long nLine1, long nLine2, long nDistance,
409                                 sal_uInt16 nPos )
410 {
411     XubString   aStr;
412     Bitmap      aBmp;
413     ImpGetLine( nLine1, nLine2, nDistance, aBmp, aStr );
414     nPos = ListBox::InsertEntry( aStr, aBmp, nPos );
415     if ( nPos != LISTBOX_ERROR )
416     {
417         ImpLineListData* pData = new ImpLineListData;
418         pData->nLine1    = nLine1;
419         pData->nLine2    = nLine2;
420         pData->nDistance = nDistance;
421         pLineList->Insert( pData, nPos );
422     }
423 
424     return nPos;
425 }
426 
427 // -----------------------------------------------------------------------
428 
429 void LineListBox::RemoveEntry( sal_uInt16 nPos )
430 {
431     ListBox::RemoveEntry( nPos );
432     ImpLineListData* pData = pLineList->Remove( nPos );
433     if ( pData )
434         delete pData;
435 }
436 
437 // -----------------------------------------------------------------------
438 
439 void LineListBox::Clear()
440 {
441     sal_uLong n = 0;
442     sal_uLong nCount = pLineList->Count();
443     while ( n < nCount )
444     {
445         ImpLineListData* pData = pLineList->GetObject( n );
446         if ( pData )
447             delete pData;
448         n++;
449     }
450 
451     pLineList->Clear();
452     ListBox::Clear();
453 }
454 
455 // -----------------------------------------------------------------------
456 
457 sal_uInt16 LineListBox::GetEntryPos( long nLine1, long nLine2,
458                                 long nDistance ) const
459 {
460     sal_uLong n = 0;
461     sal_uLong nCount = pLineList->Count();
462     while ( n < nCount )
463     {
464         ImpLineListData* pData = pLineList->GetObject( n );
465         if ( pData )
466         {
467             if ( (pData->nLine1    == nLine1) &&
468                 (pData->nLine2    == nLine2) &&
469                 (pData->nDistance == nDistance) )
470             return (sal_uInt16)n;
471         }
472 
473         n++;
474     }
475 
476     return LISTBOX_ENTRY_NOTFOUND;
477 }
478 
479 // -----------------------------------------------------------------------
480 
481 long LineListBox::GetEntryLine1( sal_uInt16 nPos ) const
482 {
483     ImpLineListData* pData = pLineList->GetObject( nPos );
484     if ( pData )
485         return pData->nLine1;
486     else
487         return 0;
488 }
489 
490 // -----------------------------------------------------------------------
491 
492 long LineListBox::GetEntryLine2( sal_uInt16 nPos ) const
493 {
494     ImpLineListData* pData = pLineList->GetObject( nPos );
495     if ( pData )
496         return pData->nLine2;
497     else
498         return 0;
499 }
500 
501 // -----------------------------------------------------------------------
502 
503 long LineListBox::GetEntryDistance( sal_uInt16 nPos ) const
504 {
505     ImpLineListData* pData = pLineList->GetObject( nPos );
506     if ( pData )
507         return pData->nDistance;
508     else
509         return 0;
510 }
511 
512 // -----------------------------------------------------------------------
513 
514 void LineListBox::UpdateLineColors( void )
515 {
516 	if( UpdatePaintLineColor() )
517 	{
518 		sal_uLong		nCount = pLineList->Count();
519 		if( !nCount )
520 			return;
521 
522 		XubString	aStr;
523 		Bitmap		aBmp;
524 
525 		// exchange entries which containing lines
526 		SetUpdateMode( sal_False );
527 
528 		sal_uInt16		nSelEntry = GetSelectEntryPos();
529 		for( sal_uLong n = 0 ; n < nCount ; ++n )
530 		{
531 			ImpLineListData*	pData = pLineList->GetObject( n );
532 			if( pData )
533 			{
534 				// exchange listbox data
535 				ListBox::RemoveEntry( sal_uInt16( n ) );
536 				ImpGetLine( pData->nLine1, pData->nLine2, pData->nDistance, aBmp, aStr );
537 				ListBox::InsertEntry( aStr, aBmp, sal_uInt16( n ) );
538 			}
539 		}
540 
541 		if( nSelEntry != LISTBOX_ENTRY_NOTFOUND )
542 			SelectEntryPos( nSelEntry );
543 
544 		SetUpdateMode( sal_True );
545 		Invalidate();
546 	}
547 }
548 
549 // -----------------------------------------------------------------------
550 
551 sal_Bool LineListBox::UpdatePaintLineColor( void )
552 {
553 	sal_Bool					bRet = sal_True;
554 	const StyleSettings&	rSettings = GetSettings().GetStyleSettings();
555 	Color					aNewCol( rSettings.GetWindowColor().IsDark()? rSettings.GetLabelTextColor() : aColor );
556 
557 	bRet = aNewCol != maPaintCol;
558 
559 	if( bRet )
560 		maPaintCol = aNewCol;
561 
562 	return bRet;
563 }
564 
565 // -----------------------------------------------------------------------
566 
567 void LineListBox::DataChanged( const DataChangedEvent& rDCEvt )
568 {
569 	ListBox::DataChanged( rDCEvt );
570 
571 	if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
572 		UpdateLineColors();
573 }
574 
575 // ===================================================================
576 // FontNameBox
577 // ===================================================================
578 
579 struct ImplFontNameListData
580 {
581     FontInfo    maInfo;
582     sal_uInt16      mnType;
583 
584                 ImplFontNameListData( const FontInfo& rInfo,
585                                     sal_uInt16 nType ) :
586                     maInfo( rInfo ),
587                     mnType( nType )
588                 {}
589 };
590 
591 DECLARE_LIST( ImplFontList, ImplFontNameListData* )
592 
593 // -------------------------------------------------------------------
594 
595 FontNameBox::FontNameBox( Window* pParent, WinBits nWinStyle ) :
596     ComboBox( pParent, nWinStyle )
597 {
598     InitBitmaps();
599     mpFontList = NULL;
600     mbWYSIWYG = sal_False;
601     mbSymbols = sal_False;
602 }
603 
604 // -------------------------------------------------------------------
605 
606 FontNameBox::FontNameBox( Window* pParent, const ResId& rResId ) :
607     ComboBox( pParent, rResId )
608 {
609     InitBitmaps();
610     mpFontList = NULL;
611     mbWYSIWYG = sal_False;
612     mbSymbols = sal_False;
613 }
614 
615 // -------------------------------------------------------------------
616 
617 FontNameBox::~FontNameBox()
618 {
619     ImplDestroyFontList();
620 }
621 
622 // -------------------------------------------------------------------
623 
624 void FontNameBox::DataChanged( const DataChangedEvent& rDCEvt )
625 {
626 	ComboBox::DataChanged( rDCEvt );
627 
628 	if( rDCEvt.GetType() == DATACHANGED_SETTINGS && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
629 		InitBitmaps();
630 }
631 
632 // -------------------------------------------------------------------
633 
634 void FontNameBox::InitBitmaps( void )
635 {
636 	sal_Bool bHC = GetSettings().GetStyleSettings().GetHighContrastMode();
637 
638 	maImagePrinterFont = Image( SvtResId( bHC? RID_IMG_PRINTERFONT_HC : RID_IMG_PRINTERFONT ) );
639 	maImageBitmapFont = Image( SvtResId( bHC? RID_IMG_BITMAPFONT_HC : RID_IMG_BITMAPFONT ) );
640 	maImageScalableFont = Image( SvtResId( bHC? RID_IMG_SCALABLEFONT_HC : RID_IMG_SCALABLEFONT ) );
641 }
642 
643 // -------------------------------------------------------------------
644 
645 void FontNameBox::ImplDestroyFontList()
646 {
647     if ( mpFontList )
648     {
649         ImplFontNameListData* pInfo = mpFontList->First();
650         while ( pInfo )
651         {
652             delete pInfo;
653             pInfo = mpFontList->Next();
654         }
655         delete mpFontList;
656     }
657 }
658 
659 // -------------------------------------------------------------------
660 
661 void FontNameBox::Fill( const FontList* pList )
662 {
663     // store old text and clear box
664     XubString aOldText = GetText();
665     Clear();
666 
667     ImplDestroyFontList();
668     mpFontList = new ImplFontList;
669 
670     // insert fonts
671     sal_uInt16 nFontCount = pList->GetFontNameCount();
672     for ( sal_uInt16 i = 0; i < nFontCount; i++ )
673     {
674         const FontInfo& rFontInfo = pList->GetFontName( i );
675         sal_uLong nIndex = InsertEntry( rFontInfo.GetName() );
676         if ( nIndex != LISTBOX_ERROR )
677         {
678             sal_uInt16 nType = pList->GetFontNameType( i );
679             ImplFontNameListData* pData = new ImplFontNameListData( rFontInfo, nType );
680             mpFontList->Insert( pData, nIndex );
681         }
682     }
683 
684     ImplCalcUserItemSize();
685 
686     // restore text
687     if ( aOldText.Len() )
688         SetText( aOldText );
689 }
690 
691 // -------------------------------------------------------------------
692 
693 void FontNameBox::EnableWYSIWYG( sal_Bool bEnable )
694 {
695     if ( bEnable != mbWYSIWYG )
696     {
697         mbWYSIWYG = bEnable;
698         EnableUserDraw( mbWYSIWYG | mbSymbols );
699         ImplCalcUserItemSize();
700     }
701 }
702 
703 // -------------------------------------------------------------------
704 
705 void FontNameBox::EnableSymbols( sal_Bool bEnable )
706 {
707     if ( bEnable != mbSymbols )
708     {
709         mbSymbols = bEnable;
710         EnableUserDraw( mbWYSIWYG | mbSymbols );
711         ImplCalcUserItemSize();
712     }
713 }
714 
715 // -------------------------------------------------------------------
716 
717 void FontNameBox::ImplCalcUserItemSize()
718 {
719     Size aUserItemSz;
720     if ( mbWYSIWYG && mpFontList )
721     {
722         sal_uInt16 nMaxLen = 0;
723         sal_Bool bSymbolFont = sal_False;
724         sal_Bool bStarSymbol = sal_False;
725         for ( sal_uInt16 n = GetEntryCount(); n; )
726         {
727             ImplFontNameListData* pData = mpFontList->GetObject( --n );
728             XubString aFontName = pData->maInfo.GetName();
729             if ( aFontName.Len() > nMaxLen )
730                 nMaxLen = aFontName.Len();
731             if ( pData->maInfo.GetCharSet() == RTL_TEXTENCODING_SYMBOL )
732                 bSymbolFont = sal_True;
733             // starsymbol is a unicode font, but gets WYSIWIG symbols
734             if( aFontName.EqualsIgnoreCaseAscii( "starsymbol" )
735             ||  aFontName.EqualsIgnoreCaseAscii( "opensymbol" ) )
736                 bSymbolFont = bStarSymbol = sal_True;
737         }
738 
739         // guess maximimum width
740         Size aOneCharSz( GetTextWidth( String( 'X' ) ), GetTextHeight() );
741         Size aSz( aOneCharSz );
742         aSz.Width() *= nMaxLen;
743         // only XX% of width, because ListBox calculates the normal width...
744         aSz.Width() *= 1;
745         aSz.Width() /= 10;
746         if ( bSymbolFont )
747         {
748             int nLength = sizeof(aImplSymbolFontText)/sizeof(aImplSymbolFontText[0]) - 1;
749             int nLength2 = sizeof(aImplStarSymbolText)/sizeof(aImplStarSymbolText[0]) - 1;
750             if( bStarSymbol && (nLength < nLength2) )
751                 nLength = nLength2;
752             aSz.Width() += aOneCharSz.Width() * nLength;
753         }
754         aSz.Height() *= 14;
755         aSz.Height() /= 10;
756         aUserItemSz = aSz;
757     }
758     if ( mbSymbols )
759     {
760         Size aSz = maImageScalableFont.GetSizePixel();
761         aUserItemSz.Width() += aSz.Width() + IMGTEXTSPACE;
762         if ( aSz.Height() > aUserItemSz.Height() )
763             aUserItemSz.Height() = aSz.Height();
764     }
765     SetUserItemSize( aUserItemSz );
766 }
767 
768 // -------------------------------------------------------------------
769 
770 void FontNameBox::UserDraw( const UserDrawEvent& rUDEvt )
771 {
772     ImplFontNameListData*   pData = mpFontList->GetObject( rUDEvt.GetItemId() );
773     const FontInfo&         rInfo = pData->maInfo;
774     sal_uInt16                  nType = pData->mnType;
775     Point                   aTopLeft = rUDEvt.GetRect().TopLeft();
776     long                    nX = aTopLeft.X();
777     long                    nH = rUDEvt.GetRect().GetHeight();
778 
779     if ( mbSymbols )
780     {
781         nX += IMGTEXTSPACE;
782         Image* pImg = NULL;
783         if ( (nType & (FONTLIST_FONTNAMETYPE_PRINTER | FONTLIST_FONTNAMETYPE_SCREEN)) == FONTLIST_FONTNAMETYPE_PRINTER )
784             pImg = &maImagePrinterFont;
785         else if ( nType & FONTLIST_FONTNAMETYPE_SCALABLE )
786             pImg = &maImageScalableFont;
787         else
788             pImg = &maImageBitmapFont;
789 
790         if ( pImg )
791         {
792             Point aPos( nX, aTopLeft.Y() + (nH-pImg->GetSizePixel().Height())/2 );
793             rUDEvt.GetDevice()->DrawImage( aPos, *pImg );
794         }
795 
796         // X immer um gleiche Breite aendern, auch wenn kein Image ausgegeben.
797         nX += maImagePrinterFont.GetSizePixel().Width();
798     }
799 
800     if ( mbWYSIWYG && mpFontList )
801     {
802         nX += IMGTEXTSPACE;
803 
804         bool bSymbolFont = (rInfo.GetCharSet() == RTL_TEXTENCODING_SYMBOL);
805         // starsymbol is a unicode font, but cannot display its own name
806         const bool bOpenSymbol = rInfo.GetName().EqualsIgnoreCaseAscii( "starsymbol" )
807                               || rInfo.GetName().EqualsIgnoreCaseAscii( "opensymbol" );
808         bSymbolFont |= bOpenSymbol;
809 
810         if( bSymbolFont )
811         {
812             String aText( rInfo.GetName() );
813             aText.AppendAscii( "  " );
814             Point aPos( nX, aTopLeft.Y() + (nH-rUDEvt.GetDevice()->GetTextHeight())/2 );
815             rUDEvt.GetDevice()->DrawText( aPos, aText );
816             nX += rUDEvt.GetDevice()->GetTextWidth( aText );
817         }
818 
819         Color aTextColor = rUDEvt.GetDevice()->GetTextColor();
820         Font aOldFont( rUDEvt.GetDevice()->GetFont() );
821         Size aSize( aOldFont.GetSize() );
822         aSize.Height() += EXTRAFONTSIZE;
823         Font aFont( rInfo );
824         aFont.SetSize( aSize );
825         rUDEvt.GetDevice()->SetFont( aFont );
826         rUDEvt.GetDevice()->SetTextColor( aTextColor );
827 
828         FontCharMap aFontCharMap;
829         bool bHasCharMap = rUDEvt.GetDevice()->GetFontCharMap( aFontCharMap );
830 
831         String aString;
832         if( !bSymbolFont )
833         {
834   	        // preview the font name
835             aString = rInfo.GetName();
836 
837             // reset font if the name cannot be display in the preview font
838             if( STRING_LEN != rUDEvt.GetDevice()->HasGlyphs( aFont, aString ) )
839                 rUDEvt.GetDevice()->SetFont( aOldFont );
840         }
841         else if( bHasCharMap )
842         {
843             // use some sample characters available in the font
844             sal_Unicode aText[8];
845 
846             // start just above the PUA used by most symbol fonts
847             sal_uInt32 cNewChar = 0xFF00;
848 #ifdef QUARTZ
849             // on MacOSX there are too many non-presentable symbols above the codepoint 0x0192
850             if( !bOpenSymbol )
851                 cNewChar = 0x0192;
852 #endif
853             const int nMaxCount = sizeof(aText)/sizeof(*aText) - 1;
854             int nSkip = aFontCharMap.GetCharCount() / nMaxCount;
855             if( nSkip > 10 )
856                 nSkip = 10;
857             else if( nSkip <= 0 )
858                 nSkip = 1;
859             for( int i = 0; i < nMaxCount; ++i )
860             {
861                 sal_uInt32 cOldChar = cNewChar;
862                 for( int j = nSkip; --j >= 0; )
863                     cNewChar = aFontCharMap.GetPrevChar( cNewChar );
864                 if( cOldChar == cNewChar )
865                     break;
866                 aText[ i ] = static_cast<sal_Unicode>(cNewChar); // TODO: support UCS4 samples
867                 aText[ i+1 ] = 0;
868             }
869 
870             aString = String( aText );
871         }
872         else
873         {
874             const sal_Unicode* pText = aImplSymbolFontText;
875             if( bOpenSymbol )
876                 pText = aImplStarSymbolText;
877 
878             aString = String( pText );
879         }
880 
881         long nTextHeight = rUDEvt.GetDevice()->GetTextHeight();
882         Point aPos( nX, aTopLeft.Y() + (nH-nTextHeight)/2 );
883         rUDEvt.GetDevice()->DrawText( aPos, aString );
884 
885         rUDEvt.GetDevice()->SetFont( aOldFont );
886         DrawEntry( rUDEvt, sal_False, sal_False);   // draw seperator
887     }
888     else
889     {
890         DrawEntry( rUDEvt, sal_True, sal_True );
891     }
892 }
893 
894 // ===================================================================
895 // FontStyleBox
896 // ===================================================================
897 
898 FontStyleBox::FontStyleBox( Window* pParent, WinBits nWinStyle ) :
899     ComboBox( pParent, nWinStyle )
900 {
901 }
902 
903 // -------------------------------------------------------------------
904 
905 FontStyleBox::FontStyleBox( Window* pParent, const ResId& rResId ) :
906     ComboBox( pParent, rResId )
907 {
908     aLastStyle = GetText();
909 }
910 
911 // -------------------------------------------------------------------
912 
913 FontStyleBox::~FontStyleBox()
914 {
915 }
916 
917 // -------------------------------------------------------------------
918 
919 void FontStyleBox::Select()
920 {
921     // keep text over fill operation
922     aLastStyle = GetText();
923     ComboBox::Select();
924 }
925 
926 // -------------------------------------------------------------------
927 
928 void FontStyleBox::LoseFocus()
929 {
930     // keep text over fill operation
931     aLastStyle = GetText();
932     ComboBox::LoseFocus();
933 }
934 
935 // -------------------------------------------------------------------
936 
937 void FontStyleBox::Modify()
938 {
939     CharClass   aChrCls( ::comphelper::getProcessServiceFactory(),
940                         GetSettings().GetLocale() );
941     XubString   aStr = GetText();
942     sal_uInt16      nEntryCount = GetEntryCount();
943 
944     if ( GetEntryPos( aStr ) == COMBOBOX_ENTRY_NOTFOUND )
945     {
946         aChrCls.toUpper( aStr );
947         for ( sal_uInt16 i = 0; i < nEntryCount; i++ )
948         {
949             XubString aEntryText = GetEntry( i );
950             aChrCls.toUpper( aEntryText );
951 
952             if ( aStr == aEntryText )
953             {
954                 SetText( GetEntry( i ) );
955                 break;
956             }
957         }
958     }
959 
960     ComboBox::Modify();
961 }
962 
963 // -------------------------------------------------------------------
964 
965 void FontStyleBox::Fill( const XubString& rName, const FontList* pList )
966 {
967     // note: this method must call ComboBox::SetText(),
968     //   else aLastStyle will overwritten
969     // store prior selection position and clear box
970     XubString aOldText = GetText();
971     sal_uInt16 nPos = GetEntryPos( aOldText );
972     Clear();
973 
974     // does a font with this name already exist?
975     sal_Handle hFontInfo = pList->GetFirstFontInfo( rName );
976     if ( hFontInfo )
977     {
978         XubString   aStyleText;
979         FontWeight  eLastWeight = WEIGHT_DONTKNOW;
980         FontItalic  eLastItalic = ITALIC_NONE;
981         FontWidth   eLastWidth = WIDTH_DONTKNOW;
982         sal_Bool        bNormal = sal_False;
983         sal_Bool        bItalic = sal_False;
984         sal_Bool        bBold = sal_False;
985         sal_Bool        bBoldItalic = sal_False;
986         sal_Bool        bInsert = sal_False;
987         FontInfo    aInfo;
988         while ( hFontInfo )
989         {
990             aInfo = pList->GetFontInfo( hFontInfo );
991 
992             FontWeight  eWeight = aInfo.GetWeight();
993             FontItalic  eItalic = aInfo.GetItalic();
994             FontWidth   eWidth = aInfo.GetWidthType();
995             // Only if the attributes are different, we insert the
996             // Font to avoid double Entries in different languages
997             if ( (eWeight != eLastWeight) || (eItalic != eLastItalic) ||
998                  (eWidth != eLastWidth) )
999             {
1000                 if ( bInsert )
1001                     InsertEntry( aStyleText );
1002 
1003                 if ( eWeight <= WEIGHT_NORMAL )
1004                 {
1005                     if ( eItalic != ITALIC_NONE )
1006                         bItalic = sal_True;
1007                     else
1008                         bNormal = sal_True;
1009                 }
1010                 else
1011                 {
1012                     if ( eItalic != ITALIC_NONE )
1013                         bBoldItalic = sal_True;
1014                     else
1015                         bBold = sal_True;
1016                 }
1017 
1018                 // For wrong StyleNames we replace this with the correct once
1019                 aStyleText = pList->GetStyleName( aInfo );
1020                 bInsert = GetEntryPos( aStyleText ) == LISTBOX_ENTRY_NOTFOUND;
1021                 if ( !bInsert )
1022                 {
1023                     aStyleText = pList->GetStyleName( eWeight, eItalic );
1024                     bInsert = GetEntryPos( aStyleText ) == LISTBOX_ENTRY_NOTFOUND;
1025                 }
1026 
1027                 eLastWeight = eWeight;
1028                 eLastItalic = eItalic;
1029                 eLastWidth = eWidth;
1030             }
1031             else
1032             {
1033                 if ( bInsert )
1034                 {
1035                     // If we have two names for the same attributes
1036                     // we prefer the translated standard names
1037                     const XubString& rAttrStyleText = pList->GetStyleName( eWeight, eItalic );
1038                     if ( rAttrStyleText != aStyleText )
1039                     {
1040                         XubString aTempStyleText = pList->GetStyleName( aInfo );
1041                         if ( rAttrStyleText == aTempStyleText )
1042                             aStyleText = rAttrStyleText;
1043                         bInsert = GetEntryPos( aStyleText ) == LISTBOX_ENTRY_NOTFOUND;
1044                     }
1045                 }
1046             }
1047 
1048             if ( !bItalic && (aStyleText == pList->GetItalicStr()) )
1049                 bItalic = sal_True;
1050             else if ( !bBold && (aStyleText == pList->GetBoldStr()) )
1051                 bBold = sal_True;
1052             else if ( !bBoldItalic && (aStyleText == pList->GetBoldItalicStr()) )
1053                 bBoldItalic = sal_True;
1054 
1055             hFontInfo = pList->GetNextFontInfo( hFontInfo );
1056         }
1057 
1058         if ( bInsert )
1059             InsertEntry( aStyleText );
1060 
1061         // Bestimmte Styles als Nachbildung
1062         if ( bNormal )
1063         {
1064             if ( !bItalic )
1065                 InsertEntry( pList->GetItalicStr() );
1066             if ( !bBold )
1067                 InsertEntry( pList->GetBoldStr() );
1068         }
1069         if ( !bBoldItalic )
1070         {
1071             if ( bNormal || bItalic || bBold )
1072                 InsertEntry( pList->GetBoldItalicStr() );
1073         }
1074         if ( aOldText.Len() )
1075         {
1076             if ( GetEntryPos( aLastStyle ) != LISTBOX_ENTRY_NOTFOUND )
1077                 ComboBox::SetText( aLastStyle );
1078             else
1079             {
1080                 if ( nPos >= GetEntryCount() )
1081                     ComboBox::SetText( GetEntry( 0 ) );
1082                 else
1083                     ComboBox::SetText( GetEntry( nPos ) );
1084             }
1085         }
1086     }
1087     else
1088     {
1089         // Wenn Font nicht, dann Standard-Styles einfuegen
1090         InsertEntry( pList->GetNormalStr() );
1091         InsertEntry( pList->GetItalicStr() );
1092         InsertEntry( pList->GetBoldStr() );
1093         InsertEntry( pList->GetBoldItalicStr() );
1094         if ( aOldText.Len() )
1095         {
1096             if ( nPos > GetEntryCount() )
1097                 ComboBox::SetText( GetEntry( 0 ) );
1098             else
1099                 ComboBox::SetText( GetEntry( nPos ) );
1100         }
1101     }
1102 }
1103 
1104 // ===================================================================
1105 // FontSizeBox
1106 // ===================================================================
1107 
1108 FontSizeBox::FontSizeBox( Window* pParent, WinBits nWinSize ) :
1109     MetricBox( pParent, nWinSize )
1110 {
1111     ImplInit();
1112 }
1113 
1114 // -----------------------------------------------------------------------
1115 
1116 FontSizeBox::FontSizeBox( Window* pParent, const ResId& rResId ) :
1117     MetricBox( pParent, rResId )
1118 {
1119     ImplInit();
1120 }
1121 
1122 // -----------------------------------------------------------------------
1123 
1124 FontSizeBox::~FontSizeBox()
1125 {
1126 }
1127 
1128 // -----------------------------------------------------------------------
1129 
1130 void FontSizeBox::ImplInit()
1131 {
1132     EnableAutocomplete( sal_False );
1133 
1134     bRelativeMode   = sal_False;
1135     bPtRelative     = sal_False;
1136     bRelative       = sal_False;
1137     bStdSize        = sal_False;
1138     pFontList       = NULL;
1139 
1140     SetShowTrailingZeros( sal_False );
1141     SetDecimalDigits( 1 );
1142     SetMin( 20 );
1143     SetMax( 9999 );
1144     SetProminentEntryType( PROMINENT_MIDDLE );
1145 }
1146 
1147 // -----------------------------------------------------------------------
1148 
1149 void FontSizeBox::Reformat()
1150 {
1151     FontSizeNames aFontSizeNames( GetSettings().GetUILanguage() );
1152     if ( !bRelativeMode || !aFontSizeNames.IsEmpty() )
1153     {
1154         long nNewValue = aFontSizeNames.Name2Size( GetText() );
1155         if ( nNewValue)
1156         {
1157             mnLastValue = nNewValue;
1158             return;
1159         }
1160     }
1161 
1162     MetricBox::Reformat();
1163 }
1164 
1165 // -----------------------------------------------------------------------
1166 
1167 void FontSizeBox::Modify()
1168 {
1169     MetricBox::Modify();
1170 
1171     if ( bRelativeMode )
1172     {
1173         XubString aStr = GetText();
1174         aStr.EraseLeadingChars();
1175 
1176         sal_Bool bNewMode = bRelative;
1177         sal_Bool bOldPtRelMode = bPtRelative;
1178 
1179         if ( bRelative )
1180         {
1181             bPtRelative = sal_False;
1182             const xub_Unicode* pStr = aStr.GetBuffer();
1183             while ( *pStr )
1184             {
1185                 if ( ((*pStr < '0') || (*pStr > '9')) && (*pStr != '%') )
1186                 {
1187                     if ( ('-' == *pStr || '+' == *pStr) && !bPtRelative )
1188                         bPtRelative = sal_True;
1189                     else if ( bPtRelative && 'p' == *pStr && 't' == *++pStr )
1190                         ;
1191                     else
1192                     {
1193                         bNewMode = sal_False;
1194                         break;
1195                     }
1196                 }
1197                 pStr++;
1198             }
1199         }
1200         else
1201         {
1202             if ( STRING_NOTFOUND != aStr.Search( '%' ) )
1203             {
1204                 bNewMode = sal_True;
1205                 bPtRelative = sal_False;
1206             }
1207 
1208             if ( '-' == aStr.GetChar( 0 ) || '+' == aStr.GetChar( 0 ) )
1209             {
1210                 bNewMode = sal_True;
1211                 bPtRelative = sal_True;
1212             }
1213         }
1214 
1215         if ( bNewMode != bRelative || bPtRelative != bOldPtRelMode )
1216             SetRelative( bNewMode );
1217     }
1218 }
1219 
1220 // -----------------------------------------------------------------------
1221 
1222 void FontSizeBox::Fill( const FontInfo* pInfo, const FontList* pList )
1223 {
1224     // remember for relative mode
1225     pFontList = pList;
1226 
1227     // no font sizes need to be set for relative mode
1228     if ( bRelative )
1229         return;
1230 
1231     // query font sizes
1232     const long* pTempAry;
1233     const long* pAry = 0;
1234 
1235 	if( pInfo )
1236 	{
1237 		aFontInfo = *pInfo;
1238 		pAry = pList->GetSizeAry( *pInfo );
1239 	}
1240 	else
1241 	{
1242 		pAry = pList->GetStdSizeAry();
1243 	}
1244 
1245     // first insert font size names (for simplified/traditional chinese)
1246     FontSizeNames aFontSizeNames( GetSettings().GetUILanguage() );
1247     if ( pAry == pList->GetStdSizeAry() )
1248     {
1249         // for standard sizes we don't need to bother
1250         if ( bStdSize && GetEntryCount() && aFontSizeNames.IsEmpty() )
1251             return;
1252         bStdSize = sal_True;
1253     }
1254     else
1255         bStdSize = sal_False;
1256 
1257     Selection aSelection = GetSelection();
1258     XubString aStr = GetText();
1259 
1260     Clear();
1261     sal_uInt16 nPos = 0;
1262 
1263     if ( !aFontSizeNames.IsEmpty() )
1264     {
1265         if ( pAry == pList->GetStdSizeAry() )
1266         {
1267             // for scalable fonts all font size names
1268             sal_uLong nCount = aFontSizeNames.Count();
1269             for( sal_uLong i = 0; i < nCount; i++ )
1270             {
1271                 String  aSizeName = aFontSizeNames.GetIndexName( i );
1272                 long    nSize = aFontSizeNames.GetIndexSize( i );
1273                 ComboBox::InsertEntry( aSizeName, nPos );
1274                 ComboBox::SetEntryData( nPos, (void*)(-nSize) ); // mark as special
1275                 nPos++;
1276             }
1277         }
1278         else
1279         {
1280             // for fixed size fonts only selectable font size names
1281             pTempAry = pAry;
1282             while ( *pTempAry )
1283             {
1284                 String aSizeName = aFontSizeNames.Size2Name( *pTempAry );
1285                 if ( aSizeName.Len() )
1286                 {
1287                     ComboBox::InsertEntry( aSizeName, nPos );
1288                     ComboBox::SetEntryData( nPos, (void*)(-(*pTempAry)) ); // mark as special
1289                     nPos++;
1290                 }
1291                 pTempAry++;
1292             }
1293         }
1294     }
1295 
1296     // then insert numerical font size values
1297     pTempAry = pAry;
1298     while ( *pTempAry )
1299     {
1300         InsertValue( *pTempAry, FUNIT_NONE, nPos );
1301         ComboBox::SetEntryData( nPos, (void*)(*pTempAry) );
1302         nPos++;
1303         pTempAry++;
1304     }
1305 
1306     SetText( aStr );
1307     SetSelection( aSelection );
1308 }
1309 
1310 // -----------------------------------------------------------------------
1311 
1312 void FontSizeBox::EnableRelativeMode( sal_uInt16 nMin, sal_uInt16 nMax, sal_uInt16 nStep )
1313 {
1314     bRelativeMode = sal_True;
1315     nRelMin       = nMin;
1316     nRelMax       = nMax;
1317     nRelStep      = nStep;
1318     SetUnit( FUNIT_POINT );
1319 }
1320 
1321 // -----------------------------------------------------------------------
1322 
1323 void FontSizeBox::EnablePtRelativeMode( short nMin, short nMax, short nStep )
1324 {
1325     bRelativeMode = sal_True;
1326     nPtRelMin     = nMin;
1327     nPtRelMax     = nMax;
1328     nPtRelStep    = nStep;
1329     SetUnit( FUNIT_POINT );
1330 }
1331 
1332 // -----------------------------------------------------------------------
1333 
1334 void FontSizeBox::SetRelative( sal_Bool bNewRelative )
1335 {
1336     if ( bRelativeMode )
1337     {
1338         Selection aSelection = GetSelection();
1339         XubString  aStr = GetText();
1340         aStr.EraseLeadingChars();
1341 
1342         if ( bNewRelative )
1343         {
1344             bRelative = sal_True;
1345             bStdSize = sal_False;
1346 
1347             if ( bPtRelative )
1348             {
1349                 SetDecimalDigits( 1 );
1350                 SetMin( nPtRelMin );
1351                 SetMax( nPtRelMax );
1352                 SetUnit( FUNIT_POINT );
1353 
1354                 Clear();
1355 
1356                 short i = nPtRelMin, n = 0;
1357                 // JP 30.06.98: more than 100 values are not useful
1358                 while ( i <= nPtRelMax && n++ < 100 )
1359                 {
1360                     InsertValue( i );
1361                     i = i + nPtRelStep;
1362                 }
1363             }
1364             else
1365             {
1366                 SetDecimalDigits( 0 );
1367                 SetMin( nRelMin );
1368                 SetMax( nRelMax );
1369                 SetCustomUnitText( '%' );
1370                 SetUnit( FUNIT_CUSTOM );
1371 
1372                 Clear();
1373                 sal_uInt16 i = nRelMin;
1374                 while ( i <= nRelMax )
1375                 {
1376                     InsertValue( i );
1377                     i = i + nRelStep;
1378                 }
1379             }
1380         }
1381         else
1382         {
1383             bRelative = bPtRelative = sal_False;
1384             SetDecimalDigits( 1 );
1385             SetMin( 20 );
1386             SetMax( 9999 );
1387             SetUnit( FUNIT_POINT );
1388             if ( pFontList )
1389                 Fill( &aFontInfo, pFontList );
1390         }
1391 
1392         SetText( aStr );
1393         SetSelection( aSelection );
1394     }
1395 }
1396 
1397 // -----------------------------------------------------------------------
1398 
1399 XubString FontSizeBox::CreateFieldText( sal_Int64 nValue ) const
1400 {
1401     XubString sRet( MetricBox::CreateFieldText( nValue ) );
1402     if ( bRelativeMode && bPtRelative && (0 <= nValue) && sRet.Len() )
1403         sRet.Insert( '+', 0 );
1404     return sRet;
1405 }
1406 
1407 // -----------------------------------------------------------------------
1408 
1409 void FontSizeBox::SetValue( sal_Int64 nNewValue, FieldUnit eInUnit )
1410 {
1411     if ( !bRelative )
1412     {
1413         sal_Int64 nTempValue = MetricField::ConvertValue( nNewValue, GetBaseValue(), GetDecimalDigits(), eInUnit, GetUnit() );
1414         FontSizeNames aFontSizeNames( GetSettings().GetUILanguage() );
1415         // conversion loses precision; however font sizes should
1416         // never have a problem with that
1417         String aName = aFontSizeNames.Size2Name( static_cast<long>(nTempValue) );
1418         if ( aName.Len() && (GetEntryPos( aName ) != LISTBOX_ENTRY_NOTFOUND) )
1419         {
1420             mnLastValue = nTempValue;
1421             SetText( aName );
1422             mnFieldValue = mnLastValue;
1423             SetEmptyFieldValueData( sal_False );
1424 			return;
1425         }
1426     }
1427 
1428     MetricBox::SetValue( nNewValue, eInUnit );
1429 }
1430 
1431 // -----------------------------------------------------------------------
1432 
1433 void FontSizeBox::SetValue( sal_Int64 nNewValue )
1434 {
1435     SetValue( nNewValue, FUNIT_NONE );
1436 }
1437 
1438 // -----------------------------------------------------------------------
1439 
1440 sal_Int64 FontSizeBox::GetValue( sal_uInt16 nPos, FieldUnit eOutUnit ) const
1441 {
1442     if ( !bRelative )
1443     {
1444         sal_Int64 nComboVal = static_cast<sal_Int64>(reinterpret_cast<long>(ComboBox::GetEntryData( nPos )));
1445         if ( nComboVal < 0 )     // marked as special?
1446         {
1447             return MetricField::ConvertValue( -nComboVal, mnBaseValue, GetDecimalDigits(),
1448                                               meUnit, eOutUnit );
1449         }
1450     }
1451 
1452     // do normal font size processing
1453     sal_Int64 nRetValue = MetricBox::GetValue( nPos, eOutUnit );
1454     return nRetValue;
1455 }
1456 
1457 // -----------------------------------------------------------------------
1458 
1459 sal_Int64 FontSizeBox::GetValue( FieldUnit eOutUnit ) const
1460 {
1461     if ( !bRelative )
1462     {
1463         FontSizeNames aFontSizeNames( GetSettings().GetUILanguage() );
1464         sal_Int64 nValue = aFontSizeNames.Name2Size( GetText() );
1465         if ( nValue)
1466             return MetricField::ConvertValue( nValue, GetBaseValue(), GetDecimalDigits(), GetUnit(), eOutUnit );
1467     }
1468 
1469     return MetricBox::GetValue( eOutUnit );
1470 }
1471 
1472 // -----------------------------------------------------------------------
1473 
1474 sal_Int64 FontSizeBox::GetValue() const
1475 {
1476     // implementation not inline, because it is a virtual function
1477     return GetValue( FUNIT_NONE );
1478 }
1479 
1480 // -----------------------------------------------------------------------
1481 
1482 void FontSizeBox::SetUserValue( sal_Int64 nNewValue, FieldUnit eInUnit )
1483 {
1484     if ( !bRelative )
1485     {
1486         sal_Int64 nTempValue = MetricField::ConvertValue( nNewValue, GetBaseValue(), GetDecimalDigits(), eInUnit, GetUnit() );
1487         FontSizeNames aFontSizeNames( GetSettings().GetUILanguage() );
1488         // conversion loses precision
1489         // however font sizes should never have a problem with that
1490         String aName = aFontSizeNames.Size2Name( static_cast<long>(nTempValue) );
1491         if ( aName.Len() && (GetEntryPos( aName ) != LISTBOX_ENTRY_NOTFOUND) )
1492         {
1493             mnLastValue = nTempValue;
1494             SetText( aName );
1495             return;
1496         }
1497     }
1498 
1499     MetricBox::SetUserValue( nNewValue, eInUnit );
1500 }
1501 
1502