@Override public void paintComponent(Graphics g) { g.setColor(getBackground()); g.fillRect(0, 0, getWidth(), getHeight()); int w = bufferedImage.getWidth(this); int h = bufferedImage.getHeight(this); if (mode == Flip.NONE) { g.drawImage(bufferedImage, 0, 0, w, h, this); } else if (mode == Flip.VERTICAL) { AffineTransform at = AffineTransform.getScaleInstance(1d, -1d); at.translate(0, -h); Graphics2D g2 = (Graphics2D) g.create(); g2.drawImage(bufferedImage, at, this); g2.dispose(); } else if (mode == Flip.HORIZONTAL) { AffineTransform at = AffineTransform.getScaleInstance(-1d, 1d); at.translate(-w, 0); AffineTransformOp atOp = new AffineTransformOp(at, null); g.drawImage(atOp.filter(bufferedImage, null), 0, 0, w, h, this); } }
private BufferedImage createReflection(BufferedImage item, int itemWidth, int itemHeight) { BufferedImage buffer = new BufferedImage(itemWidth, itemHeight << 1, BufferedImage.TYPE_INT_ARGB); Graphics2D g = buffer.createGraphics(); g.drawImage(item, null, null); g.translate(0, itemHeight << 1); AffineTransform reflectTransform = AffineTransform.getScaleInstance(1.0, -1.0); g.drawImage(item, reflectTransform, null); g.translate(0, -(itemHeight << 1)); g.dispose(); return buffer; }
public void paintComponent(Graphics g1) { Graphics2D g = (Graphics2D) g1; float width = getWidth(); float height = getHeight(); AffineTransform save = g.getTransform(); AffineTransform save_tmp; g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); if (45.0 <= rotate && rotate < 135.0) { g.translate(width, 0.0); g.rotate(Math.PI * rotate / 180, 0.0, 0.0); g.transform( AffineTransform.getScaleInstance(height / original_width, width / original_height)); } else if (135.0 <= rotate && rotate < 225.0) { g.rotate(Math.PI * rotate / 180, width / 2, height / 2); g.transform( AffineTransform.getScaleInstance(width / original_width, height / original_height)); } else if (225.0 <= rotate && rotate < 315.0) { g.translate(-height, 0.0); g.rotate(Math.PI * rotate / 180, height, 0.0); g.transform( AffineTransform.getScaleInstance(height / original_width, width / original_height)); } else g.transform( AffineTransform.getScaleInstance(width / original_width, height / original_height)); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 30, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[0]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 32, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[1]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 32, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[2]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 33, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[3]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 33, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[4]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 32, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[5]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 30, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[6]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 33, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[7]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 32, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[8]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 30, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[9]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 32, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[10]); g.setStroke(new BasicStroke(2F)); g.setColor( GeColor.getColor( 32, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[11]); g.setTransform(save); }
public void paintComponent(Graphics g1) { animationCount = 1; if (!visible) return; Graphics2D g = (Graphics2D) g1; float width = getWidth(); float height = getHeight(); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); if (45.0 <= rotate && rotate < 135.0) { g.translate(width, 0.0); g.rotate(Math.PI * rotate / 180, 0.0, 0.0); g.transform( AffineTransform.getScaleInstance(height / original_width, width / original_height)); } else if (135.0 <= rotate && rotate < 225.0) { g.rotate(Math.PI * rotate / 180, width / 2, height / 2); g.transform( AffineTransform.getScaleInstance(width / original_width, height / original_height)); } else if (225.0 <= rotate && rotate < 315.0) { g.translate(-height, 0.0); g.rotate(Math.PI * rotate / 180, height, 0.0); g.transform( AffineTransform.getScaleInstance(height / original_width, width / original_height)); } else g.transform( AffineTransform.getScaleInstance(width / original_width, height / original_height)); if ((dd.dynType & GeDyn.mDynType_Rotate) != 0 && dd.rotate != 0) { g.rotate( Math.PI * dd.rotate / 180, (dd.x0 - getX()) * original_width / width, (dd.y0 - getY()) * original_height / height); } AffineTransform save = g.getTransform(); AffineTransform save_tmp; int rounds = 1; if (fillLevel != 1F) rounds = 2; int oldColor = 0; for (int i = 0; i < rounds; i++) { if (rounds == 2) { switch (i) { case 0: if (levelColorTone != GeColor.COLOR_TONE_NO) { oldColor = colorTone; colorTone = levelColorTone; } else if (levelFillColor != GeColor.COLOR_NO) { oldColor = fillColor; fillColor = levelFillColor; } break; case 1: if (levelColorTone != GeColor.COLOR_TONE_NO) colorTone = oldColor; else if (levelFillColor != GeColor.COLOR_NO) fillColor = oldColor; break; } switch (levelDirection) { case Ge.DIRECTION_UP: if (i == 0) g.setClip( new Rectangle2D.Float( 0F, fillLevel * original_height + Ge.cJBean_Offset, original_width, original_height)); else g.setClip( new Rectangle2D.Float( 0F, 0F, original_width, fillLevel * original_height + Ge.cJBean_Offset)); break; case Ge.DIRECTION_DOWN: if (i == 0) g.setClip( new Rectangle2D.Float( 0F, 0F, original_width, (1 - fillLevel) * original_height + Ge.cJBean_Offset)); else g.setClip( new Rectangle2D.Float( 0F, (1 - fillLevel) * original_height + Ge.cJBean_Offset, original_width, original_height)); break; case Ge.DIRECTION_RIGHT: if (i == 0) g.setClip( new Rectangle2D.Float( fillLevel * original_width + Ge.cJBean_Offset, 0F, original_width, original_height)); else g.setClip( new Rectangle2D.Float(0F, 0F, fillLevel * width + Ge.cJBean_Offset, height)); break; case Ge.DIRECTION_LEFT: if (i == 0) g.setClip( new Rectangle2D.Float( 0F, 0F, (1 - fillLevel) * original_width + Ge.cJBean_Offset, original_height)); else g.setClip( new Rectangle2D.Float( (1 - fillLevel) * original_width + Ge.cJBean_Offset, 0F, original_width, original_height)); break; } } { int fcolor = GeColor.getDrawtype( 293, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, fillColor, dimmed); if (gradient == GeGradient.eGradient_No) { g.setColor(GeColor.getColor(fcolor)); g.fill(shapes[0]); } else { GeGradient.paint( g, gradient, 2, -2, 2F, 2F, 13.6808F, 14.8208F, false, 293, colorTone, colorShift, colorIntensity, colorInverse, fillColor, dimmed); g.fill(shapes[0]); } if (shadow != 0) { g.setColor(GeColor.shiftColor(fcolor, -2, colorInverse)); g.fill(shapes[1]); g.setColor(GeColor.shiftColor(fcolor, 2, colorInverse)); g.fill(shapes[2]); } g.setStroke(new BasicStroke(1F)); g.setColor( GeColor.getColor( 0, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, dimmed)); g.draw(shapes[0]); } } if (rounds == 2) g.setClip(null); g.setTransform(save); }
public void paintComponent(Graphics g1) { Graphics2D g = (Graphics2D) g1; float width = getWidth(); float height = getHeight(); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); double scaleWidth = (1.0 * width / original_width); double scaleHeight = (1.0 * height / original_height); AffineTransform save = g.getTransform(); g.setColor(getBackground()); g.fill(new Rectangle(0, 0, getWidth(), getHeight())); g.transform(AffineTransform.getScaleInstance(scaleWidth, scaleHeight)); // scaletest AffineTransform save_tmp; g.setColor( GeColor.getColor( 0, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, textColor, dimmed)); g.setFont(new Font("Helvetica", Font.BOLD, 12)); g.drawString(JopLang.transl("Status"), 13, 91); g.setColor( GeColor.getColor( 0, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, textColor, dimmed)); g.setFont(new Font("Helvetica", Font.BOLD, 12)); g.drawString(JopLang.transl("LogMessage"), 13, 114); g.setColor( GeColor.getColor( 0, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, textColor, dimmed)); g.setFont(new Font("Helvetica", Font.BOLD, 12)); g.drawString(JopLang.transl("EventListSize"), 13, 23); g.setColor( GeColor.getColor( 0, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, textColor, dimmed)); g.setFont(new Font("Helvetica", Font.BOLD, 12)); g.drawString(JopLang.transl("EventLogSize"), 13, 44); g.setColor( GeColor.getColor( 0, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, textColor, dimmed)); g.setFont(new Font("Helvetica", Font.BOLD, 12)); g.drawString(JopLang.transl("MaxApplAlarms"), 13, 67); g.setTransform(save); }
public class TestType1CFont extends JPanel implements KeyListener { int encoding[] = new int[256]; // glyph at position i has code encoding[i] int glyphnames[]; // glyph at position i has name SID glyphnames[i] String names[]; // extra names for this font (others in FontSupport) // String safenames[]; // names without high-bit characters HashMap<String, GlyphData> charset = new HashMap<String, GlyphData>(); ArrayList<String> charnames = new ArrayList<String>(); int charcounter = -1; byte[] data; int pos; byte[] subrs[]; float[] stack = new float[100]; int stackptr = 0; AffineTransform at = new AffineTransform(0.001f, 0, 0, 0.001f, 0, 0); int num; float fnum; int type; static int CMD = 0; static int NUM = 1; static int FLT = 2; public boolean isRequestFocusEnabled() { return true; } public TestType1CFont(InputStream is) throws IOException { super(); setPreferredSize(new Dimension(800, 800)); addKeyListener(this); BufferedInputStream bis = new BufferedInputStream(is); int count = 0; ArrayList<byte[]> al = new ArrayList<byte[]>(); byte b[] = new byte[32000]; int len; while ((len = bis.read(b, 0, b.length)) >= 0) { byte[] c = new byte[len]; System.arraycopy(b, 0, c, 0, len); al.add(c); count += len; b = new byte[32000]; } data = new byte[count]; len = 0; for (int i = 0; i < al.size(); i++) { byte from[] = al.get(i); System.arraycopy(from, 0, data, len, from.length); len += from.length; } pos = 0; // printData(); parse(); // TODO: free up (set to null) unused structures (data, subrs, stack) } GlyphData showing; String showname; Font gfont = new Font("Sans-serif", Font.PLAIN, 24).deriveFont(AffineTransform.getScaleInstance(1, -1)); Color fillColor = new Color(0xe0, 0xff, 0xff); public void keyTyped(KeyEvent evt) {} public void keyReleased(KeyEvent evt) {} public void keyPressed(KeyEvent evt) { if (evt.getKeyCode() == evt.VK_RIGHT) { charcounter++; if (charcounter >= charnames.size()) { charcounter = 0; } showing = readGlyph((String) charnames.get(charcounter)); } else if (evt.getKeyCode() == evt.VK_LEFT) { charcounter--; if (charcounter < 0) { charcounter = charnames.size() - 1; } showing = readGlyph((String) charnames.get(charcounter)); } else { char c = evt.getKeyChar(); // System.out.println("Got char: "+name); showing = readGlyph(FontSupport.stdNames[FontSupport.standardEncoding[(int) c & 0xff]]); } repaint(); } public void paint(Graphics g) { Graphics2D g2 = (Graphics2D) g; g2.setColor(Color.white); g2.fillRect(0, 0, getWidth(), getHeight()); AffineTransform at = new AffineTransform(0.5, 0, 0, -0.5, 30, getHeight() * 3 / 4); g2.transform(at); g2.setColor(Color.black); g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.setRenderingHint( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON); // System.out.println("Showing="+showing); if (showing != null) { showing.draw(g2); } } private void printData() { char[] parts = new char[17]; int partsloc = 0; for (int i = 0; i < data.length; i++) { int d = ((int) data[i]) & 0xff; if (d == 0) { parts[partsloc++] = '.'; } else if (d < 32 || d >= 127) { parts[partsloc++] = '?'; } else { parts[partsloc++] = (char) d; } if (d < 16) { System.out.print("0" + Integer.toHexString(d)); } else { System.out.print(Integer.toHexString(d)); } if ((i & 15) == 15) { System.out.println(" " + new String(parts)); partsloc = 0; } else if ((i & 7) == 7) { System.out.print(" "); parts[partsloc++] = ' '; } else if ((i & 1) == 1) { System.out.print(" "); } } System.out.println(); } private int readNext(boolean charstring) { num = (int) (data[pos++]) & 0xff; if (num == 30 && !charstring) { // goofy floatingpoint rep readFNum(); return type = FLT; } else if (num == 28) { num = (((int) data[pos]) << 8) + (((int) data[pos + 1]) & 0xff); pos += 2; return type = NUM; } else if (num == 29 && !charstring) { num = (((int) data[pos] & 0xff) << 24) | (((int) data[pos + 1] & 0xff) << 16) | (((int) data[pos + 2] & 0xff) << 8) | (((int) data[pos + 3] & 0xff)); pos += 4; return type = NUM; } else if (num == 12) { // two-byte command num = 1000 + ((int) (data[pos++]) & 0xff); return type = CMD; } else if (num < 32) { return type = CMD; } else if (num < 247) { num -= 139; return type = NUM; } else if (num < 251) { num = (num - 247) * 256 + (((int) data[pos++]) & 0xff) + 108; return type = NUM; } else if (num < 255) { num = -(num - 251) * 256 - (((int) data[pos++]) & 0xff) - 108; return type = NUM; } else if (!charstring) { // dict shouldn't have a 255 code printData(); throw new RuntimeException("Got a 255 code while reading dict"); } else { // num was 255 fnum = ((((int) data[pos] & 0xff) << 24) | (((int) data[pos + 1] & 0xff) << 16) | (((int) data[pos + 2] & 0xff) << 8) | (((int) data[pos + 3] & 0xff))) / 65536f; pos += 4; return type = FLT; } } public void readFNum() { // work in nybbles: 0-9=0-9, a=. b=E, c=E-, d=rsvd e=neg f=end float f = 0; boolean neg = false; int exp = 0; int eval = 0; float mul = 1; byte work = data[pos++]; while (true) { if (work == (byte) 0xdd) { work = data[pos++]; } int nyb = (work >> 4) & 0xf; work = (byte) ((work << 4) | 0xd); if (nyb < 10) { if (exp != 0) { // working on the exponent eval = eval * 10 + nyb; } else if (mul == 1) { // working on an int f = f * 10 + nyb; } else { // working on decimal part f += nyb * mul; mul /= 10f; } } else if (nyb == 0xa) { // decimal mul = 0.1f; } else if (nyb == 0xb) { // E+ exp = 1; } else if (nyb == 0xc) { // E- exp = -1; } else if (nyb == 0xe) { // neg neg = true; } else { break; } } fnum = (neg ? -1 : 1) * f * (float) Math.pow(10, eval * exp); } private int readInt(int len) { int n = 0; for (int i = 0; i < len; i++) { n = (n << 8) | (((int) data[pos++]) & 0xff); } return n; } private int readByte() { return ((int) data[pos++]) & 0xff; } // DICT structure: // operand operator operand operator ... // INDEX structure: // count(2) offsize [offset offset ... offset] data // offset array has count+1 entries // data starts at 3+(count+1)*offsize // offset for data is offset+2+(count+1)*offsize public int getIndexSize(int loc) { // System.out.println("Getting size of index at "+loc); int hold = pos; pos = loc; int count = readInt(2); if (count == 0) { return 2; } int encsz = readByte(); // pos is now at the first offset. last offset is at count*encsz pos += count * encsz; int end = readInt(encsz); pos = hold; return 2 + (count + 1) * encsz + end; } class Range { private int start; private int len; public Range(int start, int len) { this.start = start; this.len = len; } public final int getStart() { return start; } public final int getLen() { return len; } public final int getEnd() { return start + len; } } public Range getIndexEntry(int index, int id) { int hold = pos; pos = index; int count = readInt(2); int encsz = readByte(); pos += encsz * id; int from = readInt(encsz); Range r = new Range(from + 2 + index + encsz * (count + 1), readInt(encsz) - from); pos = hold; return r; } // Top DICT: NAME CODE DEFAULT // charstringtype 12 6 2 // fontmatrix 12 7 0.001 0 0 0.001 // charset 15 - (offset) names of glyphs (ref to name idx) // encoding 16 - (offset) array of codes // CharStrings 17 - (offset) // Private 18 - (size, offset) // glyph at position i in CharStrings has name charset[i] // and code encoding[i] int charstringtype = 2; float temps[] = new float[32]; int charsetbase = 0; int encodingbase = 0; int charstringbase = 0; int privatebase = 0; int privatesize = 0; int gsubrbase = 0; int lsubrbase = 0; int gsubrsoffset = 0; int lsubrsoffset = 0; int defaultWidthX = 0; int nominalWidthX = 0; int nglyphs = 1; private void readDict(Range r) { // System.out.println("reading dictionary from "+r.getStart()+" to "+r.getEnd()); pos = r.getStart(); while (pos < r.getEnd()) { int cmd = readCommand(false); if (cmd == 1006) { // charstringtype, default=2 charstringtype = (int) stack[0]; } else if (cmd == 1007) { // fontmatrix if (stackptr == 4) { at = new AffineTransform( (float) stack[0], (float) stack[1], (float) stack[2], (float) stack[3], 0, 0); } else { at = new AffineTransform( (float) stack[0], (float) stack[1], (float) stack[2], (float) stack[3], (float) stack[4], (float) stack[5]); } } else if (cmd == 15) { // charset charsetbase = (int) stack[0]; } else if (cmd == 16) { // encoding encodingbase = (int) stack[0]; } else if (cmd == 17) { // charstrings charstringbase = (int) stack[0]; } else if (cmd == 18) { // private privatesize = (int) stack[0]; privatebase = (int) stack[1]; } else if (cmd == 19) { // subrs (in Private dict) lsubrbase = (int) stack[0]; lsubrsoffset = calcoffset(lsubrbase); } else if (cmd == 20) { // defaultWidthX (in Private dict) defaultWidthX = (int) stack[0]; } else if (cmd == 21) { // nominalWidthX (in Private dict) nominalWidthX = (int) stack[0]; } stackptr = 0; } } private int readCommand(boolean charstring) { while (true) { int type = readNext(charstring); if (type == CMD) { System.out.print("CMD= " + num + ", args="); for (int i = 0; i < stackptr; i++) { System.out.print(" " + stack[i]); } System.out.println(); return num; } else { stack[stackptr++] = (type == NUM) ? (float) num : (float) fnum; } } } private void readEncodingData(int base) { if (base == 0) { // this is the StandardEncoding System.out.println("**** STANDARD ENCODING!"); // TODO: copy standard encoding } else if (base == 1) { // this is the expert encoding System.out.println("**** EXPERT ENCODING!"); // TODO: copy ExpertEncoding } else { pos = base; int encodingtype = readByte(); if ((encodingtype & 127) == 0) { System.out.println("**** Type 0 Encoding:"); int ncodes = readByte(); for (int i = 1; i < ncodes + 1; i++) { encoding[i] = readByte(); System.out.println("Encoding[" + i + "] = " + encoding[i]); } } else if ((encodingtype & 127) == 1) { System.out.println("**** Type 1 Encoding:"); int nranges = readByte(); int pos = 0; for (int i = 0; i < nranges; i++) { int start = readByte(); int more = readByte(); for (int j = start; j < start + more + 1; j++) { System.out.println("Encoding[" + pos + "] = " + j); encoding[pos++] = j; } } } else { System.out.println("Bad encoding type: " + encodingtype); } // TODO: now check for supplemental encoding data } } private void readGlyphNames(int base) { if (base == 0) { System.out.println("**** Identity glyphNames"); glyphnames = new int[229]; for (int i = 0; i < glyphnames.length; i++) { glyphnames[i] = i; } return; } else if (base == 1) { System.out.println("**** Type1CExpertCharset glyphNames"); glyphnames = FontSupport.type1CExpertCharset; return; } else if (base == 2) { System.out.println("**** Type1CExpertSubCharset glyphNames"); glyphnames = FontSupport.type1CExpertSubCharset; return; } System.out.print("**** Custom glyphNames Type "); // nglyphs has already been set. glyphnames = new int[nglyphs]; glyphnames[0] = 0; pos = base; int type = readByte(); if (type == 0) { System.out.println("0"); for (int i = 1; i < nglyphs; i++) { glyphnames[i] = readInt(2); System.out.println("glyphnames[" + i + "] = " + glyphnames[i]); } } else if (type == 1) { System.out.println("1"); int n = 1; while (n < nglyphs) { int sid = readInt(2); int range = readByte() + 1; for (int i = 0; i < range; i++) { System.out.println("glyphnames[" + n + "] = " + sid); glyphnames[n++] = sid++; } } } else if (type == 2) { System.out.println("2"); int n = 1; while (n < nglyphs) { int sid = readInt(2); int range = readInt(2) + 1; for (int i = 0; i < range; i++) { System.out.println("glyphnames[" + n + "] = " + sid); glyphnames[n++] = sid++; } } } } private void readNames(int base) { pos = base; int nextra = readInt(2); names = new String[nextra]; // safenames= new String[nextra]; for (int i = 0; i < nextra; i++) { Range r = getIndexEntry(base, i); names[i] = new String(data, r.getStart(), r.getLen()); System.out.println( "Read name: " + i + " from " + r.getStart() + " to " + r.getEnd() + ": " + safe(names[i])); } } private void parse() { int majorVersion = readByte(); int minorVersion = readByte(); int hdrsz = readByte(); int offsize = readByte(); // jump over rest of header: base of font names index int fnames = hdrsz; // offset in the file of the array of font dicts int topdicts = fnames + getIndexSize(fnames); // offset in the file of local names int names = topdicts + getIndexSize(topdicts); // offset in the file of the array of global subroutines gsubrbase = names + getIndexSize(names); gsubrsoffset = calcoffset(gsubrbase); // read extra names readNames(names); // does this file have more than one font? pos = topdicts; if (readInt(2) != 1) { printData(); throw new RuntimeException("More than one font in this file!"); } // read first dict System.out.println("TOPDICT[0]:"); readDict(getIndexEntry(topdicts, 0)); // read the private dictionary System.out.println("PRIVATE DICT:"); readDict(new Range(privatebase, privatesize)); // calculate the number of glyphs pos = charstringbase; nglyphs = readInt(2); // now get the glyph names System.out.println("GLYPHNAMES:"); readGlyphNames(charsetbase); // now figure out the encoding System.out.println("ENCODING:"); readEncodingData(encodingbase); // now get the glyphs System.out.println("GLYPHS:"); readGlyphs(charstringbase); } private String safe(String src) { StringBuffer sb = new StringBuffer(); for (int i = 0; i < src.length(); i++) { char c = src.charAt(i); if (c >= 32 && c < 128) { sb.append(c); } else { sb.append("<" + (int) c + ">"); } } return sb.toString(); } class GlyphPoint { float x, y; boolean curvecontrol; GeneralPath gp; public GlyphPoint(float x, float y, boolean curvectrl) { this.x = x; this.y = y; this.curvecontrol = curvectrl; gp = new GeneralPath(); if (curvectrl) { gp.moveTo(x - 4, y - 4); gp.lineTo(x + 4, y + 4); gp.moveTo(x - 4, y + 4); gp.lineTo(x + 4, y - 4); } else { gp.moveTo(x - 4, y - 4); gp.lineTo(x - 4, y + 4); gp.lineTo(x + 4, y + 4); gp.lineTo(x + 4, y - 4); gp.closePath(); } } } class GlyphData { GeneralPath gp; GeneralPath advp; ArrayList<GlyphPoint> points; float x, y; float advance; String name; public GlyphData() { gp = new GeneralPath(); // advp= new GeneralPath(); points = new ArrayList<GlyphPoint>(); x = y = 0; } public void setName(String name) { this.name = name; } public void lineTo(float x, float y) { gp.lineTo(x, y); this.x = x; this.y = y; points.add(new GlyphPoint(x, y, false)); } public void moveTo(float x, float y) { gp.moveTo(x, y); this.x = x; this.y = y; points.add(new GlyphPoint(x, y, false)); } public void curveTo(float x1, float y1, float x2, float y2, float x3, float y3) { gp.curveTo(x1, y1, x2, y2, x3, y3); this.x = x3; this.y = y3; points.add(new GlyphPoint(x1, y1, true)); points.add(new GlyphPoint(x2, y2, true)); points.add(new GlyphPoint(x3, y3, false)); } public void closePath() { gp.closePath(); } public void addGlyph(GlyphData gv, float x, float y) { AffineTransform at = AffineTransform.getTranslateInstance(x, y); PathIterator pi = gv.gp.getPathIterator(at); float[] coords = new float[6]; while (!pi.isDone()) { int type = pi.currentSegment(coords); switch (type) { case PathIterator.SEG_MOVETO: moveTo(coords[0], coords[1]); break; case PathIterator.SEG_LINETO: lineTo(coords[0], coords[1]); break; case PathIterator.SEG_CUBICTO: curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]); break; case PathIterator.SEG_CLOSE: closePath(); break; default: System.out.println("Unknown path type: " + type); break; } pi.next(); } } public void setAdvance(float adv) { advance = adv; advp = new GeneralPath(); advp.moveTo(-2, -2); advp.lineTo(2, 2); advp.moveTo(-2, 2); advp.lineTo(2, -2); advp.moveTo(adv - 2, -2); advp.lineTo(adv, 0); advp.lineTo(adv + 2, -2); advp.moveTo(adv, 0); advp.lineTo(adv, -8); } public void draw(Graphics2D g) { g.setColor(fillColor); g.fill(gp); g.setColor(Color.black); g.draw(gp); for (int i = 0; i < points.size(); i++) { GlyphPoint p = points.get(i); g.setColor(Color.red); g.draw(p.gp); g.setColor(Color.blue); g.setFont(gfont); g.drawString(String.valueOf(i), p.x + 3, p.y + 3); } g.setColor(Color.black); // System.out.println("Advance: "+advance); g.draw(advp); if (name != null) { g.setFont(gfont); g.drawString(name, 0, -40); } } } private void readGlyphs(int base) { for (int i = 1; i < nglyphs; i++) { System.out.println("Reading glyph " + safe(getSID(glyphnames[i]))); charnames.add(getSID(glyphnames[i])); } } /** Read a single glyph, given its offset */ public GlyphData readGlyph(String sid) { int index = getNameIndex(sid); // now find the glyph with that name for (int i = 0; i < glyphnames.length; i++) { if (glyphnames[i] == index) { return readGlyph(i); } } // not found -- return the unknown glyph return readGlyph(0); } /** Read a glyph, given an index */ public GlyphData readGlyph(int index) { String sid = getSID(index); if (charset.containsKey(sid)) { return (GlyphData) charset.get(sid); } Range r = getIndexEntry(charstringbase, index); FlPoint pt = new FlPoint(); GlyphData gd = new GlyphData(); parseGlyph(r, gd, pt); gd.setName(sid); charset.put(sid, gd); return gd; } /** * build an accented character out of two pre-defined glyphs. * * @param x the x offset of the accent * @param y the y offset of the accent * @param a the index of the base glyph * @param b the index of the accent glyph * @param gp the GeneralPath into which the combined glyph will be written. */ private void buildAccentChar(float x, float y, float a, float b, GlyphData gv) { System.out.println("Building accent character!!!!!!"); for (int i = 0; i < nglyphs; i++) { if (encoding[i] == (int) a) { gv.addGlyph(readGlyph(i + 1), x, y); } else if (encoding[i] == (int) b) { gv.addGlyph(readGlyph(i + 1), 0, 0); } } /* if (shapes[b]!=null) { gp.append(shapes[b], false); } if (shapes[a]!=null) { gp.append(shapes[a], false); }*/ } public int calcoffset(int base) { int len = getIndexSize(base); if (len < 1240) { return -107; } else if (len < 33900) { return -1131; } else { return -32768; } } public String getSID(int id) { if (id < FontSupport.stdNames.length) { return FontSupport.stdNames[id]; } else { id -= FontSupport.stdNames.length; return names[id]; } } /** * get the index of a particular name. The name table starts with the standard names in * FontSupport.stdNames, and is appended by any names in the name table from this font's * dictionary. */ private int getNameIndex(String name) { int val = FontSupport.findName(name, FontSupport.stdNames); if (val == -1) { val = FontSupport.findName(name, names) + FontSupport.stdNames.length; } if (val == -1) { val = 0; } return val; } public void parseGlyph(Range r, GlyphData gp, FlPoint pt) { pos = r.getStart(); int i; float x1, y1, x2, y2, x3, y3, ybase; int hold; int stemhints = 0; gp.setAdvance(defaultWidthX); while (pos < r.getEnd()) { int cmd = readCommand(true); hold = 0; switch (cmd) { case 1: // hstem case 3: // vstem if ((stackptr & 1) == 1) { gp.setAdvance(nominalWidthX + stack[0]); } stackptr = 0; break; case 4: // vmoveto if (stackptr > 1) { // this is the first call, arg1 is width gp.setAdvance(nominalWidthX + stack[0]); stack[0] = stack[1]; } pt.y += stack[0]; if (pt.open) { gp.closePath(); } pt.open = false; gp.moveTo(pt.x, pt.y); stackptr = 0; break; case 5: // rlineto for (i = 0; i < stackptr; ) { pt.x += stack[i++]; pt.y += stack[i++]; gp.lineTo(pt.x, pt.y); } pt.open = true; stackptr = 0; break; case 6: // hlineto for (i = 0; i < stackptr; ) { if ((i & 1) == 0) { pt.x += stack[i++]; } else { pt.y += stack[i++]; } gp.lineTo(pt.x, pt.y); } pt.open = true; stackptr = 0; break; case 7: // vlineto for (i = 0; i < stackptr; ) { if ((i & 1) == 0) { pt.y += stack[i++]; } else { pt.x += stack[i++]; } gp.lineTo(pt.x, pt.y); } pt.open = true; stackptr = 0; break; case 8: // rrcurveto for (i = 0; i < stackptr; ) { x1 = pt.x + stack[i++]; y1 = pt.y + stack[i++]; x2 = x1 + stack[i++]; y2 = y1 + stack[i++]; pt.x = x2 + stack[i++]; pt.y = y2 + stack[i++]; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); } pt.open = true; stackptr = 0; break; case 10: // callsubr hold = pos; i = (int) stack[--stackptr] + lsubrsoffset; Range lsubr = getIndexEntry(lsubrbase, i); parseGlyph(lsubr, gp, pt); pos = hold; break; case 11: // return return; case 14: // endchar if (stackptr == 5) { buildAccentChar(stack[1], stack[2], stack[3], stack[4], gp); } if (pt.open) { gp.closePath(); } pt.open = false; stackptr = 0; return; case 18: // hstemhm if ((stackptr & 1) == 1) { gp.setAdvance(nominalWidthX + stack[0]); } stemhints += stackptr / 2; stackptr = 0; break; case 19: // hintmask case 20: // cntrmask if ((stackptr & 1) == 1) { gp.setAdvance(nominalWidthX + stack[0]); } stemhints += stackptr / 2; System.out.println( "Added " + stackptr + " extra bits; skipping " + ((stemhints - 1) / 8 + 1) + " from " + stemhints); pos += (stemhints - 1) / 8 + 1; stackptr = 0; break; case 21: // rmoveto if (stackptr > 2) { gp.setAdvance(nominalWidthX + stack[0]); stack[0] = stack[1]; stack[1] = stack[2]; } pt.x += stack[0]; pt.y += stack[1]; if (pt.open) { gp.closePath(); } gp.moveTo(pt.x, pt.y); pt.open = false; stackptr = 0; break; case 22: // hmoveto if (stackptr > 1) { gp.setAdvance(nominalWidthX + stack[0]); stack[0] = stack[1]; } pt.x += stack[0]; if (pt.open) { gp.closePath(); } gp.moveTo(pt.x, pt.y); pt.open = false; stackptr = 0; break; case 23: // vstemhm if ((stackptr & 1) == 1) { gp.setAdvance(nominalWidthX + stack[0]); } stemhints += stackptr / 2; stackptr = 0; break; case 24: // rcurveline for (i = 0; i < stackptr - 2; ) { x1 = pt.x + stack[i++]; y1 = pt.y + stack[i++]; x2 = x1 + stack[i++]; y2 = y1 + stack[i++]; pt.x = x2 + stack[i++]; pt.y = y2 + stack[i++]; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); } pt.x += stack[i++]; pt.y += stack[i++]; gp.lineTo(pt.x, pt.y); pt.open = true; stackptr = 0; break; case 25: // rlinecurve for (i = 0; i < stackptr - 6; ) { pt.x += stack[i++]; pt.y += stack[i++]; gp.lineTo(pt.x, pt.y); } x1 = pt.x + stack[i++]; y1 = pt.y + stack[i++]; x2 = x1 + stack[i++]; y2 = y1 + stack[i++]; pt.x = x2 + stack[i++]; pt.y = y2 + stack[i++]; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); pt.open = true; stackptr = 0; break; case 26: // vvcurveto i = 0; if ((stackptr & 1) == 1) { // odd number of arguments pt.x += stack[i++]; } while (i < stackptr) { x1 = pt.x; y1 = pt.y + stack[i++]; x2 = x1 + stack[i++]; y2 = y1 + stack[i++]; pt.x = x2; pt.y = y2 + stack[i++]; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); } pt.open = true; stackptr = 0; break; case 27: // hhcurveto i = 0; if ((stackptr & 1) == 1) { // odd number of arguments pt.y += stack[i++]; } while (i < stackptr) { x1 = pt.x + stack[i++]; y1 = pt.y; x2 = x1 + stack[i++]; y2 = y1 + stack[i++]; pt.x = x2 + stack[i++]; pt.y = y2; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); } pt.open = true; stackptr = 0; break; case 29: // callgsubr hold = pos; i = (int) stack[--stackptr] + gsubrsoffset; Range gsubr = getIndexEntry(gsubrbase, i); parseGlyph(gsubr, gp, pt); pos = hold; break; case 30: // vhcurveto hold = 4; case 31: // hvcurveto for (i = 0; i < stackptr; ) { boolean hv = (((i + hold) & 4) == 0); x1 = pt.x + (hv ? stack[i++] : 0); y1 = pt.y + (hv ? 0 : stack[i++]); x2 = x1 + stack[i++]; y2 = y1 + stack[i++]; pt.x = x2 + (hv ? 0 : stack[i++]); pt.y = y2 + (hv ? stack[i++] : 0); if (i == stackptr - 1) { if (hv) { pt.x += stack[i++]; } else { pt.y += stack[i++]; } } gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); } pt.open = true; stackptr = 0; break; case 1003: // and x1 = stack[--stackptr]; y1 = stack[--stackptr]; stack[stackptr++] = ((x1 != 0) && (y1 != 0)) ? 1 : 0; break; case 1004: // or x1 = stack[--stackptr]; y1 = stack[--stackptr]; stack[stackptr++] = ((x1 != 0) || (y1 != 0)) ? 1 : 0; break; case 1005: // not x1 = stack[--stackptr]; stack[stackptr++] = (x1 == 0) ? 1 : 0; break; case 1009: // abs stack[stackptr - 1] = Math.abs(stack[stackptr - 1]); break; case 1010: // add x1 = stack[--stackptr]; y1 = stack[--stackptr]; stack[stackptr++] = x1 + y1; break; case 1011: // sub x1 = stack[--stackptr]; y1 = stack[--stackptr]; stack[stackptr++] = y1 - x1; break; case 1012: // div x1 = stack[--stackptr]; y1 = stack[--stackptr]; stack[stackptr++] = y1 / x1; break; case 1014: // neg stack[stackptr - 1] = -stack[stackptr - 1]; break; case 1015: // eq x1 = stack[--stackptr]; y1 = stack[--stackptr]; stack[stackptr++] = (x1 == y1) ? 1 : 0; break; case 1018: // drop stackptr--; break; case 1020: // put i = (int) stack[--stackptr]; x1 = stack[--stackptr]; temps[i] = x1; break; case 1021: // get i = (int) stack[--stackptr]; stack[stackptr++] = temps[i]; break; case 1022: // ifelse if (stack[stackptr - 2] > stack[stackptr - 1]) { stack[stackptr - 4] = stack[stackptr - 3]; } stackptr -= 3; break; case 1023: // random stack[stackptr++] = (float) Math.random(); break; case 1024: // mul x1 = stack[--stackptr]; y1 = stack[--stackptr]; stack[stackptr++] = y1 * x1; break; case 1026: // sqrt stack[stackptr - 1] = (float) Math.sqrt(stack[stackptr - 1]); break; case 1027: // dup x1 = stack[stackptr - 1]; stack[stackptr++] = x1; break; case 1028: // exch x1 = stack[stackptr - 1]; stack[stackptr - 1] = stack[stackptr - 2]; stack[stackptr - 2] = x1; break; case 1029: // index i = (int) stack[stackptr - 1]; if (i < 0) { i = 0; } stack[stackptr - 1] = stack[stackptr - 2 - i]; break; case 1030: // roll i = (int) stack[--stackptr]; int n = (int) stack[--stackptr]; // roll n number by i (+ = upward) if (i > 0) { i = i % n; } else { i = n - (-i % n); } // x x x x i y y y -> y y y x x x x i (where i=3) if (i > 0) { float roll[] = new float[n]; System.arraycopy(stack, stackptr - 1 - i, roll, 0, i); System.arraycopy(stack, stackptr - 1 - n, roll, i, n - i); System.arraycopy(roll, 0, stack, stackptr - 1 - n, n); } break; case 1034: // hflex x1 = pt.x + stack[0]; y1 = ybase = pt.y; x2 = x1 + stack[1]; y2 = y1 + stack[2]; pt.x = x2 + stack[3]; pt.y = y2; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); x1 = pt.x + stack[4]; y1 = pt.y; x2 = x1 + stack[5]; y2 = ybase; pt.x = x2 + stack[6]; pt.y = y2; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); pt.open = true; stackptr = 0; break; case 1035: // flex x1 = pt.x + stack[0]; y1 = pt.y + stack[1]; x2 = x1 + stack[2]; y2 = y1 + stack[3]; pt.x = x2 + stack[4]; pt.y = y2 + stack[5]; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); x1 = pt.x + stack[6]; y1 = pt.y + stack[7]; x2 = x1 + stack[8]; y2 = y1 + stack[9]; pt.x = x2 + stack[10]; pt.y = y2 + stack[11]; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); pt.open = true; stackptr = 0; break; case 1036: // hflex1 ybase = pt.y; x1 = pt.x + stack[0]; y1 = pt.y + stack[1]; x2 = x1 + stack[2]; y2 = y1 + stack[3]; pt.x = x2 + stack[4]; pt.y = y2; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); x1 = pt.x + stack[5]; y1 = pt.y; x2 = x1 + stack[6]; y2 = y1 + stack[7]; pt.x = x2 + stack[8]; pt.y = ybase; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); pt.open = true; stackptr = 0; break; case 1037: // flex1 ybase = pt.y; float xbase = pt.x; x1 = pt.x + stack[0]; y1 = pt.y + stack[1]; x2 = x1 + stack[2]; y2 = y1 + stack[3]; pt.x = x2 + stack[4]; pt.y = y2 + stack[5]; gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); x1 = pt.x + stack[6]; y1 = pt.y + stack[7]; x2 = x1 + stack[8]; y2 = y1 + stack[9]; if (Math.abs(x2 - xbase) > Math.abs(y2 - ybase)) { pt.x = x2 + stack[10]; pt.y = ybase; } else { pt.x = xbase; pt.y = y2 + stack[10]; } gp.curveTo(x1, y1, x2, y2, pt.x, pt.y); pt.open = true; stackptr = 0; break; default: System.out.println("ERROR! TYPE1C CHARSTRING CMD IS " + cmd); break; } } } public static void main(String args[]) { if (args.length != 1) { System.out.println("Need the name of a cff font."); System.exit(0); } JFrame jf = new JFrame("Font test: " + args[0]); try { FileInputStream fis = new FileInputStream(args[0]); TestType1CFont panel = new TestType1CFont(fis); jf.getContentPane().add(panel); jf.pack(); jf.setVisible(true); panel.requestFocus(); } catch (IOException ioe) { } } }
public Shape getShape() { int R = Integer.parseInt(hexcolor.substring(0, 2), 16); int G = Integer.parseInt(hexcolor.substring(2, 4), 16); int B = Integer.parseInt(hexcolor.substring(4, 6), 16); color = new Color(R, G, B); Shape geom; if (shape.equals("circle")) { geom = new Ellipse2D.Float(-0.05f * size, -0.05f * size, 1.1f * size, 1.1f * size); center = new Point2D.Float(size / 2, size / 2); } else if (shape.equals("square")) { geom = new Rectangle2D.Float(0, 0, size, size); center = new Point2D.Float(size / 2, size / 2); } else if (shape.equals("roundsquare")) { geom = new RoundRectangle2D.Float(0, 0, size, size, size / 2, size / 2); center = new Point2D.Float(size / 2, size / 2); } else if (shape.equals("triangle")) { GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2); float height = (float) (Math.sqrt(3) * size / 2); path.moveTo(size / 2, size - height); path.lineTo(size, size); path.lineTo(0, size); path.closePath(); geom = path; center = new Point2D.Float(size / 2, size - height / 2); } else if (shape.equals("star")) { GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2); path.moveTo(size / 2, 0); path.lineTo(7 * size / 10, 3 * size / 10); path.lineTo(size, size / 2); path.lineTo(7 * size / 10, 7 * size / 10); path.lineTo(size / 2, size); path.lineTo(3 * size / 10, 7 * size / 10); path.lineTo(0, size / 2); path.lineTo(3 * size / 10, 3 * size / 10); path.closePath(); AffineTransform trans = AffineTransform.getRotateInstance(Math.PI / 4, size / 2, size / 2); Shape shape = trans.createTransformedShape(path); Area area = new Area(path); area.add(new Area(shape)); trans = AffineTransform.getScaleInstance(1.2, 1.2); shape = trans.createTransformedShape(area); trans = AffineTransform.getTranslateInstance(-0.1 * size, -0.1 * size); shape = trans.createTransformedShape(shape); geom = shape; center = new Point2D.Float(size / 2, size / 2); } else if (shape.equals("octagon")) { GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2); path.moveTo(size / 4, 0); path.lineTo(3 * size / 4, 0); path.lineTo(size, size / 4); path.lineTo(size, 3 * size / 4); path.lineTo(3 * size / 4, size); path.lineTo(size / 4, size); path.lineTo(0, 3 * size / 4); path.lineTo(0, size / 4); path.closePath(); geom = path; path.closePath(); geom = path; center = new Point2D.Float(size / 2, size / 2); } else if (shape.equals("ellipse")) { geom = new Ellipse2D.Float(0, 0, 3 * size / 4, size); center = new Point2D.Float(3 * size / 8, size / 2); } else if (shape.equals("cross")) { GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2); path.moveTo(size / 4, 0); path.lineTo(3 * size / 4, 0); path.lineTo(3 * size / 4, size / 4); path.lineTo(size, size / 4); path.lineTo(size, 3 * size / 4); path.lineTo(3 * size / 4, 3 * size / 4); path.lineTo(3 * size / 4, size); path.lineTo(size / 4, size); path.lineTo(size / 4, 3 * size / 4); path.lineTo(0, 3 * size / 4); path.lineTo(0, size / 4); path.lineTo(size / 4, size / 4); path.closePath(); geom = path; center = new Point2D.Float(size / 2, size / 2); } else if (shape.equals("pentagon")) { GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2); path.moveTo(size / 2, size); float x, y, a; for (int i = 1; i < 5; i++) { a = (float) ((2 * Math.PI / 5) * i); x = (float) (size / 2 + size / 2 * Math.sin(a)); y = (float) (size / 2 + size / 2 * Math.cos(a)); path.lineTo(x, y); } path.closePath(); AffineTransform trans = AffineTransform.getScaleInstance(1.1, 1.1); Shape shape = trans.createTransformedShape(path); trans = AffineTransform.getTranslateInstance(-0.05 * size, -0.05 * size); shape = trans.createTransformedShape(shape); geom = shape; center = new Point2D.Float(size / 2, size / 2); } else if (shape.equals("hexagon")) { GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 2); path.moveTo(size / 2, size); float x, y, a; for (int i = 1; i < 6; i++) { a = (float) ((2 * Math.PI / 6) * i); x = (float) (size / 2 + size / 2 * Math.sin(a)); y = (float) (size / 2 + size / 2 * Math.cos(a)); path.lineTo(x, y); } path.closePath(); geom = path; center = new Point2D.Float(size / 2, size / 2); } else { geom = new Ellipse2D.Float(0, 0, size, size); center = new Point2D.Float(size / 2, size / 2); } return geom; }
public void paintComponent(Graphics g1) { Graphics2D g = (Graphics2D) g1; float width = getWidth(); float height = getHeight(); AffineTransform save = g.getTransform(); AffineTransform save_tmp; g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); if (45.0 <= rotate && rotate < 135.0) { g.translate(width, 0.0); g.rotate(Math.PI * rotate / 180, 0.0, 0.0); g.transform( AffineTransform.getScaleInstance(height / original_width, width / original_height)); } else if (135.0 <= rotate && rotate < 225.0) { g.rotate(Math.PI * rotate / 180, width / 2, height / 2); g.transform( AffineTransform.getScaleInstance(width / original_width, height / original_height)); } else if (225.0 <= rotate && rotate < 315.0) { g.translate(-height, 0.0); g.rotate(Math.PI * rotate / 180, height, 0.0); g.transform( AffineTransform.getScaleInstance(height / original_width, width / original_height)); } else g.transform( AffineTransform.getScaleInstance(width / original_width, height / original_height)); g.setColor( GeColor.getColor( 22, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, fillColor, false)); g.fill(shapes[0]); g.setColor( GeColor.getColor( 20, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, fillColor, false)); g.fill(shapes[1]); g.setColor( GeColor.getColor( 23, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, fillColor, false)); g.fill(shapes[2]); g.setStroke(new BasicStroke(1F)); g.setColor( GeColor.getColor( 0, colorTone, colorShift, colorIntensity, colorBrightness, colorInverse, borderColor, false)); g.draw(shapes[3]); g.setColor(Color.black); g.setFont(annot1Font); save_tmp = g.getTransform(); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF); g.transform( AffineTransform.getScaleInstance(original_width / width * height / original_height, 1)); g.drawString(annot1, 13 * original_height / height * width / original_width, 22F); g.setTransform(save_tmp); g.setTransform(save); }