src/java/org/apache/poi/hssf/usermodel/HSSFFontFormatting.java

   1 /* ====================================================================
   2    Licensed to the Apache Software Foundation (ASF) under one or more
   3    contributor license agreements.  See the NOTICE file distributed with
   4    this work for additional information regarding copyright ownership.
   5    The ASF licenses this file to You under the Apache License, Version 2.0
   6    (the "License"); you may not use this file except in compliance with
   7    the License.  You may obtain a copy of the License at
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  11    Unless required by applicable law or agreed to in writing, software
  12    distributed under the License is distributed on an "AS IS" BASIS,
  13    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14    See the License for the specific language governing permissions and
  15    limitations under the License.
  16 ==================================================================== */
  17
  18 package org.apache.poi.hssf.usermodel;
  19
  20 import org.apache.poi.hssf.record.CFRuleRecord;
  21 import org.apache.poi.hssf.record.cf.FontFormatting;
  22 /**
  23  * High level representation for Font Formatting component
  24  * of Conditional Formatting settings
  25  *
  26  * @author Dmitriy Kumshayev
  27  *
  28  */
  29 public final class HSSFFontFormatting
  30 {
  31         /** Escapement type - None */
  32         public final static short SS_NONE  = FontFormatting.SS_NONE;
  33         /** Escapement type - Superscript */
  34         public final static short SS_SUPER = FontFormatting.SS_SUPER;
  35         /** Escapement type - Subscript */
  36         public final static short SS_SUB   = FontFormatting.SS_SUB;
  37
  38         /** Underline type - None */
  39         public final static byte U_NONE              = FontFormatting.U_NONE;
  40         /** Underline type - Single */
  41         public final static byte U_SINGLE            = FontFormatting.U_SINGLE;
  42         /** Underline type - Double */
  43         public final static byte U_DOUBLE            = FontFormatting.U_DOUBLE;
  44         /**  Underline type - Single Accounting */
  45         public final static byte U_SINGLE_ACCOUNTING = FontFormatting.U_SINGLE_ACCOUNTING;
  46         /** Underline type - Double Accounting */
  47         public final static byte U_DOUBLE_ACCOUNTING = FontFormatting.U_DOUBLE_ACCOUNTING;
  48
  49         private final FontFormatting fontFormatting;
  50
  51         protected HSSFFontFormatting(CFRuleRecord cfRuleRecord)
  52         {
  53                 this.fontFormatting = cfRuleRecord.getFontFormatting();
  54         }
  55
  56         protected FontFormatting getFontFormattingBlock()
  57         {
  58                 return fontFormatting;
  59         }
  60
  61         /**
  62          * get the type of super or subscript for the font
  63          *
  64          * @return super or subscript option
  65          * @see #SS_NONE
  66          * @see #SS_SUPER
  67          * @see #SS_SUB
  68          */
  69         public short getEscapementType()
  70         {
  71                 return fontFormatting.getEscapementType();
  72         }
  73
  74         /**
  75          * @return font color index
  76          */
  77         public short getFontColorIndex()
  78         {
  79                 return fontFormatting.getFontColorIndex();
  80         }
  81
  82         /**
  83          * gets the height of the font in 1/20th point units
  84          *
  85          * @return fontheight (in points/20); or -1 if not modified
  86          */
  87         public int getFontHeight()
  88         {
  89                 return fontFormatting.getFontHeight();
  90         }
  91
  92         /**
  93          * get the font weight for this font (100-1000dec or 0x64-0x3e8).  Default is
  94          * 0x190 for normal and 0x2bc for bold
  95          *
  96          * @return bw - a number between 100-1000 for the fonts "boldness"
  97          */
  98
  99         public short getFontWeight()
 100         {
 101                 return fontFormatting.getFontWeight();
 102         }
 103
 104         /**
 105          * @return
 106          * @see org.apache.poi.hssf.record.cf.FontFormatting#getRawRecord()
 107          */
 108         protected byte[] getRawRecord()
 109         {
 110                 return fontFormatting.getRawRecord();
 111         }
 112
 113         /**
 114          * get the type of underlining for the font
 115          *
 116          * @return font underlining type
 117          *
 118          * @see #U_NONE
 119          * @see #U_SINGLE
 120          * @see #U_DOUBLE
 121          * @see #U_SINGLE_ACCOUNTING
 122          * @see #U_DOUBLE_ACCOUNTING
 123          */
 124         public short getUnderlineType()
 125         {
 126                 return fontFormatting.getUnderlineType();
 127         }
 128
 129         /**
 130          * get whether the font weight is set to bold or not
 131          *
 132          * @return bold - whether the font is bold or not
 133          */
 134         public boolean isBold()
 135         {
 136                 return fontFormatting.isFontWeightModified() && fontFormatting.isBold();
 137         }
 138
 139         /**
 140          * @return true if escapement type was modified from default
 141          */
 142         public boolean isEscapementTypeModified()
 143         {
 144                 return fontFormatting.isEscapementTypeModified();
 145         }
 146
 147         /**
 148          * @return true if font cancellation was modified from default
 149          */
 150         public boolean isFontCancellationModified()
 151         {
 152                 return fontFormatting.isFontCancellationModified();
 153         }
 154
 155         /**
 156          * @return true if font outline type was modified from default
 157          */
 158         public boolean isFontOutlineModified()
 159         {
 160                 return fontFormatting.isFontOutlineModified();
 161         }
 162
 163         /**
 164          * @return true if font shadow type was modified from default
 165          */
 166         public boolean isFontShadowModified()
 167         {
 168                 return fontFormatting.isFontShadowModified();
 169         }
 170
 171         /**
 172          * @return true if font style was modified from default
 173          */
 174         public boolean isFontStyleModified()
 175         {
 176                 return fontFormatting.isFontStyleModified();
 177         }
 178
 179         /**
 180          * @return true if font style was set to <i>italic</i>
 181          */
 182         public boolean isItalic()
 183         {
 184                 return fontFormatting.isFontStyleModified() && fontFormatting.isItalic();
 185         }
 186
 187         /**
 188          * @return true if font outline is on
 189          */
 190         public boolean isOutlineOn()
 191         {
 192                 return fontFormatting.isFontOutlineModified() && fontFormatting.isOutlineOn();
 193         }
 194
 195         /**
 196          * @return true if font shadow is on
 197          */
 198         public boolean isShadowOn()
 199         {
 200                 return fontFormatting.isFontOutlineModified() && fontFormatting.isShadowOn();
 201         }
 202
 203         /**
 204          * @return true if font strikeout is on
 205          */
 206         public boolean isStruckout()
 207         {
 208                 return fontFormatting.isFontCancellationModified() && fontFormatting.isStruckout();
 209         }
 210
 211         /**
 212          * @return true if font underline type was modified from default
 213          */
 214         public boolean isUnderlineTypeModified()
 215         {
 216                 return fontFormatting.isUnderlineTypeModified();
 217         }
 218
 219         /**
 220          * @return true if font weight was modified from default
 221          */
 222         public boolean isFontWeightModified()
 223         {
 224                 return fontFormatting.isFontWeightModified();
 225         }
 226
 227         /**
 228          * set font style options.
 229          *
 230          * @param italic - if true, set posture style to italic, otherwise to normal
 231          * @param bold- if true, set font weight to bold, otherwise to normal
 232          */
 233
 234         public void setFontStyle(boolean italic, boolean bold)
 235         {
 236                 boolean modified = italic || bold;
 237                 fontFormatting.setItalic(italic);
 238                 fontFormatting.setBold(bold);
 239                 fontFormatting.setFontStyleModified(modified);
 240                 fontFormatting.setFontWieghtModified(modified);
 241         }
 242
 243         /**
 244          * set font style options to default values (non-italic, non-bold)
 245          */
 246         public void resetFontStyle()
 247         {
 248                 setFontStyle(false,false);
 249         }
 250
 251         /**
 252          * set the escapement type for the font
 253          *
 254          * @param escapementType  super or subscript option
 255          * @see #SS_NONE
 256          * @see #SS_SUPER
 257          * @see #SS_SUB
 258          */
 259         public void setEscapementType(short escapementType)
 260         {
 261                 switch(escapementType)
 262                 {
 263                         case HSSFFontFormatting.SS_SUB:
 264                         case HSSFFontFormatting.SS_SUPER:
 265                                 fontFormatting.setEscapementType(escapementType);
 266                                 fontFormatting.setEscapementTypeModified(true);
 267                                 break;
 268                         case HSSFFontFormatting.SS_NONE:
 269                                 fontFormatting.setEscapementType(escapementType);
 270                                 fontFormatting.setEscapementTypeModified(false);
 271                                 break;
 272                         default:
 273                 }
 274         }
 275
 276         /**
 277          * @param modified
 278          * @see org.apache.poi.hssf.record.cf.FontFormatting#setEscapementTypeModified(boolean)
 279          */
 280         public void setEscapementTypeModified(boolean modified)
 281         {
 282                 fontFormatting.setEscapementTypeModified(modified);
 283         }
 284
 285         /**
 286          * @param modified
 287          * @see org.apache.poi.hssf.record.cf.FontFormatting#setFontCancellationModified(boolean)
 288          */
 289         public void setFontCancellationModified(boolean modified)
 290         {
 291                 fontFormatting.setFontCancellationModified(modified);
 292         }
 293
 294         /**
 295          * @param fci
 296          * @see org.apache.poi.hssf.record.cf.FontFormatting#setFontColorIndex(short)
 297          */
 298         public void setFontColorIndex(short fci)
 299         {
 300                 fontFormatting.setFontColorIndex(fci);
 301         }
 302
 303         /**
 304          * @param height
 305          * @see org.apache.poi.hssf.record.cf.FontFormatting#setFontHeight(short)
 306          */
 307         public void setFontHeight(int height)
 308         {
 309                 fontFormatting.setFontHeight(height);
 310         }
 311
 312         /**
 313          * @param modified
 314          * @see org.apache.poi.hssf.record.cf.FontFormatting#setFontOutlineModified(boolean)
 315          */
 316         public void setFontOutlineModified(boolean modified)
 317         {
 318                 fontFormatting.setFontOutlineModified(modified);
 319         }
 320
 321         /**
 322          * @param modified
 323          * @see org.apache.poi.hssf.record.cf.FontFormatting#setFontShadowModified(boolean)
 324          */
 325         public void setFontShadowModified(boolean modified)
 326         {
 327                 fontFormatting.setFontShadowModified(modified);
 328         }
 329
 330         /**
 331          * @param modified
 332          * @see org.apache.poi.hssf.record.cf.FontFormatting#setFontStyleModified(boolean)
 333          */
 334         public void setFontStyleModified(boolean modified)
 335         {
 336                 fontFormatting.setFontStyleModified(modified);
 337         }
 338
 339         /**
 340          * @param on
 341          * @see org.apache.poi.hssf.record.cf.FontFormatting#setOutline(boolean)
 342          */
 343         public void setOutline(boolean on)
 344         {
 345                 fontFormatting.setOutline(on);
 346                 fontFormatting.setFontOutlineModified(on);
 347         }
 348
 349         /**
 350          * @param on
 351          * @see org.apache.poi.hssf.record.cf.FontFormatting#setShadow(boolean)
 352          */
 353         public void setShadow(boolean on)
 354         {
 355                 fontFormatting.setShadow(on);
 356                 fontFormatting.setFontShadowModified(on);
 357         }
 358
 359         /**
 360          * @param strike
 361          * @see org.apache.poi.hssf.record.cf.FontFormatting#setStrikeout(boolean)
 362          */
 363         public void setStrikeout(boolean strike)
 364         {
 365                 fontFormatting.setStrikeout(strike);
 366                 fontFormatting.setFontCancellationModified(strike);
 367         }
 368
 369         /**
 370          * set the type of underlining type for the font
 371          *
 372          * @param u  super or subscript option
 373          *
 374          * @see #U_NONE
 375          * @see #U_SINGLE
 376          * @see #U_DOUBLE
 377          * @see #U_SINGLE_ACCOUNTING
 378          * @see #U_DOUBLE_ACCOUNTING
 379          */
 380         public void setUnderlineType(short underlineType)
 381         {
 382                 switch(underlineType)
 383                 {
 384                         case HSSFFontFormatting.U_SINGLE:
 385                         case HSSFFontFormatting.U_DOUBLE:
 386                         case HSSFFontFormatting.U_SINGLE_ACCOUNTING:
 387                         case HSSFFontFormatting.U_DOUBLE_ACCOUNTING:
 388                                 fontFormatting.setUnderlineType(underlineType);
 389                                 setUnderlineTypeModified(true);
 390                                 break;
 391
 392                         case HSSFFontFormatting.U_NONE:
 393                                 fontFormatting.setUnderlineType(underlineType);
 394                                 setUnderlineTypeModified(false);
 395                                 break;
 396                         default:
 397                 }
 398         }
 399
 400         /**
 401          * @param modified
 402          * @see org.apache.poi.hssf.record.cf.FontFormatting#setUnderlineTypeModified(boolean)
 403          */
 404         public void setUnderlineTypeModified(boolean modified)
 405         {
 406                 fontFormatting.setUnderlineTypeModified(modified);
 407         }
 408 }