eessppeelllloo/processing4
1
0
Fork 0
mirror of https://github.com/processing/processing4.git synced 2026-02-11 09:39:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

mostly font work, making multibyte fonts happen

Browse Source
This commit is contained in:
benfry
2004-07-17 03:49:47 +00:00
parent 55cab0b9cf
commit bd94b70ffc
11 changed files with 277 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

253
core/PFont.java
View File

@@ -35,63 +35,6 @@ import java.util.*;
public class PFont implements PConstants {
/**
* This is the union of the Mac Roman and Windows ANSI
* character sets. ISO Latin 1 would be Unicode characters
* 0x80 -> 0xFF, but in practice, it would seem that most
* designers using P5 would rather have the characters
* that they expect from their platform's fonts.
*
* This is more of an interim solution until a much better
* font solution can be determined. (i.e. create fonts on
* the fly from some sort of vector format).
*
* Not that I expect that to happen.
*/
static final char[] EXTRA_CHARS = {
0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
0x00B0, 0x00B1, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00BA,
0x00BB, 0x00BF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5,
0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD,
0x00CE, 0x00CF, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6,
0x00D7, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8,
0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FF, 0x0102, 0x0103,
0x0104, 0x0105, 0x0106, 0x0107, 0x010C, 0x010D, 0x010E, 0x010F,
0x0110, 0x0111, 0x0118, 0x0119, 0x011A, 0x011B, 0x0131, 0x0139,
0x013A, 0x013D, 0x013E, 0x0141, 0x0142, 0x0143, 0x0144, 0x0147,
0x0148, 0x0150, 0x0151, 0x0152, 0x0153, 0x0154, 0x0155, 0x0158,
0x0159, 0x015A, 0x015B, 0x015E, 0x015F, 0x0160, 0x0161, 0x0162,
0x0163, 0x0164, 0x0165, 0x016E, 0x016F, 0x0170, 0x0171, 0x0178,
0x0179, 0x017A, 0x017B, 0x017C, 0x017D, 0x017E, 0x0192, 0x02C6,
0x02C7, 0x02D8, 0x02D9, 0x02DA, 0x02DB, 0x02DC, 0x02DD, 0x03A9,
0x03C0, 0x2013, 0x2014, 0x2018, 0x2019, 0x201A, 0x201C, 0x201D,
0x201E, 0x2020, 0x2021, 0x2022, 0x2026, 0x2030, 0x2039, 0x203A,
0x2044, 0x20AC, 0x2122, 0x2202, 0x2206, 0x220F, 0x2211, 0x221A,
0x221E, 0x222B, 0x2248, 0x2260, 0x2264, 0x2265, 0x25CA, 0xF8FF,
0xFB01, 0xFB02
};
static char[] charset;
static {
charset = new char[126-33+1 + EXTRA_CHARS.length];
int index = 0;
for (int i = 33; i <= 126; i++) {
charset[index++] = (char)i;
}
for (int i = 0; i < EXTRA_CHARS.length; i++) {
charset[index++] = EXTRA_CHARS[i];
}
};
//int firstChar = 33; // always
int charCount;
PImage images[];
@@ -116,79 +59,13 @@ public class PFont implements PConstants {
float size;
float leading;
int ascii[]; // quick lookup for the ascii chars
boolean cached;
public PFont() { } // for PFontAI subclass and font builder
// can this throw an exception instead?
/*
public PFont(String filename, PApplet parent) throws IOException {
//this.parent = parent;
//this.valid = false;
String lower = filename.toLowerCase();
if (lower.endsWith(".vlw")) {
read(parent.openStream(filename));
} else if (lower.endsWith(".vlw.gz")) {
read(new GZIPInputStream(parent.openStream(filename)));
} else {
throw new IOException("don't know what type of file that is");
}
cached = false;
size();
}
*/
/*
public PFont(InputStream input) throws IOException {
read(input);
//cached = false;
//size();
}
*/
public void write(OutputStream output) throws IOException {
DataOutputStream os = new DataOutputStream(output);
os.writeInt(charCount);
os.writeInt(8); // numBits
os.writeInt(mbox); // mboxX (font size)
os.writeInt(mbox); // mboxY (font size)
os.writeInt(0); // baseHt, ignored
os.writeInt(0); // struct padding for c version
for (int i = 0; i < charCount; i++) {
os.writeInt(value[i]);
os.writeInt(height[i]);
os.writeInt(width[i]);
os.writeInt(setWidth[i]);
os.writeInt(topExtent[i]);
os.writeInt(leftExtent[i]);
os.writeInt(0); // padding
}
for (int i = 0; i < charCount; i++) {
//int bitmapSize = height[i] * width[i];
//byte bitmap[] = new byte[bitmapSize];
for (int y = 0; y < height[i]; y++) {
for (int x = 0; x < width[i]; x++) {
os.write(images[i].pixels[y * width[i] + x] & 0xff);
}
}
}
os.flush();
os.close(); // can/should i do this?
}
//private void load_vlw_font(String filename) throws IOException {
//public void read(InputStream input) throws IOException {
public PFont(InputStream input) throws IOException {
DataInputStream is = new DataInputStream(input);
@@ -226,6 +103,9 @@ public class PFont implements PConstants {
topExtent = new int[charCount];
leftExtent = new int[charCount];
ascii = new int[128];
for (int i = 0; i < 128; i++) ascii[i] = -1;
// read the information about the individual characters
for (int i = 0; i < charCount; i++) {
value[i] = is.readInt();
@@ -237,6 +117,9 @@ public class PFont implements PConstants {
// pointer in the c version, ignored
is.readInt();
// cache locations of the ascii charset
if (value[i] < 128) ascii[value[i]] = i;
}
images = new PImage[charCount];
@@ -268,7 +151,43 @@ public class PFont implements PConstants {
//System.out.println();
}
cached = false;
size();
resetSize();
resetLeading(); // ??
}
public void write(OutputStream output) throws IOException {
DataOutputStream os = new DataOutputStream(output);
os.writeInt(charCount);
os.writeInt(8); // numBits
os.writeInt(mbox); // mboxX (font size)
os.writeInt(mbox); // mboxY (font size)
os.writeInt(0); // baseHt, ignored
os.writeInt(0); // struct padding for c version
for (int i = 0; i < charCount; i++) {
os.writeInt(value[i]);
os.writeInt(height[i]);
os.writeInt(width[i]);
os.writeInt(setWidth[i]);
os.writeInt(topExtent[i]);
os.writeInt(leftExtent[i]);
os.writeInt(0); // padding
}
for (int i = 0; i < charCount; i++) {
//int bitmapSize = height[i] * width[i];
//byte bitmap[] = new byte[bitmapSize];
for (int y = 0; y < height[i]; y++) {
for (int x = 0; x < width[i]; x++) {
os.write(images[i].pixels[y * width[i] + x] & 0xff);
}
}
}
os.flush();
os.close(); // can/should i do this?
}
@@ -278,11 +197,13 @@ public class PFont implements PConstants {
*/
public int index(char c) {
// these chars required in all fonts
if ((c >= 33) && (c <= 126)) {
return c - 33;
}
//if ((c >= 33) && (c <= 126)) {
//return c - 33;
//}
// quicker lookup for the ascii fellers
if (c < 128) return ascii[c];
// some other unicode char, hunt it out
//return index_hunt(c, 0, charset.length-1);
return index_hunt(c, 0, value.length-1);
}
@@ -291,11 +212,10 @@ public class PFont implements PConstants {
// meaning that old fonts would crash.. fixed for 0069
private int index_hunt(int c, int start, int stop) {
//System.out.println("checking between " + start + " and " + stop);
//System.err.println("checking between " + start + " and " + stop);
int pivot = (start + stop) / 2;
// if this is the char, then return it
//if (c == charset[pivot]) return pivot;
if (c == value[pivot]) return pivot;
// char doesn't exist, otherwise would have been the pivot
@@ -303,7 +223,6 @@ public class PFont implements PConstants {
if (start >= stop) return -1;
// if it's in the lower half, continue searching that
//if (c < charset[pivot]) return index_hunt(c, start, pivot-1);
if (c < value[pivot]) return index_hunt(c, start, pivot-1);
// if it's in the upper half, continue there
@@ -316,18 +235,17 @@ public class PFont implements PConstants {
}
public void size() {
public void resetSize() {
size = 12;
}
public void size(float isize) {
size = isize;
//leading();
}
public void leading() {
public void resetLeading() {
leading = size * ((float)mbox / iheightf) * 1.2f;
}
@@ -442,11 +360,6 @@ public class PFont implements PConstants {
int xx = (int) x + leftExtent[glyph];;
int yy = (int) y - topExtent[glyph];
//int x1 = xx + leftExtent[glyph];
//int y1 = yy - topExtent[glyph];
//int x2 = x1 + width[glyph];
//int y2 = y1 + height[glyph];
int x0 = 0;
int y0 = 0;
int w0 = width[glyph];
@@ -508,27 +421,16 @@ public class PFont implements PConstants {
}
}
/*
public final static int _blend(int p1, int p2, int a2) {
// scale alpha by alpha of incoming pixel
a2 = (a2 * (p2 >>> 24)) >> 8;
int a1 = a2 ^ 0xff;
int r = (a1 * ((p1 >> 16) & 0xff) + a2 * ((p2 >> 16) & 0xff)) & 0xff00;
int g = (a1 * ((p1 >> 8) & 0xff) + a2 * ((p2 >> 8) & 0xff)) & 0xff00;
int b = (a1 * ( p1 & 0xff) + a2 * ( p2 & 0xff)) >> 8;
return 0xff000000 | (r << 8) | g | b;
}
*/
// used by the text() functions to avoid over-allocation of memory
private char c[] = new char[8192];
public void text(String str, float x, float y, PGraphics parent) {
text(str, x, y, 0, parent);
}
public void text(String str, float x, float y, float z, PGraphics parent) {
float startX = x;
int index = 0;
@@ -555,4 +457,47 @@ public class PFont implements PConstants {
index++;
}
}
/**
* Same as below, just without a z coordinate.
*/
public void text(String str, float x, float y,
float w, float h, PGraphics parent) {
text(str, x, y, 0, w, h, parent);
}
/**
* Draw text in a text both that is constrained to a
* particular width and height
*/
public void text(String str, float x, float y, float z,
float w, float h, PGraphics parent) {
float space = width(' ');
float xx = x;
float yy = y;
float right = x + w;
String paragraphs[] = PApplet.split(str, '\n');
for (int i = 0; i < paragraphs.length; i++) {
String words[] = PApplet.split(paragraphs[i], ' ');
float wide = 0;
for (int j = 0; j < words.length; j++) {
float size = width(words[j]);
if (xx + size > right) {
// this goes on the next line
xx = 0;
yy += leading;
if (yy > h) return; // too big for box
}
text(words[j], xx, yy, z, parent);
xx += size + space;
}
// end of paragraph, move to left and increment leading
xx = 0;
yy += leading;
if (yy > h) return; // too big for box
}
}
}