Coverage Report - ar.com.fdvs.dj.domain.Style
 
Classes in this File Line Coverage Branch Coverage Complexity
Style
95%
179/187
86%
33/38
1.333
 
 1  
 /*
 2  
  * DynamicJasper: A library for creating reports dynamically by specifying
 3  
  * columns, groups, styles, etc. at runtime. It also saves a lot of development
 4  
  * time in many cases! (http://sourceforge.net/projects/dynamicjasper)
 5  
  *
 6  
  * Copyright (C) 2008  FDV Solutions (http://www.fdvsolutions.com)
 7  
  *
 8  
  * This library is free software; you can redistribute it and/or
 9  
  * modify it under the terms of the GNU Lesser General Public
 10  
  *
 11  
  * License as published by the Free Software Foundation; either
 12  
  *
 13  
  * version 2.1 of the License, or (at your option) any later version.
 14  
  *
 15  
  * This library is distributed in the hope that it will be useful,
 16  
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 17  
  *
 18  
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19  
  *
 20  
  * Lesser General Public License for more details.
 21  
  *
 22  
  * You should have received a copy of the GNU Lesser General Public
 23  
  * License along with this library; if not, write to the Free Software
 24  
  *
 25  
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 26  
  *
 27  
  *
 28  
  */
 29  
 
 30  
 package ar.com.fdvs.dj.domain;
 31  
 
 32  
 import ar.com.fdvs.dj.domain.constants.*;
 33  
 import ar.com.fdvs.dj.domain.constants.Font;
 34  
 import ar.com.fdvs.dj.domain.constants.Transparency;
 35  
 import ar.com.fdvs.dj.domain.entities.Entity;
 36  
 import ar.com.fdvs.dj.util.LayoutUtils;
 37  
 import net.sf.jasperreports.engine.base.JRBaseStyle;
 38  
 import net.sf.jasperreports.engine.base.JRBoxPen;
 39  
 import net.sf.jasperreports.engine.design.JRDesignConditionalStyle;
 40  
 import net.sf.jasperreports.engine.design.JRDesignStyle;
 41  
 import net.sf.jasperreports.engine.type.*;
 42  
 
 43  
 import java.awt.*;
 44  
 import java.io.Serializable;
 45  
 
 46  
 /**
 47  
  * Class that should be used to define the different styles in a friendly </br>
 48  
  * and strict way.</br>
 49  
  * </br>
 50  
  * Usage example:</br>
 51  
  * Style headerStyle = new Style();</br>
 52  
  * headerStyle.setFont(Font.ARIAL_MEDIUM_BOLD);</br>
 53  
  * headerStyle.setBorder(Border.PEN_2_POINT());</br>
 54  
  * headerStyle.setHorizontalAlign(HorizontalAlign.CENTER);</br>
 55  
  * headerStyle.setVerticalAlign(VerticalAlign.MIDDLE);</br>
 56  
  */
 57  
 public class Style implements Serializable, Cloneable {
 58  
 
 59  
         private static final long serialVersionUID = Entity.SERIAL_VERSION_UID;
 60  
 
 61  
         private String name;
 62  
         private String parentStyleName;
 63  
 
 64  2680
         private Color backgroundColor = Color.WHITE;
 65  2680
         private Color textColor = Color.BLACK;
 66  
 
 67  2680
         private Font font = Font.ARIAL_MEDIUM;
 68  
 
 69  2680
         private Border border = Border.NO_BORDER();
 70  
 
 71  2680
         private Border borderTop = null;
 72  2680
         private Border borderBottom = null;
 73  2680
         private Border borderLeft = null;
 74  2680
         private Border borderRight = null;
 75  
 
 76  
         private Integer paddingBottom, paddingTop, paddingLeft, paddingRight;
 77  
 
 78  2680
         private Integer padding = new Integer(2);
 79  2680
         private Integer radius = new Integer(0);
 80  
 
 81  2680
         private Transparency transparency = Transparency.TRANSPARENT;
 82  
 
 83  2680
     private VerticalAlign verticalAlign = VerticalAlign.BOTTOM;
 84  2680
     private HorizontalAlign horizontalAlign = HorizontalAlign.LEFT;
 85  2680
     private Rotation rotation = Rotation.NONE;
 86  
 
 87  2680
     private Stretching streching = Stretching.RELATIVE_TO_TALLEST_OBJECT;
 88  
 
 89  2680
     private boolean stretchWithOverflow = true;
 90  2680
     private boolean blankWhenNull = true;
 91  
 
 92  
     private String pattern;
 93  
 
 94  
     /**
 95  
      * If true and another style exists in the design with the same name, this style overrides the existing one.
 96  
      */
 97  2680
     private boolean overridesExistingStyle = false;
 98  
 
 99  
     public boolean isOverridesExistingStyle() {
 100  1251
                 return overridesExistingStyle;
 101  
         }
 102  
 
 103  
         public void setOverridesExistingStyle(boolean overridesExistingStyle) {
 104  5
                 this.overridesExistingStyle = overridesExistingStyle;
 105  5
         }
 106  
 
 107  3380
         public Style(){}
 108  
 
 109  990
     public Style(String name){
 110  990
             this.name = name;
 111  990
     }
 112  0
     public Style(String name, String parentName){
 113  0
             this.name = name;
 114  0
             this.parentStyleName = parentName;
 115  0
     }
 116  
 
 117  
         public boolean isBlankWhenNull() {
 118  5
                 return blankWhenNull;
 119  
         }
 120  
 
 121  
         public void setBlankWhenNull(boolean blankWhenNull) {
 122  5
                 this.blankWhenNull = blankWhenNull;
 123  5
         }
 124  
 
 125  
         public Color getBackgroundColor() {
 126  1448
                 return backgroundColor;
 127  
         }
 128  
 
 129  
         public void setBackgroundColor(Color backgroundColor) {
 130  374
                 this.backgroundColor = backgroundColor;
 131  374
         }
 132  
 
 133  
         public Border getBorder() {
 134  2577
                 return border;
 135  
         }
 136  
 
 137  
         public void setBorder(Border border) {
 138  54
                 this.border = border;
 139  54
         }
 140  
 
 141  
         public Font getFont() {
 142  11
                 return font;
 143  
         }
 144  
 
 145  
         public void setFont(Font font) {
 146  407
                 if (font != null)
 147  395
                         this.font = (Font) font.clone();
 148  12
                 else this.font = null;
 149  407
         }
 150  
 
 151  
         public HorizontalAlign getHorizontalAlign() {
 152  2515
                 return horizontalAlign;
 153  
         }
 154  
 
 155  
         public void setHorizontalAlign(HorizontalAlign horizontalAlign) {
 156  483
                 this.horizontalAlign = horizontalAlign;
 157  483
         }
 158  
 
 159  
         public Integer getPadding() {
 160  1271
                 return padding;
 161  
         }
 162  
 
 163  
         public void setPadding(Integer padding) {
 164  17
                 this.padding = padding;
 165  17
         }
 166  
 
 167  
         public Stretching getStreching() {
 168  3238
                 return streching;
 169  
         }
 170  
 
 171  
         public void setStreching(Stretching streching) {
 172  351
                 this.streching = streching;
 173  351
         }
 174  
 
 175  
         public boolean isStretchWithOverflow() {
 176  1626
                 return stretchWithOverflow;
 177  
         }
 178  
 
 179  
         public void setStretchWithOverflow(boolean stretchWithOverflow) {
 180  9
                 this.stretchWithOverflow = stretchWithOverflow;
 181  9
         }
 182  
 
 183  
         public Color getTextColor() {
 184  1271
                 return textColor;
 185  
         }
 186  
 
 187  
         public void setTextColor(Color textColor) {
 188  132
                 this.textColor = textColor;
 189  132
         }
 190  
 
 191  
         public Transparency getTransparency() {
 192  2518
                 return transparency;
 193  
         }
 194  
 
 195  
         public void setTransparency(Transparency transparency) {
 196  209
                 this.transparency = transparency;
 197  209
         }
 198  
 
 199  
         public void setTransparent(boolean transparent) {
 200  5
                 if (transparent)
 201  3
                         this.setTransparency(Transparency.TRANSPARENT);
 202  
                 else
 203  2
                         this.setTransparency(Transparency.OPAQUE);
 204  5
         }
 205  
 
 206  
         public boolean isTransparent(){
 207  5
                 return this.transparency.equals(Transparency.TRANSPARENT);
 208  
         }
 209  
 
 210  
         public VerticalAlign getVerticalAlign() {
 211  2515
                 return verticalAlign;
 212  
         }
 213  
 
 214  
         public void setVerticalAlign(VerticalAlign verticalAlign) {
 215  283
                 this.verticalAlign = verticalAlign;
 216  283
         }
 217  
 
 218  
         public JRDesignConditionalStyle transformAsConditinalStyle() {
 219  6
                 JRDesignConditionalStyle ret = new JRDesignConditionalStyle();
 220  6
                 setJRBaseStyleProperties(ret);
 221  6
                 return ret;
 222  
                 
 223  
         }
 224  
 
 225  
         public JRDesignStyle transform() {
 226  1260
                 JRDesignStyle transformedStyle = new JRDesignStyle();
 227  1260
                 transformedStyle.setName(this.name);
 228  1260
                 transformedStyle.setParentStyleNameReference(this.parentStyleName);
 229  1260
                 setJRBaseStyleProperties(transformedStyle);
 230  1260
                 return transformedStyle;
 231  
         }
 232  
 
 233  
         protected void setJRBaseStyleProperties(JRBaseStyle transformedStyle) {
 234  1266
         JRBoxPen pen = transformedStyle.getLineBox().getPen();
 235  1266
         if (getBorder()!=null){
 236  1244
             LayoutUtils.convertBorderToPen(getBorder(),transformedStyle.getLineBox().getPen());
 237  
         }
 238  
 
 239  1266
                 if (getBorderBottom()!= null)
 240  218
             LayoutUtils.convertBorderToPen(getBorderBottom(),transformedStyle.getLineBox().getBottomPen());
 241  
                         //transformedStyle.setBottomBorder(getBorderBottom().getValue());
 242  1266
                 if (getBorderTop()!= null)
 243  8
             LayoutUtils.convertBorderToPen(getBorderTop(),transformedStyle.getLineBox().getTopPen());
 244  
                         //transformedStyle.setTopBorder(getBorderTop().getValue());
 245  1266
                 if (getBorderLeft()!= null)
 246  0
             LayoutUtils.convertBorderToPen(getBorderLeft(),transformedStyle.getLineBox().getLeftPen());
 247  
                         //transformedStyle.setLeftBorder(getBorderLeft().getValue());
 248  1266
                 if (getBorderRight()!= null)
 249  0
             LayoutUtils.convertBorderToPen(getBorderRight(),transformedStyle.getLineBox().getRightPen());
 250  
                         //transformedStyle.setRightBorder(getBorderRight().getValue());
 251  
 
 252  
                 //Padding
 253  1266
                 transformedStyle.getLineBox().setPadding(getPadding());
 254  
 
 255  1266
                 if (paddingBottom != null)
 256  6
             transformedStyle.getLineBox().setBottomPadding(paddingBottom);
 257  1266
                 if (paddingTop != null)
 258  4
             transformedStyle.getLineBox().setTopPadding(paddingTop);
 259  1266
                 if (paddingLeft != null)
 260  4
             transformedStyle.getLineBox().setLeftPadding(paddingLeft);
 261  1266
                 if (paddingRight != null)
 262  2
             transformedStyle.getLineBox().setRightPadding(paddingRight);
 263  
 
 264  
                 //Aligns
 265  1266
                 if (getHorizontalAlign() != null)
 266  1244
                         transformedStyle.setHorizontalAlignment(HorizontalAlignEnum.getByValue(getHorizontalAlign().getValue() ));
 267  
 
 268  1266
                 if (getVerticalAlign() != null)
 269  1244
                         transformedStyle.setVerticalAlignment(VerticalAlignEnum.getByValue(getVerticalAlign().getValue()));
 270  
 
 271  1266
                 transformedStyle.setBlankWhenNull(blankWhenNull);
 272  
 
 273  
                 //Font
 274  1266
                 if (font != null) {
 275  1266
                         transformedStyle.setFontName(font.getFontName());
 276  1266
                         transformedStyle.setFontSize(font.getFontSize());
 277  1266
                         transformedStyle.setBold(font.isBold());
 278  1266
                         transformedStyle.setItalic(font.isItalic());
 279  1266
                         transformedStyle.setUnderline(font.isUnderline());
 280  1266
                         transformedStyle.setPdfFontName(font.getPdfFontName());
 281  1266
                         transformedStyle.setPdfEmbedded(font.isPdfFontEmbedded());
 282  1266
                         transformedStyle.setPdfEncoding(font.getPdfFontEncoding());
 283  
                 }
 284  
 
 285  1266
                 transformedStyle.setBackcolor(getBackgroundColor());
 286  1266
                 transformedStyle.setForecolor(getTextColor());
 287  
 
 288  1266
                 if (getTransparency() != null)
 289  1244
                         transformedStyle.setMode(ModeEnum.getByValue( getTransparency().getValue() ));
 290  
 
 291  1266
                 if (getRotation() != null)
 292  1244
                         transformedStyle.setRotation(RotationEnum.getByValue( getRotation().getValue() ));
 293  
 
 294  1266
                 if (getRadius() != null)
 295  1244
                         transformedStyle.setRadius(getRadius().intValue());
 296  
 
 297  1266
                 transformedStyle.setPattern(this.pattern);
 298  
 
 299  
                 /**
 300  
                  * This values are needed when exporting to JRXML
 301  
                  */
 302  
         //TODO Check if this is still necessary
 303  
         /*transformedStyle.setPen((byte)0);
 304  
                 transformedStyle.setFill((byte)1);
 305  
                 transformedStyle.setScaleImage(ImageScaleMode.NO_RESIZE.getValue());*/
 306  
         
 307  1266
         }
 308  
 
 309  
         public Border getBorderBottom() {
 310  1489
                 return borderBottom;
 311  
         }
 312  
 
 313  
         public void setBorderBottom(Border borderBottom) {
 314  169
                 this.borderBottom = borderBottom;
 315  169
         }
 316  
 
 317  
         public Border getBorderLeft() {
 318  1271
                 return borderLeft;
 319  
         }
 320  
 
 321  
         public void setBorderLeft(Border borderLeft) {
 322  5
                 this.borderLeft = borderLeft;
 323  5
         }
 324  
 
 325  
         public Border getBorderRight() {
 326  1271
                 return borderRight;
 327  
         }
 328  
 
 329  
         public void setBorderRight(Border borderRight) {
 330  5
                 this.borderRight = borderRight;
 331  5
         }
 332  
 
 333  
         public Border getBorderTop() {
 334  1279
                 return borderTop;
 335  
         }
 336  
 
 337  
         public void setBorderTop(Border borderTop) {
 338  8
                 this.borderTop = borderTop;
 339  8
         }
 340  
 
 341  
     /**
 342  
      * use #Style.getBorder().getColor() instead
 343  
      * @return
 344  
      */
 345  
     @Deprecated
 346  
         public Color getBorderColor() {
 347  5
         if (getBorder() == null)
 348  0
             return null;
 349  5
                 return getBorder().getColor();
 350  
         }
 351  
 
 352  
     /**
 353  
      * Use #Style.setBorder(...) instead
 354  
      * @param borderColor
 355  
      */
 356  
     @Deprecated
 357  
         public void setBorderColor(Color borderColor) {
 358  26
         if (getBorder() == null)
 359  0
             return;
 360  
 
 361  26
         this.getBorder().setColor(borderColor);
 362  26
         }
 363  
 
 364  
         public Rotation getRotation() {
 365  2515
                 return rotation;
 366  
         }
 367  
 
 368  
         public void setRotation(Rotation rotation) {
 369  18
                 this.rotation = rotation;
 370  18
         }
 371  
 
 372  
         public Integer getRadius() {
 373  2515
                 return radius;
 374  
         }
 375  
 
 376  
         public void setRadius(Integer radius) {
 377  17
                 this.radius = radius;
 378  17
         }
 379  
 
 380  
         public Integer getPaddingBottom() {
 381  5
                 return paddingBottom;
 382  
         }
 383  
 
 384  
         public void setPaddingBottom(Integer paddingBottom) {
 385  6
                 this.paddingBottom = paddingBottom;
 386  6
         }
 387  
 
 388  
     public Integer getPaddingTop() {
 389  5
                 return paddingTop;
 390  
         }
 391  
 
 392  
         public void setPaddingTop(Integer paddingTop) {
 393  6
                 this.paddingTop = paddingTop;
 394  6
         }
 395  
 
 396  
         public Integer getPaddingLeft() {
 397  5
                 return paddingLeft;
 398  
         }
 399  
 
 400  
         public void setPaddingLeft(Integer paddingLeft) {
 401  6
                 this.paddingLeft = paddingLeft;
 402  6
         }
 403  
 
 404  
         public Integer getPaddingRight() {
 405  5
                 return paddingRight;
 406  
         }
 407  
 
 408  
         public void setPaddingRight(Integer paddingRight) {
 409  5
                 this.paddingRight = paddingRight;
 410  5
         }
 411  
 
 412  
         public String getName() {
 413  4886
                 return name;
 414  
         }
 415  
 
 416  
         public void setName(String name) {
 417  804
                 this.name = name;
 418  804
         }
 419  
 
 420  
         public String getParentStyleName() {
 421  5
                 return parentStyleName;
 422  
         }
 423  
 
 424  
         public void setParentStyleName(String parentStyleName) {
 425  7
                 this.parentStyleName = parentStyleName;
 426  7
         }
 427  
 
 428  
         /**
 429  
          * Creates a blank style (no default values).
 430  
          * Useful when we need a style with a parent style, not defined properties (null ones) will be inherited
 431  
          * from parent style
 432  
          *
 433  
          * @param name  style name
 434  
          * @return  Style
 435  
          */
 436  
         public static Style createBlankStyle(String name){
 437  12
                 Style style = new Style(name);
 438  
 
 439  12
                 style.setBackgroundColor(null);
 440  12
                 style.setBorderColor(null);
 441  12
                 style.setTransparency(null);
 442  12
                 style.setTextColor(null);
 443  12
                 style.setBorder(null);
 444  12
                 style.setFont(null);
 445  12
                 style.setPadding(null);
 446  12
                 style.setRadius(null);
 447  12
                 style.setVerticalAlign(null);
 448  12
                 style.setHorizontalAlign(null);
 449  12
                 style.setRotation(null);
 450  12
                 style.setStreching(null);
 451  
 
 452  12
                 return style;
 453  
 
 454  
         }
 455  
 
 456  
         public static Style createBlankStyle(String name, String parent){
 457  2
                 Style s = createBlankStyle(name);
 458  2
                 s.setParentStyleName(parent);
 459  2
                 return s;
 460  
         }
 461  
 
 462  
         public String getPattern() {
 463  5
                 return pattern;
 464  
         }
 465  
 
 466  
         public void setPattern(String pattern) {
 467  31
                 this.pattern = pattern;
 468  31
         }
 469  
 
 470  
         public Object clone() throws CloneNotSupportedException {
 471  54
                 Style style = (Style) super.clone();
 472  54
                 style.setFont(this.font);
 473  54
                 return style;
 474  
         }
 475  
 }