0001: /*
0002: * ============================================================================
0003: * GNU Lesser General Public License
0004: * ============================================================================
0005: *
0006: * JasperReports - Free Java report-generating library.
0007: * Copyright (C) 2001-2006 JasperSoft Corporation http://www.jaspersoft.com
0008: *
0009: * This library is free software; you can redistribute it and/or
0010: * modify it under the terms of the GNU Lesser General Public
0011: * License as published by the Free Software Foundation; either
0012: * version 2.1 of the License, or (at your option) any later version.
0013: *
0014: * This library is distributed in the hope that it will be useful,
0015: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0016: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0017: * Lesser General Public License for more details.
0018: *
0019: * You should have received a copy of the GNU Lesser General Public
0020: * License along with this library; if not, write to the Free Software
0021: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
0022: *
0023: * JasperSoft Corporation
0024: * 303 Second Street, Suite 450 North
0025: * San Francisco, CA 94107
0026: * http://www.jaspersoft.com
0027: */
0028: package net.sf.jasperreports.engine.base;
0029:
0030: import java.awt.Color;
0031: import java.io.Serializable;
0032:
0033: import net.sf.jasperreports.engine.JRAbstractObjectFactory;
0034: import net.sf.jasperreports.engine.JRConditionalStyle;
0035: import net.sf.jasperreports.engine.JRDefaultStyleProvider;
0036: import net.sf.jasperreports.engine.JRRuntimeException;
0037: import net.sf.jasperreports.engine.JRStyle;
0038: import net.sf.jasperreports.engine.JRStyleSetter;
0039: import net.sf.jasperreports.engine.util.JRStyleResolver;
0040:
0041: /**
0042: * @author Ionut Nedelcu (ionutned@users.sourceforge.net)
0043: * @version $Id: JRBaseStyle.java 1765 2007-06-21 15:50:27Z lucianc $
0044: */
0045: public class JRBaseStyle implements JRStyle, Serializable {
0046:
0047: /**
0048: *
0049: */
0050: private static final long serialVersionUID = 10001;
0051:
0052: /**
0053: *
0054: */
0055: protected JRDefaultStyleProvider defaultStyleProvider = null;
0056: protected JRStyle parentStyle = null;
0057: protected String parentStyleNameReference;
0058:
0059: /**
0060: *
0061: */
0062: protected String name = null;
0063: protected boolean isDefault = false;
0064:
0065: protected Byte positionType = null;
0066: protected Byte stretchType = null;
0067: protected Byte mode = null;
0068: protected Color forecolor = null;
0069: protected Color backcolor = null;
0070:
0071: protected Byte pen = null;
0072: protected Byte fill = null;
0073:
0074: protected Integer radius = null;
0075:
0076: protected Byte scaleImage = null;
0077: protected Byte horizontalAlignment = null;
0078: protected Byte verticalAlignment = null;
0079:
0080: protected Byte border = null;
0081: protected Byte topBorder = null;
0082: protected Byte leftBorder = null;
0083: protected Byte bottomBorder = null;
0084: protected Byte rightBorder = null;
0085: protected Color borderColor = null;
0086: protected Color topBorderColor = null;
0087: protected Color leftBorderColor = null;
0088: protected Color bottomBorderColor = null;
0089: protected Color rightBorderColor = null;
0090: protected Integer padding = null;
0091: protected Integer topPadding = null;
0092: protected Integer leftPadding = null;
0093: protected Integer bottomPadding = null;
0094: protected Integer rightPadding = null;
0095:
0096: protected String fontName = null;
0097: protected Boolean isBold = null;
0098: protected Boolean isItalic = null;
0099: protected Boolean isUnderline = null;
0100: protected Boolean isStrikeThrough = null;
0101: protected Integer fontSize = null;
0102: protected String pdfFontName = null;
0103: protected String pdfEncoding = null;
0104: protected Boolean isPdfEmbedded = null;
0105:
0106: protected Byte rotation = null;
0107: protected Byte lineSpacing = null;
0108: protected Boolean isStyledText = null;
0109:
0110: protected String pattern = null;
0111: protected Boolean isBlankWhenNull = null;
0112:
0113: protected JRConditionalStyle[] conditionalStyles;
0114:
0115: /**
0116: *
0117: */
0118: public JRBaseStyle() {
0119: }
0120:
0121: /**
0122: *
0123: */
0124: public JRBaseStyle(String name) {
0125: this .name = name;
0126: }
0127:
0128: /**
0129: *
0130: */
0131: public JRBaseStyle(JRStyle style, JRAbstractObjectFactory factory) {
0132: name = style.getName();
0133:
0134: factory.setStyle(new JRStyleSetter() {
0135: public void setStyle(JRStyle aStyle) {
0136: setParentStyle(aStyle);
0137: }
0138:
0139: public void setStyleNameReference(String name) {
0140: parentStyleNameReference = name;
0141: }
0142: }, style);
0143:
0144: isDefault = style.isDefault();
0145:
0146: mode = style.getOwnMode();
0147: forecolor = style.getOwnForecolor();
0148: backcolor = style.getOwnBackcolor();
0149:
0150: pen = style.getOwnPen();
0151: fill = style.getOwnFill();
0152:
0153: radius = style.getOwnRadius();
0154:
0155: scaleImage = style.getOwnScaleImage();
0156: horizontalAlignment = style.getOwnHorizontalAlignment();
0157: verticalAlignment = style.getOwnVerticalAlignment();
0158:
0159: border = style.getOwnBorder();
0160: topBorder = style.getOwnTopBorder();
0161: leftBorder = style.getOwnLeftBorder();
0162: bottomBorder = style.getOwnBottomBorder();
0163: rightBorder = style.getOwnRightBorder();
0164: borderColor = style.getOwnBorderColor();
0165: topBorderColor = style.getOwnTopBorderColor();
0166: leftBorderColor = style.getOwnLeftBorderColor();
0167: bottomBorderColor = style.getOwnBottomBorderColor();
0168: rightBorderColor = style.getOwnRightBorderColor();
0169: padding = style.getOwnPadding();
0170: topPadding = style.getOwnTopPadding();
0171: leftPadding = style.getOwnLeftPadding();
0172: bottomPadding = style.getOwnBottomPadding();
0173: rightPadding = style.getOwnRightPadding();
0174:
0175: rotation = style.getOwnRotation();
0176: lineSpacing = style.getOwnLineSpacing();
0177: isStyledText = style.isOwnStyledText();
0178:
0179: pattern = style.getOwnPattern();
0180:
0181: fontName = style.getOwnFontName();
0182: isBold = style.isOwnBold();
0183: isItalic = style.isOwnItalic();
0184: isUnderline = style.isOwnUnderline();
0185: isStrikeThrough = style.isOwnStrikeThrough();
0186: fontSize = style.getOwnFontSize();
0187: pdfFontName = style.getOwnPdfFontName();
0188: pdfEncoding = style.getOwnPdfEncoding();
0189: isPdfEmbedded = style.isOwnPdfEmbedded();
0190:
0191: JRConditionalStyle[] condStyles = style.getConditionalStyles();
0192: if (condStyles != null && condStyles.length > 0) {
0193: this .conditionalStyles = new JRConditionalStyle[condStyles.length];
0194: for (int i = 0; i < condStyles.length; i++) {
0195: this .conditionalStyles[i] = factory
0196: .getConditionalStyle(condStyles[i], this );
0197: }
0198: }
0199: }
0200:
0201: protected void setParentStyle(JRStyle parentStyle) {
0202: this .parentStyle = parentStyle;
0203: checkCircularParent();
0204: }
0205:
0206: protected void checkCircularParent() {
0207: for (JRStyle ancestor = parentStyle; ancestor != null; ancestor = ancestor
0208: .getStyle()) {
0209: if (ancestor == this ) {
0210: throw new JRRuntimeException(
0211: "Circular dependency detected for style "
0212: + getName());
0213: }
0214: }
0215: }
0216:
0217: /**
0218: *
0219: */
0220: public JRDefaultStyleProvider getDefaultStyleProvider() {
0221: return defaultStyleProvider;
0222: }
0223:
0224: /**
0225: *
0226: */
0227: public JRStyle getStyle() {
0228: return parentStyle;
0229: }
0230:
0231: /**
0232: *
0233: */
0234: public String getName() {
0235: return name;
0236: }
0237:
0238: /**
0239: * Changes the name of this style.
0240: * <p/>
0241: * Note that this method is mostly meant to be used internally.
0242: * Use cautiously as it might have unexpected consequences.
0243: *
0244: * @param newName the new name
0245: */
0246: public void rename(String newName) {
0247: this .name = newName;
0248: }
0249:
0250: /**
0251: *
0252: */
0253: public boolean isDefault() {
0254: return isDefault;
0255: }
0256:
0257: /**
0258: *
0259: */
0260: public Color getForecolor() {
0261: return JRStyleResolver.getForecolor(this );
0262: }
0263:
0264: /**
0265: *
0266: */
0267: public Color getOwnForecolor() {
0268: return forecolor;
0269: }
0270:
0271: public Color getBackcolor() {
0272: return JRStyleResolver.getBackcolor(this );
0273: }
0274:
0275: public Color getOwnBackcolor() {
0276: return backcolor;
0277: }
0278:
0279: public Byte getPen() {
0280: return JRStyleResolver.getPen(this );
0281: }
0282:
0283: public Byte getOwnPen() {
0284: return pen;
0285: }
0286:
0287: public Byte getFill() {
0288: return JRStyleResolver.getFill(this );
0289: }
0290:
0291: public Byte getOwnFill() {
0292: return fill;
0293: }
0294:
0295: public Integer getRadius() {
0296: return JRStyleResolver.getRadius(this );
0297: }
0298:
0299: public Integer getOwnRadius() {
0300: return radius;
0301: }
0302:
0303: public Byte getScaleImage() {
0304: return JRStyleResolver.getScaleImage(this );
0305: }
0306:
0307: public Byte getOwnScaleImage() {
0308: return scaleImage;
0309: }
0310:
0311: public Byte getHorizontalAlignment() {
0312: return JRStyleResolver.getHorizontalAlignment(this );
0313: }
0314:
0315: public Byte getOwnHorizontalAlignment() {
0316: return horizontalAlignment;
0317: }
0318:
0319: public Byte getVerticalAlignment() {
0320: return JRStyleResolver.getVerticalAlignment(this );
0321: }
0322:
0323: public Byte getOwnVerticalAlignment() {
0324: return verticalAlignment;
0325: }
0326:
0327: public Byte getBorder() {
0328: return JRStyleResolver.getBorder(this );
0329: }
0330:
0331: public Byte getOwnBorder() {
0332: return border;
0333: }
0334:
0335: public Color getBorderColor() {
0336: return JRStyleResolver.getBorderColor(this );
0337: }
0338:
0339: public Color getOwnBorderColor() {
0340: return borderColor;
0341: }
0342:
0343: public Integer getPadding() {
0344: return JRStyleResolver.getPadding(this );
0345: }
0346:
0347: public Integer getOwnPadding() {
0348: return padding;
0349: }
0350:
0351: public Byte getTopBorder() {
0352: return JRStyleResolver.getTopBorder(this );
0353: }
0354:
0355: public Byte getOwnTopBorder() {
0356: return topBorder;
0357: }
0358:
0359: public Color getTopBorderColor() {
0360: return JRStyleResolver.getTopBorderColor(this );
0361: }
0362:
0363: public Color getOwnTopBorderColor() {
0364: return topBorderColor;
0365: }
0366:
0367: public Integer getTopPadding() {
0368: return JRStyleResolver.getTopPadding(this );
0369: }
0370:
0371: public Integer getOwnTopPadding() {
0372: return topPadding;
0373: }
0374:
0375: public Byte getLeftBorder() {
0376: return JRStyleResolver.getLeftBorder(this );
0377: }
0378:
0379: public Byte getOwnLeftBorder() {
0380: return leftBorder;
0381: }
0382:
0383: public Color getLeftBorderColor() {
0384: return JRStyleResolver.getLeftBorderColor(this );
0385: }
0386:
0387: public Color getOwnLeftBorderColor() {
0388: return leftBorderColor;
0389: }
0390:
0391: public Integer getLeftPadding() {
0392: return JRStyleResolver.getLeftPadding(this );
0393: }
0394:
0395: public Integer getOwnLeftPadding() {
0396: return leftPadding;
0397: }
0398:
0399: public Byte getBottomBorder() {
0400: return JRStyleResolver.getBottomBorder(this );
0401: }
0402:
0403: public Byte getOwnBottomBorder() {
0404: return bottomBorder;
0405: }
0406:
0407: public Color getBottomBorderColor() {
0408: return JRStyleResolver.getBottomBorderColor(this );
0409: }
0410:
0411: public Color getOwnBottomBorderColor() {
0412: return bottomBorderColor;
0413: }
0414:
0415: public Integer getBottomPadding() {
0416: return JRStyleResolver.getBottomPadding(this );
0417: }
0418:
0419: public Integer getOwnBottomPadding() {
0420: return bottomPadding;
0421: }
0422:
0423: public Byte getRightBorder() {
0424: return JRStyleResolver.getRightBorder(this );
0425: }
0426:
0427: public Byte getOwnRightBorder() {
0428: return rightBorder;
0429: }
0430:
0431: public Color getRightBorderColor() {
0432: return JRStyleResolver.getRightBorderColor(this );
0433: }
0434:
0435: public Color getOwnRightBorderColor() {
0436: return rightBorderColor;
0437: }
0438:
0439: public Integer getRightPadding() {
0440: return JRStyleResolver.getRightPadding(this );
0441: }
0442:
0443: public Integer getOwnRightPadding() {
0444: return rightPadding;
0445: }
0446:
0447: public Byte getRotation() {
0448: return JRStyleResolver.getRotation(this );
0449: }
0450:
0451: public Byte getOwnRotation() {
0452: return rotation;
0453: }
0454:
0455: public Byte getLineSpacing() {
0456: return JRStyleResolver.getLineSpacing(this );
0457: }
0458:
0459: public Byte getOwnLineSpacing() {
0460: return lineSpacing;
0461: }
0462:
0463: public Boolean isStyledText() {
0464: return JRStyleResolver.isStyledText(this );
0465: }
0466:
0467: public Boolean isOwnStyledText() {
0468: return isStyledText;
0469: }
0470:
0471: public Boolean isBlankWhenNull() {
0472: return JRStyleResolver.isBlankWhenNull(this );
0473: }
0474:
0475: public Boolean isOwnBlankWhenNull() {
0476: return isStyledText;
0477: }
0478:
0479: public String getFontName() {
0480: return JRStyleResolver.getFontName(this );
0481: }
0482:
0483: public String getOwnFontName() {
0484: return fontName;
0485: }
0486:
0487: public Boolean isBold() {
0488: return JRStyleResolver.isBold(this );
0489: }
0490:
0491: public Boolean isOwnBold() {
0492: return isBold;
0493: }
0494:
0495: public Boolean isItalic() {
0496: return JRStyleResolver.isItalic(this );
0497: }
0498:
0499: public Boolean isOwnItalic() {
0500: return isItalic;
0501: }
0502:
0503: public Boolean isUnderline() {
0504: return JRStyleResolver.isUnderline(this );
0505: }
0506:
0507: public Boolean isOwnUnderline() {
0508: return isUnderline;
0509: }
0510:
0511: public Boolean isStrikeThrough() {
0512: return JRStyleResolver.isStrikeThrough(this );
0513: }
0514:
0515: public Boolean isOwnStrikeThrough() {
0516: return isStrikeThrough;
0517: }
0518:
0519: public Integer getFontSize() {
0520: return JRStyleResolver.getFontSize(this );
0521: }
0522:
0523: public Integer getOwnFontSize() {
0524: return fontSize;
0525: }
0526:
0527: public String getPdfFontName() {
0528: return JRStyleResolver.getPdfFontName(this );
0529: }
0530:
0531: public String getOwnPdfFontName() {
0532: return pdfFontName;
0533: }
0534:
0535: public String getPdfEncoding() {
0536: return JRStyleResolver.getPdfEncoding(this );
0537: }
0538:
0539: public String getOwnPdfEncoding() {
0540: return pdfEncoding;
0541: }
0542:
0543: public Boolean isPdfEmbedded() {
0544: return JRStyleResolver.isPdfEmbedded(this );
0545: }
0546:
0547: public Boolean isOwnPdfEmbedded() {
0548: return isPdfEmbedded;
0549: }
0550:
0551: public String getPattern() {
0552: return JRStyleResolver.getPattern(this );
0553: }
0554:
0555: public String getOwnPattern() {
0556: return pattern;
0557: }
0558:
0559: public Byte getMode() {
0560: return JRStyleResolver.getMode(this );
0561: }
0562:
0563: public Byte getOwnMode() {
0564: return mode;
0565: }
0566:
0567: /**
0568: *
0569: */
0570: public void setForecolor(Color forecolor) {
0571: this .forecolor = forecolor;
0572: }
0573:
0574: /**
0575: *
0576: */
0577: public void setBackcolor(Color backcolor) {
0578: this .backcolor = backcolor;
0579: }
0580:
0581: /**
0582: *
0583: */
0584: public void setMode(byte mode) {
0585: setMode(new Byte(mode));
0586: }
0587:
0588: /**
0589: *
0590: */
0591: public void setMode(Byte mode) {
0592: this .mode = mode;
0593: }
0594:
0595: /**
0596: *
0597: */
0598: public void setPen(byte pen) {
0599: setPen(new Byte(pen));
0600: }
0601:
0602: /**
0603: *
0604: */
0605: public void setPen(Byte pen) {
0606: this .pen = pen;
0607: }
0608:
0609: /**
0610: *
0611: */
0612: public void setFill(byte fill) {
0613: setFill(new Byte(fill));
0614: }
0615:
0616: /**
0617: *
0618: */
0619: public void setFill(Byte fill) {
0620: this .fill = fill;
0621: }
0622:
0623: /**
0624: *
0625: */
0626: public void setRadius(int radius) {
0627: setRadius(new Integer(radius));
0628: }
0629:
0630: /**
0631: *
0632: */
0633: public void setRadius(Integer radius) {
0634: this .radius = radius;
0635: }
0636:
0637: /**
0638: *
0639: */
0640: public void setScaleImage(byte scaleImage) {
0641: setScaleImage(new Byte(scaleImage));
0642: }
0643:
0644: /**
0645: *
0646: */
0647: public void setScaleImage(Byte scaleImage) {
0648: this .scaleImage = scaleImage;
0649: }
0650:
0651: /**
0652: *
0653: */
0654: public void setHorizontalAlignment(byte horizontalAlignment) {
0655: setHorizontalAlignment(new Byte(horizontalAlignment));
0656: }
0657:
0658: /**
0659: *
0660: */
0661: public void setHorizontalAlignment(Byte horizontalAlignment) {
0662: this .horizontalAlignment = horizontalAlignment;
0663: }
0664:
0665: /**
0666: *
0667: */
0668: public void setVerticalAlignment(byte verticalAlignment) {
0669: setVerticalAlignment(new Byte(verticalAlignment));
0670: }
0671:
0672: /**
0673: *
0674: */
0675: public void setVerticalAlignment(Byte verticalAlignment) {
0676: this .verticalAlignment = verticalAlignment;
0677: }
0678:
0679: /**
0680: *
0681: */
0682: public void setBorder(byte border) {
0683: setBorder(new Byte(border));
0684: }
0685:
0686: /**
0687: *
0688: */
0689: public void setBorder(Byte border) {
0690: this .border = border;
0691: }
0692:
0693: /**
0694: *
0695: */
0696: public void setBorderColor(Color borderColor) {
0697: this .borderColor = borderColor;
0698: }
0699:
0700: /**
0701: *
0702: */
0703: public void setPadding(int padding) {
0704: setPadding(new Integer(padding));
0705: }
0706:
0707: /**
0708: *
0709: */
0710: public void setPadding(Integer padding) {
0711: this .padding = padding;
0712: }
0713:
0714: /**
0715: *
0716: */
0717: public void setTopBorder(byte topBorder) {
0718: setTopBorder(new Byte(topBorder));
0719: }
0720:
0721: /**
0722: *
0723: */
0724: public void setTopBorder(Byte topBorder) {
0725: this .topBorder = topBorder;
0726: }
0727:
0728: /**
0729: *
0730: */
0731: public void setTopBorderColor(Color topBorderColor) {
0732: this .topBorderColor = topBorderColor;
0733: }
0734:
0735: /**
0736: *
0737: */
0738: public void setTopPadding(int topPadding) {
0739: setTopPadding(new Integer(topPadding));
0740: }
0741:
0742: /**
0743: *
0744: */
0745: public void setTopPadding(Integer topPadding) {
0746: this .topPadding = topPadding;
0747: }
0748:
0749: /**
0750: *
0751: */
0752: public void setLeftBorder(byte leftBorder) {
0753: setLeftBorder(new Byte(leftBorder));
0754: }
0755:
0756: /**
0757: *
0758: */
0759: public void setLeftBorder(Byte leftBorder) {
0760: this .leftBorder = leftBorder;
0761: }
0762:
0763: /**
0764: *
0765: */
0766: public void setLeftBorderColor(Color leftBorderColor) {
0767: this .leftBorderColor = leftBorderColor;
0768: }
0769:
0770: /**
0771: *
0772: */
0773: public void setLeftPadding(int leftPadding) {
0774: setLeftPadding(new Integer(leftPadding));
0775: }
0776:
0777: /**
0778: *
0779: */
0780: public void setLeftPadding(Integer leftPadding) {
0781: this .leftPadding = leftPadding;
0782: }
0783:
0784: /**
0785: *
0786: */
0787: public void setBottomBorder(byte bottomBorder) {
0788: setBottomBorder(new Byte(bottomBorder));
0789: }
0790:
0791: /**
0792: *
0793: */
0794: public void setBottomBorder(Byte bottomBorder) {
0795: this .bottomBorder = bottomBorder;
0796: }
0797:
0798: /**
0799: *
0800: */
0801: public void setBottomBorderColor(Color bottomBorderColor) {
0802: this .bottomBorderColor = bottomBorderColor;
0803: }
0804:
0805: /**
0806: *
0807: */
0808: public void setBottomPadding(int bottomPadding) {
0809: setBottomPadding(new Integer(bottomPadding));
0810: }
0811:
0812: /**
0813: *
0814: */
0815: public void setBottomPadding(Integer bottomPadding) {
0816: this .bottomPadding = bottomPadding;
0817: }
0818:
0819: /**
0820: *
0821: */
0822: public void setRightBorder(byte rightBorder) {
0823: setRightBorder(new Byte(rightBorder));
0824: }
0825:
0826: /**
0827: *
0828: */
0829: public void setRightBorder(Byte rightBorder) {
0830: this .rightBorder = rightBorder;
0831: }
0832:
0833: /**
0834: *
0835: */
0836: public void setRightBorderColor(Color rightBorderColor) {
0837: this .rightBorderColor = rightBorderColor;
0838: }
0839:
0840: /**
0841: *
0842: */
0843: public void setRightPadding(int rightPadding) {
0844: setRightPadding(new Integer(rightPadding));
0845: }
0846:
0847: /**
0848: *
0849: */
0850: public void setRightPadding(Integer rightPadding) {
0851: this .rightPadding = rightPadding;
0852: }
0853:
0854: /**
0855: *
0856: */
0857: public void setRotation(byte rotation) {
0858: setRotation(new Byte(rotation));
0859: }
0860:
0861: /**
0862: *
0863: */
0864: public void setRotation(Byte rotation) {
0865: this .rotation = rotation;
0866: }
0867:
0868: /**
0869: *
0870: */
0871: public void setFontName(String fontName) {
0872: this .fontName = fontName;
0873: }
0874:
0875: /**
0876: *
0877: */
0878: public void setBold(boolean bold) {
0879: setBold(bold ? Boolean.TRUE : Boolean.FALSE);
0880: }
0881:
0882: /**
0883: *
0884: */
0885: public void setBold(Boolean bold) {
0886: this .isBold = bold;
0887: }
0888:
0889: /**
0890: *
0891: */
0892: public void setItalic(boolean italic) {
0893: setItalic(italic ? Boolean.TRUE : Boolean.FALSE);
0894: }
0895:
0896: /**
0897: *
0898: */
0899: public void setItalic(Boolean italic) {
0900: this .isItalic = italic;
0901: }
0902:
0903: /**
0904: *
0905: */
0906: public void setPdfEmbedded(boolean pdfEmbedded) {
0907: setPdfEmbedded(pdfEmbedded ? Boolean.TRUE : Boolean.FALSE);
0908: }
0909:
0910: /**
0911: *
0912: */
0913: public void setPdfEmbedded(Boolean pdfEmbedded) {
0914: this .isPdfEmbedded = pdfEmbedded;
0915: }
0916:
0917: /**
0918: *
0919: */
0920: public void setStrikeThrough(boolean strikeThrough) {
0921: setStrikeThrough(strikeThrough ? Boolean.TRUE : Boolean.FALSE);
0922: }
0923:
0924: /**
0925: *
0926: */
0927: public void setStrikeThrough(Boolean strikeThrough) {
0928: this .isStrikeThrough = strikeThrough;
0929: }
0930:
0931: /**
0932: *
0933: */
0934: public void setStyledText(boolean styledText) {
0935: setStyledText(styledText ? Boolean.TRUE : Boolean.FALSE);
0936: }
0937:
0938: /**
0939: *
0940: */
0941: public void setStyledText(Boolean styledText) {
0942: this .isStyledText = styledText;
0943: }
0944:
0945: /**
0946: *
0947: */
0948: public void setBlankWhenNull(boolean isBlankWhenNull) {
0949: setBlankWhenNull(isBlankWhenNull ? Boolean.TRUE : Boolean.FALSE);
0950: }
0951:
0952: /**
0953: *
0954: */
0955: public void setBlankWhenNull(Boolean isBlankWhenNull) {
0956: this .isBlankWhenNull = isBlankWhenNull;
0957: }
0958:
0959: /**
0960: *
0961: */
0962: public void setUnderline(boolean underline) {
0963: setUnderline(underline ? Boolean.TRUE : Boolean.FALSE);
0964: }
0965:
0966: /**
0967: *
0968: */
0969: public void setUnderline(Boolean underline) {
0970: this .isUnderline = underline;
0971: }
0972:
0973: /**
0974: *
0975: */
0976: public void setLineSpacing(byte lineSpacing) {
0977: setLineSpacing(new Byte(lineSpacing));
0978: }
0979:
0980: /**
0981: *
0982: */
0983: public void setLineSpacing(Byte lineSpacing) {
0984: this .lineSpacing = lineSpacing;
0985: }
0986:
0987: /**
0988: *
0989: */
0990: public void setPattern(String pattern) {
0991: this .pattern = pattern;
0992: }
0993:
0994: /**
0995: *
0996: */
0997: public void setPdfEncoding(String pdfEncoding) {
0998: this .pdfEncoding = pdfEncoding;
0999: }
1000:
1001: /**
1002: *
1003: */
1004: public void setPdfFontName(String pdfFontName) {
1005: this .pdfFontName = pdfFontName;
1006: }
1007:
1008: /**
1009: *
1010: */
1011: public void setFontSize(int fontSize) {
1012: setFontSize(new Integer(fontSize));
1013: }
1014:
1015: /**
1016: *
1017: */
1018: public void setFontSize(Integer fontSize) {
1019: this .fontSize = fontSize;
1020: }
1021:
1022: /**
1023: *
1024: */
1025: public JRConditionalStyle[] getConditionalStyles() {
1026: return conditionalStyles;
1027: }
1028:
1029: public String getStyleNameReference() {
1030: return parentStyleNameReference;
1031: }
1032:
1033: }
|