forms/source/component/formcontrolfont.cxx

   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 <formcontrolfont.hxx>
  21 #include <frm_strings.hxx>
  22 #include <property.hxx>
  23 #include <cppuhelper/propshlp.hxx>
  24 #include <comphelper/property.hxx>
  25 #include <comphelper/types.hxx>
  26 #include <tools/color.hxx>
  27 #include <sal/log.hxx>
  28 #include <toolkit/helper/emptyfontdescriptor.hxx>
  29 #include <com/sun/star/awt/FontRelief.hpp>
  30 #include <com/sun/star/awt/FontEmphasisMark.hpp>
  31 #include <com/sun/star/beans/PropertyAttribute.hpp>
  32
  33
  34 namespace frm
  35 {
  36
  37
  38     using namespace ::comphelper;
  39     using namespace ::com::sun::star::uno;
  40     using namespace ::com::sun::star::awt;
  41     using namespace ::com::sun::star::lang;
  42     using namespace ::com::sun::star::beans;
  43
  44
  45     namespace
  46     {
  47         Any lcl_extractFontDescriptorAggregate( sal_Int32 _nHandle, const FontDescriptor& _rFont )
  48         {
  49             Any aValue;
  50             switch ( _nHandle )
  51             {
  52             case PROPERTY_ID_FONT_NAME:
  53                 aValue <<= _rFont.Name;
  54                 break;
  55
  56             case PROPERTY_ID_FONT_STYLENAME:
  57                 aValue <<= _rFont.StyleName;
  58                 break;
  59
  60             case PROPERTY_ID_FONT_FAMILY:
  61                 aValue <<= _rFont.Family;
  62                 break;
  63
  64             case PROPERTY_ID_FONT_CHARSET:
  65                 aValue <<= _rFont.CharSet;
  66                 break;
  67
  68             case PROPERTY_ID_FONT_CHARWIDTH:
  69                 aValue <<= _rFont.CharacterWidth;
  70                 break;
  71
  72             case PROPERTY_ID_FONT_KERNING:
  73                 aValue <<= _rFont.Kerning;
  74                 break;
  75
  76             case PROPERTY_ID_FONT_ORIENTATION:
  77                 aValue <<= _rFont.Orientation;
  78                 break;
  79
  80             case PROPERTY_ID_FONT_PITCH:
  81                 aValue <<= _rFont.Pitch;
  82                 break;
  83
  84             case PROPERTY_ID_FONT_TYPE:
  85                 aValue <<= _rFont.Type;
  86                 break;
  87
  88             case PROPERTY_ID_FONT_WIDTH:
  89                 aValue <<= _rFont.Width;
  90                 break;
  91
  92             case PROPERTY_ID_FONT_HEIGHT:
  93                 aValue <<= static_cast<float>( _rFont.Height );
  94                 break;
  95
  96             case PROPERTY_ID_FONT_WEIGHT:
  97                 aValue <<= _rFont.Weight;
  98                 break;
  99
 100             case PROPERTY_ID_FONT_SLANT:
 101                 aValue <<= _rFont.Slant;
 102                 break;
 103
 104             case PROPERTY_ID_FONT_UNDERLINE:
 105                 aValue <<= _rFont.Underline;
 106                 break;
 107
 108             case PROPERTY_ID_FONT_STRIKEOUT:
 109                 aValue <<= _rFont.Strikeout;
 110                 break;
 111
 112             case PROPERTY_ID_FONT_WORDLINEMODE:
 113                 aValue <<= _rFont.WordLineMode;
 114                 break;
 115
 116             default:
 117                 OSL_FAIL( "lcl_extractFontDescriptorAggregate: invalid handle!" );
 118                 break;
 119             }
 120             return aValue;
 121         }
 122     }
 123
 124     FontControlModel::FontControlModel( bool _bToolkitCompatibleDefaults )
 125         :m_nFontRelief( css::awt::FontRelief::NONE )
 126         ,m_nFontEmphasis( css::awt::FontEmphasisMark::NONE )
 127         ,m_bToolkitCompatibleDefaults( _bToolkitCompatibleDefaults )
 128     {
 129     }
 130
 131
 132     FontControlModel::FontControlModel( const FontControlModel* _pOriginal )
 133     {
 134         m_aFont = _pOriginal->m_aFont;
 135         m_nFontRelief = _pOriginal->m_nFontRelief;
 136         m_nFontEmphasis = _pOriginal->m_nFontEmphasis;
 137         m_aTextLineColor = _pOriginal->m_aTextLineColor;
 138         m_aTextColor = _pOriginal->m_aTextColor;
 139         m_bToolkitCompatibleDefaults = _pOriginal->m_bToolkitCompatibleDefaults;
 140     }
 141
 142
 143     bool FontControlModel::isFontRelatedProperty( sal_Int32 _nPropertyHandle )
 144     {
 145         return isFontAggregateProperty( _nPropertyHandle )
 146             || ( _nPropertyHandle == PROPERTY_ID_FONT )
 147             || ( _nPropertyHandle == PROPERTY_ID_FONTEMPHASISMARK )
 148             || ( _nPropertyHandle == PROPERTY_ID_FONTRELIEF )
 149             || ( _nPropertyHandle == PROPERTY_ID_TEXTLINECOLOR )
 150             || ( _nPropertyHandle == PROPERTY_ID_TEXTCOLOR );
 151     }
 152
 153
 154     bool FontControlModel::isFontAggregateProperty( sal_Int32 _nPropertyHandle )
 155     {
 156         return ( _nPropertyHandle == PROPERTY_ID_FONT_CHARWIDTH )
 157             || ( _nPropertyHandle == PROPERTY_ID_FONT_ORIENTATION )
 158             || ( _nPropertyHandle == PROPERTY_ID_FONT_WIDTH )
 159             || ( _nPropertyHandle == PROPERTY_ID_FONT_NAME )
 160             || ( _nPropertyHandle == PROPERTY_ID_FONT_STYLENAME )
 161             || ( _nPropertyHandle == PROPERTY_ID_FONT_FAMILY )
 162             || ( _nPropertyHandle == PROPERTY_ID_FONT_CHARSET )
 163             || ( _nPropertyHandle == PROPERTY_ID_FONT_HEIGHT )
 164             || ( _nPropertyHandle == PROPERTY_ID_FONT_WEIGHT )
 165             || ( _nPropertyHandle == PROPERTY_ID_FONT_SLANT )
 166             || ( _nPropertyHandle == PROPERTY_ID_FONT_UNDERLINE )
 167             || ( _nPropertyHandle == PROPERTY_ID_FONT_STRIKEOUT )
 168             || ( _nPropertyHandle == PROPERTY_ID_FONT_WORDLINEMODE )
 169             || ( _nPropertyHandle == PROPERTY_ID_FONT_PITCH )
 170             || ( _nPropertyHandle == PROPERTY_ID_FONT_KERNING )
 171             || ( _nPropertyHandle == PROPERTY_ID_FONT_TYPE );
 172     }
 173
 174
 175     Color FontControlModel::getTextColor( ) const
 176     {
 177         Color nColor = COL_TRANSPARENT;
 178         m_aTextColor >>= nColor;
 179         return nColor;
 180     }
 181
 182
 183     Color FontControlModel::getTextLineColor( ) const
 184     {
 185         Color nColor = COL_TRANSPARENT;
 186         m_aTextLineColor >>= nColor;
 187         return nColor;
 188     }
 189
 190
 191     void FontControlModel::describeFontRelatedProperties( Sequence< Property >& /* [out] */ _rProps)
 192     {
 193         sal_Int32 nPos = _rProps.getLength();
 194         _rProps.realloc( nPos + 21 );
 195         Property* pProperties = _rProps.getArray();
 196
 197         *pProperties++ = css::beans::Property(PROPERTY_FONT, PROPERTY_ID_FONT, cppu::UnoType<FontDescriptor>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEDEFAULT);
 198         *pProperties++ = css::beans::Property(PROPERTY_FONTEMPHASISMARK, PROPERTY_ID_FONTEMPHASISMARK, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEDEFAULT);
 199         *pProperties++ = css::beans::Property(PROPERTY_FONTRELIEF, PROPERTY_ID_FONTRELIEF, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEDEFAULT);
 200         *pProperties++ = css::beans::Property(PROPERTY_TEXTCOLOR, PROPERTY_ID_TEXTCOLOR, cppu::UnoType<sal_Int32>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEDEFAULT | css::beans::PropertyAttribute::MAYBEVOID);
 201         *pProperties++ = css::beans::Property(PROPERTY_TEXTLINECOLOR, PROPERTY_ID_TEXTLINECOLOR, cppu::UnoType<sal_Int32>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEDEFAULT | css::beans::PropertyAttribute::MAYBEVOID);
 202
 203         *pProperties++ = css::beans::Property(PROPERTY_FONT_CHARWIDTH, PROPERTY_ID_FONT_CHARWIDTH, cppu::UnoType<float>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 204         *pProperties++ = css::beans::Property(PROPERTY_FONT_KERNING, PROPERTY_ID_FONT_KERNING, cppu::UnoType<bool>::get(),
 205                                               css::beans::PropertyAttribute::MAYBEDEFAULT);
 206         *pProperties++ = css::beans::Property(PROPERTY_FONT_ORIENTATION, PROPERTY_ID_FONT_ORIENTATION, cppu::UnoType<float>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 207         *pProperties++ = css::beans::Property(PROPERTY_FONT_PITCH, PROPERTY_ID_FONT_PITCH, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 208         *pProperties++ = css::beans::Property(PROPERTY_FONT_TYPE, PROPERTY_ID_FONT_TYPE, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 209         *pProperties++ = css::beans::Property(PROPERTY_FONT_WIDTH, PROPERTY_ID_FONT_WIDTH, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 210         *pProperties++ = css::beans::Property(PROPERTY_FONT_NAME, PROPERTY_ID_FONT_NAME, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 211         *pProperties++ = css::beans::Property(PROPERTY_FONT_STYLENAME, PROPERTY_ID_FONT_STYLENAME, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 212         *pProperties++ = css::beans::Property(PROPERTY_FONT_FAMILY, PROPERTY_ID_FONT_FAMILY, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 213         *pProperties++ = css::beans::Property(PROPERTY_FONT_CHARSET, PROPERTY_ID_FONT_CHARSET, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 214         *pProperties++ = css::beans::Property(PROPERTY_FONT_HEIGHT, PROPERTY_ID_FONT_HEIGHT, cppu::UnoType<float>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 215         *pProperties++ = css::beans::Property(PROPERTY_FONT_WEIGHT, PROPERTY_ID_FONT_WEIGHT, cppu::UnoType<float>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 216         *pProperties++ = css::beans::Property(PROPERTY_FONT_SLANT, PROPERTY_ID_FONT_SLANT, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 217         *pProperties++ = css::beans::Property(PROPERTY_FONT_UNDERLINE, PROPERTY_ID_FONT_UNDERLINE, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 218         *pProperties++ = css::beans::Property(PROPERTY_FONT_STRIKEOUT, PROPERTY_ID_FONT_STRIKEOUT, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::MAYBEDEFAULT);
 219         *pProperties++ = css::beans::Property(PROPERTY_FONT_WORDLINEMODE, PROPERTY_ID_FONT_WORDLINEMODE, cppu::UnoType<bool>::get(),
 220                                               css::beans::PropertyAttribute::MAYBEDEFAULT);
 221     }
 222
 223
 224     void FontControlModel::getFastPropertyValue( Any& _rValue, sal_Int32 _nHandle ) const
 225     {
 226         switch( _nHandle )
 227         {
 228         case PROPERTY_ID_TEXTCOLOR:
 229             _rValue = m_aTextColor;
 230             break;
 231
 232         case PROPERTY_ID_FONTEMPHASISMARK:
 233             _rValue <<= m_nFontEmphasis;
 234             break;
 235
 236         case PROPERTY_ID_FONTRELIEF:
 237             _rValue <<= m_nFontRelief;
 238             break;
 239
 240         case PROPERTY_ID_TEXTLINECOLOR:
 241             _rValue = m_aTextLineColor;
 242             break;
 243
 244         case PROPERTY_ID_FONT:
 245             _rValue <<= m_aFont;
 246             break;
 247
 248         default:
 249             _rValue = lcl_extractFontDescriptorAggregate( _nHandle, m_aFont );
 250             break;
 251         }
 252     }
 253
 254
 255     bool FontControlModel::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue,
 256                 sal_Int32 _nHandle, const Any& _rValue )
 257     {
 258         bool bModified = false;
 259         switch( _nHandle )
 260         {
 261         case PROPERTY_ID_TEXTCOLOR:
 262             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aTextColor, cppu::UnoType<sal_Int32>::get() );
 263             break;
 264
 265         case PROPERTY_ID_TEXTLINECOLOR:
 266             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aTextLineColor, cppu::UnoType<sal_Int32>::get() );
 267             break;
 268
 269         case PROPERTY_ID_FONTEMPHASISMARK:
 270             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_nFontEmphasis );
 271             break;
 272
 273         case PROPERTY_ID_FONTRELIEF:
 274             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_nFontRelief );
 275             break;
 276
 277         case PROPERTY_ID_FONT:
 278         {
 279             Any aWorkAroundGccLimitation( m_aFont );
 280             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, aWorkAroundGccLimitation, cppu::UnoType<decltype(m_aFont)>::get() );
 281         }
 282         break;
 283
 284         case PROPERTY_ID_FONT_NAME:
 285             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Name );
 286             break;
 287
 288         case PROPERTY_ID_FONT_STYLENAME:
 289             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.StyleName );
 290             break;
 291
 292         case PROPERTY_ID_FONT_FAMILY:
 293             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Family );
 294             break;
 295
 296         case PROPERTY_ID_FONT_CHARSET:
 297             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.CharSet );
 298             break;
 299
 300         case PROPERTY_ID_FONT_CHARWIDTH:
 301             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.CharacterWidth );
 302             break;
 303
 304         case PROPERTY_ID_FONT_KERNING:
 305             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Kerning );
 306             break;
 307
 308         case PROPERTY_ID_FONT_ORIENTATION:
 309             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Orientation );
 310             break;
 311
 312         case PROPERTY_ID_FONT_PITCH:
 313             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Pitch );
 314             break;
 315
 316         case PROPERTY_ID_FONT_TYPE:
 317             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Type );
 318             break;
 319
 320         case PROPERTY_ID_FONT_WIDTH:
 321             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Width );
 322             break;
 323
 324         case PROPERTY_ID_FONT_HEIGHT:
 325             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, float( m_aFont.Height ) );
 326             break;
 327
 328         case PROPERTY_ID_FONT_WEIGHT:
 329             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Weight );
 330             break;
 331
 332         case PROPERTY_ID_FONT_SLANT:
 333             bModified = tryPropertyValueEnum( _rConvertedValue, _rOldValue, _rValue, m_aFont.Slant );
 334             break;
 335
 336         case PROPERTY_ID_FONT_UNDERLINE:
 337             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Underline );
 338             break;
 339
 340         case PROPERTY_ID_FONT_STRIKEOUT:
 341             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.Strikeout );
 342             break;
 343
 344         case PROPERTY_ID_FONT_WORDLINEMODE:
 345             bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_aFont.WordLineMode );
 346             break;
 347
 348         default:
 349             OSL_FAIL( "FontControlModel::convertFastPropertyValue: no font aggregate!" );
 350         }
 351         return bModified;
 352     }
 353
 354     /// @throws Exception
 355     static void setFastPropertyValue_NoBroadcast_implimpl(
 356             FontDescriptor & rFont,
 357             sal_Int32 nHandle, const Any& rValue)
 358     {
 359         switch (nHandle)
 360         {
 361         case PROPERTY_ID_FONT_NAME:
 362             rValue >>= rFont.Name;
 363             break;
 364
 365         case PROPERTY_ID_FONT_STYLENAME:
 366             rValue >>= rFont.StyleName;
 367             break;
 368
 369         case PROPERTY_ID_FONT_FAMILY:
 370             rValue >>= rFont.Family;
 371             break;
 372
 373         case PROPERTY_ID_FONT_CHARSET:
 374             rValue >>= rFont.CharSet;
 375             break;
 376
 377         case PROPERTY_ID_FONT_CHARWIDTH:
 378             rValue >>= rFont.CharacterWidth;
 379             break;
 380
 381         case PROPERTY_ID_FONT_KERNING:
 382             rValue >>= rFont.Kerning;
 383             break;
 384
 385         case PROPERTY_ID_FONT_ORIENTATION:
 386             rValue >>= rFont.Orientation;
 387             break;
 388
 389         case PROPERTY_ID_FONT_PITCH:
 390             rValue >>= rFont.Pitch;
 391             break;
 392
 393         case PROPERTY_ID_FONT_TYPE:
 394             rValue >>= rFont.Type;
 395             break;
 396
 397         case PROPERTY_ID_FONT_WIDTH:
 398             rValue >>= rFont.Width;
 399             break;
 400
 401         case PROPERTY_ID_FONT_HEIGHT:
 402         {
 403             float nHeight = 0;
 404             rValue >>= nHeight;
 405             rFont.Height = static_cast<sal_Int16>(nHeight);
 406         }
 407         break;
 408
 409         case PROPERTY_ID_FONT_WEIGHT:
 410             rValue >>= rFont.Weight;
 411             break;
 412
 413         case PROPERTY_ID_FONT_SLANT:
 414             rValue >>= rFont.Slant;
 415             break;
 416
 417         case PROPERTY_ID_FONT_UNDERLINE:
 418             rValue >>= rFont.Underline;
 419             break;
 420
 421         case PROPERTY_ID_FONT_STRIKEOUT:
 422             rValue >>= rFont.Strikeout;
 423             break;
 424
 425         case PROPERTY_ID_FONT_WORDLINEMODE:
 426         {
 427             bool bWordLineMode = false;
 428             rValue >>= bWordLineMode;
 429             rFont.WordLineMode = bWordLineMode;
 430         }
 431         break;
 432
 433         default:
 434             assert(false); // isFontAggregateProperty
 435         }
 436     }
 437
 438     void FontControlModel::setFastPropertyValue_NoBroadcast_impl(
 439             ::cppu::OPropertySetHelper & rBase,
 440             void (::cppu::OPropertySetHelper::*pSet)(sal_Int32, Any const&),
 441             sal_Int32 nHandle, const Any& rValue)
 442     {
 443         if (isFontAggregateProperty(nHandle))
 444         {
 445             // need to fire an event for PROPERTY_ID_FONT too apparently, so:
 446             FontDescriptor font(getFont());
 447
 448             // first set new value on backup copy
 449             setFastPropertyValue_NoBroadcast_implimpl(font, nHandle, rValue);
 450
 451             // then set that as the actual property - will eventually call
 452             // this method recursively again...
 453             (rBase.*pSet)(PROPERTY_ID_FONT, Any(font));
 454 #ifndef NDEBUG
 455             // verify that the nHandle property has the new value
 456             Any tmp;
 457             getFastPropertyValue(tmp, nHandle);
 458             assert(tmp == rValue || PROPERTY_ID_FONT_HEIGHT == nHandle /*rounded*/);
 459 #endif
 460         }
 461         else
 462         {
 463             switch (nHandle)
 464             {
 465             case PROPERTY_ID_TEXTCOLOR:
 466                 m_aTextColor = rValue;
 467                 break;
 468
 469             case PROPERTY_ID_TEXTLINECOLOR:
 470                 m_aTextLineColor = rValue;
 471                 break;
 472
 473             case PROPERTY_ID_FONTEMPHASISMARK:
 474                 rValue >>= m_nFontEmphasis;
 475                 break;
 476
 477             case PROPERTY_ID_FONTRELIEF:
 478                 rValue >>= m_nFontRelief;
 479                 break;
 480
 481             case PROPERTY_ID_FONT:
 482                 rValue >>= m_aFont;
 483                 break;
 484
 485             default:
 486                 SAL_WARN("forms.component", "invalid property: " << nHandle);
 487             }
 488         }
 489     }
 490
 491
 492     Any FontControlModel::getPropertyDefaultByHandle( sal_Int32 _nHandle ) const
 493     {
 494         Any aReturn;
 495         // some defaults which are the same, not matter if we have toolkit-compatible
 496         // defaults or not
 497         bool bHandled = false;
 498         switch( _nHandle )
 499         {
 500         case PROPERTY_ID_TEXTCOLOR:
 501         case PROPERTY_ID_TEXTLINECOLOR:
 502             // void
 503             bHandled = true;
 504             break;
 505
 506         case PROPERTY_ID_FONTEMPHASISMARK:
 507             aReturn <<= css::awt::FontEmphasisMark::NONE;
 508             bHandled = true;
 509             break;
 510
 511         case PROPERTY_ID_FONTRELIEF:
 512             aReturn <<= css::awt::FontRelief::NONE;
 513             bHandled = true;
 514             break;
 515         }
 516         if ( bHandled )
 517             return aReturn;
 518
 519         if ( m_bToolkitCompatibleDefaults )
 520         {
 521             EmptyFontDescriptor aEmpty;
 522             if ( PROPERTY_ID_FONT == _nHandle )
 523                 return Any( FontDescriptor(aEmpty) );
 524             return lcl_extractFontDescriptorAggregate( _nHandle, aEmpty );
 525         }
 526
 527         switch( _nHandle )
 528         {
 529         case PROPERTY_ID_FONT:
 530             aReturn <<= ::comphelper::getDefaultFont();
 531             break;
 532
 533         case PROPERTY_ID_FONT_WORDLINEMODE:
 534             aReturn <<= false;
 535             break;
 536
 537         case PROPERTY_ID_FONT_NAME:
 538         case PROPERTY_ID_FONT_STYLENAME:
 539             aReturn <<= OUString();
 540             break;
 541
 542         case PROPERTY_ID_FONT_FAMILY:
 543         case PROPERTY_ID_FONT_CHARSET:
 544         case PROPERTY_ID_FONT_SLANT:
 545         case PROPERTY_ID_FONT_UNDERLINE:
 546         case PROPERTY_ID_FONT_STRIKEOUT:
 547             aReturn <<= sal_Int16(1);
 548             break;
 549
 550         case PROPERTY_ID_FONT_KERNING:
 551             aReturn <<= false;
 552             break;
 553
 554         case PROPERTY_ID_FONT_PITCH:
 555         case PROPERTY_ID_FONT_TYPE:
 556         case PROPERTY_ID_FONT_WIDTH:
 557             aReturn <<= sal_Int16(0);
 558             break;
 559
 560         case PROPERTY_ID_FONT_HEIGHT:
 561         case PROPERTY_ID_FONT_WEIGHT:
 562         case PROPERTY_ID_FONT_CHARWIDTH:
 563         case PROPERTY_ID_FONT_ORIENTATION:
 564             aReturn <<= float(0);
 565             break;
 566
 567         default:
 568             OSL_FAIL( "FontControlModel::getPropertyDefaultByHandle: invalid property!" );
 569         }
 570
 571         return aReturn;
 572     }
 573
 574
 575 }   // namespace frm
 576
 577
 578 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */