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