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