8398c9048d
code was modified slightly, so the code differs from the original downloadable 1.9.5 version
777 lines
24 KiB
JavaScript
777 lines
24 KiB
JavaScript
dojo.provide("dojox.gfx.VectorText");
|
|
dojo.require("dojox.gfx");
|
|
dojo.require("dojox.xml.DomParser");
|
|
dojo.require("dojox.html.metrics");
|
|
|
|
(function(){
|
|
/*
|
|
dojox.gfx.VectorText
|
|
An implementation of the SVG Font 1.1 spec, using dojox.gfx.
|
|
|
|
Basic interface:
|
|
var f = new dojox.gfx.Font(url|string);
|
|
surface||group.createVectorText(text)
|
|
.setFill(fill)
|
|
.setStroke(stroke)
|
|
.setFont(fontStyleObject);
|
|
|
|
The arguments passed to createVectorText are the same as you would
|
|
pass to surface||group.createText; the difference is that this
|
|
is entirely renderer-agnostic, and the return value is a subclass
|
|
of dojox.gfx.Group.
|
|
|
|
Note also that the "defaultText" object is slightly different:
|
|
{ type:"vectortext", x:0, y:0, width:null, height: null,
|
|
text: "", align: "start", decoration: "none" }
|
|
|
|
...as well as the "defaultVectorFont" object:
|
|
{ type:"vectorfont", size:"10pt" }
|
|
|
|
The reason for this should be obvious: most of the style for the font is defined
|
|
by the font object itself.
|
|
|
|
Note that this will only render IF and WHEN you set the font.
|
|
*/
|
|
dojo.mixin(dojox.gfx, {
|
|
vectorFontFitting: {
|
|
NONE: 0, // render text according to passed size.
|
|
FLOW: 1, // render text based on the passed width and size
|
|
FIT: 2 // render text based on a passed viewbox.
|
|
},
|
|
defaultVectorText: {
|
|
type:"vectortext", x:0, y:0, width: null, height: null,
|
|
text: "", align: "start", decoration: "none", fitting: 0, // vectorFontFitting.NONE
|
|
leading: 1.5 // in ems.
|
|
},
|
|
defaultVectorFont: {
|
|
type:"vectorfont", size: "10pt", family: null
|
|
},
|
|
_vectorFontCache: {},
|
|
_svgFontCache: {},
|
|
getVectorFont: function(/* String */url){
|
|
if(dojox.gfx._vectorFontCache[url]){
|
|
return dojox.gfx._vectorFontCache[url];
|
|
}
|
|
return new dojox.gfx.VectorFont(url);
|
|
}
|
|
});
|
|
|
|
dojo.declare("dojox.gfx.VectorFont", null, {
|
|
_entityRe: /&(quot|apos|lt|gt|amp|#x[^;]+|#\d+);/g,
|
|
_decodeEntitySequence: function(str){
|
|
// unescape the unicode sequences
|
|
|
|
// nothing to decode
|
|
if(!str.match(this._entityRe)){ return; } // undefined
|
|
var xmlEntityMap = {
|
|
amp:"&", apos:"'", quot:'"', lt:"<", gt:">"
|
|
};
|
|
|
|
// we have at least one encoded entity.
|
|
var r, tmp="";
|
|
while((r=this._entityRe.exec(str))!==null){
|
|
if(r[1].charAt(1)=="x"){
|
|
tmp+=String.fromCharCode(r[1].slice(2), 16);
|
|
}
|
|
else if(!isNaN(parseInt(r[1].slice(1),10))){
|
|
tmp+=String.fromCharCode(r[1].slice(1));
|
|
}
|
|
else {
|
|
tmp+=xmlEntityMap(r[1]);
|
|
}
|
|
}
|
|
return tmp; // String
|
|
},
|
|
_parse: function(/* String */svg, /* String */url){
|
|
// summary:
|
|
// Take the loaded SVG Font definition file and convert the info
|
|
// into things we can use. The SVG Font definition must follow
|
|
// the SVG 1.1 Font specification.
|
|
var doc = dojox.gfx._svgFontCache[url]||dojox.xml.DomParser.parse(svg);
|
|
|
|
// font information
|
|
var f = doc.documentElement.byName("font")[0], face = doc.documentElement.byName("font-face")[0];
|
|
var unitsPerEm = parseFloat(face.getAttribute("units-per-em")||1000, 10);
|
|
var advance = {
|
|
x: parseFloat(f.getAttribute("horiz-adv-x"), 10),
|
|
y: parseFloat(f.getAttribute("vert-adv-y")||0, 10)
|
|
};
|
|
if(!advance.y){
|
|
advance.y = unitsPerEm;
|
|
}
|
|
|
|
var origin = {
|
|
horiz: {
|
|
x: parseFloat(f.getAttribute("horiz-origin-x")||0, 10),
|
|
y: parseFloat(f.getAttribute("horiz-origin-y")||0, 10)
|
|
},
|
|
vert: {
|
|
x: parseFloat(f.getAttribute("vert-origin-x")||0, 10),
|
|
y: parseFloat(f.getAttribute("vert-origin-y")||0, 10)
|
|
}
|
|
};
|
|
|
|
// face information
|
|
var family = face.getAttribute("font-family"),
|
|
style = face.getAttribute("font-style")||"all",
|
|
variant = face.getAttribute("font-variant")||"normal",
|
|
weight = face.getAttribute("font-weight")||"all",
|
|
stretch = face.getAttribute("font-stretch")||"normal",
|
|
|
|
// additional info, may not be needed
|
|
range = face.getAttribute("unicode-range")||"U+0-10FFFF",
|
|
panose = face.getAttribute("panose-1") || "0 0 0 0 0 0 0 0 0 0",
|
|
capHeight = face.getAttribute("cap-height"),
|
|
ascent = parseFloat(face.getAttribute("ascent")||(unitsPerEm-origin.vert.y), 10),
|
|
descent = parseFloat(face.getAttribute("descent")||origin.vert.y, 10),
|
|
baseline = {};
|
|
|
|
// check for font-face-src/font-face-name
|
|
var name = family;
|
|
if(face.byName("font-face-name")[0]){
|
|
name = face.byName("font-face-name")[0].getAttribute("name");
|
|
}
|
|
|
|
// see if this is cached already, and if so, forget the rest of the parsing.
|
|
if(dojox.gfx._vectorFontCache[name]){ return; }
|
|
|
|
// get any provided baseline alignment offsets.
|
|
dojo.forEach(["alphabetic", "ideographic", "mathematical", "hanging" ], function(attr){
|
|
var a = face.getAttribute(attr);
|
|
if(a !== null /* be explicit, might be 0 */){
|
|
baseline[attr] = parseFloat(a, 10);
|
|
}
|
|
});
|
|
|
|
/*
|
|
// TODO: decoration hinting.
|
|
var decoration = { };
|
|
dojo.forEach(["underline", "strikethrough", "overline"], function(type){
|
|
if(face.getAttribute(type+"-position")!=null){
|
|
decoration[type]={ };
|
|
}
|
|
});
|
|
*/
|
|
|
|
// missing glyph info
|
|
var missing = parseFloat(doc.documentElement.byName("missing-glyph")[0].getAttribute("horiz-adv-x")||advance.x, 10);
|
|
|
|
// glyph information
|
|
var glyphs = {}, glyphsByName={}, g=doc.documentElement.byName("glyph");
|
|
dojo.forEach(g, function(node){
|
|
// we are going to assume the following:
|
|
// 1) we have the unicode attribute
|
|
// 2) we have the name attribute
|
|
// 3) we have the horiz-adv-x and d attributes.
|
|
var code = node.getAttribute("unicode"),
|
|
name = node.getAttribute("glyph-name"),
|
|
xAdv = parseFloat(node.getAttribute("horiz-adv-x")||advance.x, 10),
|
|
path = node.getAttribute("d");
|
|
|
|
// unescape the unicode sequences
|
|
if(code.match(this._entityRe)){
|
|
code = this._decodeEntitySequence(code);
|
|
}
|
|
|
|
// build our glyph objects
|
|
var o = { code: code, name: name, xAdvance: xAdv, path: path };
|
|
glyphs[code]=o;
|
|
glyphsByName[name]=o;
|
|
}, this);
|
|
|
|
// now the fun part: look for kerning pairs.
|
|
var hkern=doc.documentElement.byName("hkern");
|
|
dojo.forEach(hkern, function(node, i){
|
|
var k = -parseInt(node.getAttribute("k"),10);
|
|
// look for either a code or a name
|
|
var u1=node.getAttribute("u1"),
|
|
g1=node.getAttribute("g1"),
|
|
u2=node.getAttribute("u2"),
|
|
g2=node.getAttribute("g2"),
|
|
gl;
|
|
|
|
if(u1){
|
|
// the first of the pair is a sequence of unicode characters.
|
|
// TODO: deal with unicode ranges and mulitple characters.
|
|
u1 = this._decodeEntitySequence(u1);
|
|
if(glyphs[u1]){
|
|
gl = glyphs[u1];
|
|
}
|
|
} else {
|
|
// we are referring to a name.
|
|
// TODO: deal with multiple names
|
|
if(glyphsByName[g1]){
|
|
gl = glyphsByName[g1];
|
|
}
|
|
}
|
|
|
|
if(gl){
|
|
if(!gl.kern){ gl.kern = {}; }
|
|
if(u2){
|
|
// see the notes above.
|
|
u2 = this._decodeEntitySequence(u2);
|
|
gl.kern[u2] = { x: k };
|
|
} else {
|
|
if(glyphsByName[g2]){
|
|
gl.kern[glyphsByName[g2].code] = { x: k };
|
|
}
|
|
}
|
|
}
|
|
}, this);
|
|
|
|
// pop the final definition in the font cache.
|
|
dojo.mixin(this, {
|
|
family: family,
|
|
name: name,
|
|
style: style,
|
|
variant: variant,
|
|
weight: weight,
|
|
stretch: stretch,
|
|
range: range,
|
|
viewbox: { width: unitsPerEm, height: unitsPerEm },
|
|
origin: origin,
|
|
advance: dojo.mixin(advance, {
|
|
missing:{ x: missing, y: missing }
|
|
}),
|
|
ascent: ascent,
|
|
descent: descent,
|
|
baseline: baseline,
|
|
glyphs: glyphs
|
|
});
|
|
|
|
// cache the parsed font
|
|
dojox.gfx._vectorFontCache[name] = this;
|
|
dojox.gfx._vectorFontCache[url] = this;
|
|
if(name!=family && !dojox.gfx._vectorFontCache[family]){
|
|
dojox.gfx._vectorFontCache[family] = this;
|
|
}
|
|
|
|
// cache the doc
|
|
if(!dojox.gfx._svgFontCache[url]){
|
|
dojox.gfx._svgFontCache[url]=doc;
|
|
}
|
|
},
|
|
_clean: function(){
|
|
// summary:
|
|
// Clean off all of the given mixin parameters.
|
|
var name = this.name, family = this.family;
|
|
dojo.forEach(["family","name","style","variant",
|
|
"weight","stretch","range","viewbox",
|
|
"origin","advance","ascent","descent",
|
|
"baseline","glyphs"], function(prop){
|
|
try{ delete this[prop]; } catch(e) { }
|
|
}, this);
|
|
|
|
// try to pull out of the font cache.
|
|
if(dojox.gfx._vectorFontCache[name]){
|
|
delete dojox.gfx._vectorFontCache[name];
|
|
}
|
|
if(dojox.gfx._vectorFontCache[family]){
|
|
delete dojox.gfx._vectorFontCache[family];
|
|
}
|
|
return this;
|
|
},
|
|
|
|
constructor: function(/* String|dojo._Url */url){
|
|
// summary::
|
|
// Create this font object based on the SVG Font definition at url.
|
|
this._defaultLeading = 1.5;
|
|
if(url!==undefined){
|
|
this.load(url);
|
|
}
|
|
},
|
|
load: function(/* String|dojo._Url */url){
|
|
// summary::
|
|
// Load the passed SVG and send it to the parser for parsing.
|
|
this.onLoadBegin(url.toString());
|
|
this._parse(
|
|
dojox.gfx._svgFontCache[url.toString()]||dojo._getText(url.toString()),
|
|
url.toString()
|
|
);
|
|
this.onLoad(this);
|
|
return this; // dojox.gfx.VectorFont
|
|
},
|
|
initialized: function(){
|
|
// summary::
|
|
// Return if we've loaded a font def, and the parsing was successful.
|
|
return (this.glyphs!==null); // Boolean
|
|
},
|
|
|
|
// preset round to 3 places.
|
|
_round: function(n){ return Math.round(1000*n)/1000; },
|
|
_leading: function(unit){ return this.viewbox.height * (unit||this._defaultLeading); },
|
|
_normalize: function(str){
|
|
return str.replace(/\s+/g, String.fromCharCode(0x20));
|
|
},
|
|
|
|
_getWidth: function(glyphs){
|
|
var w=0, last=0, lastGlyph=null;
|
|
dojo.forEach(glyphs, function(glyph, i){
|
|
last=glyph.xAdvance;
|
|
if(glyphs[i] && glyph.kern && glyph.kern[glyphs[i].code]){
|
|
last += glyph.kern[glyphs[i].code].x;
|
|
}
|
|
w += last;
|
|
lastGlyph = glyph;
|
|
});
|
|
|
|
// if the last glyph was a space, pull it off.
|
|
if(lastGlyph && lastGlyph.code == " "){
|
|
w -= lastGlyph.xAdvance;
|
|
}
|
|
|
|
return this._round(w/*-last*/);
|
|
},
|
|
|
|
_getLongestLine: function(lines){
|
|
var maxw=0, idx=0;
|
|
dojo.forEach(lines, function(line, i){
|
|
var max = Math.max(maxw, this._getWidth(line));
|
|
if(max > maxw){
|
|
maxw = max;
|
|
idx=i;
|
|
}
|
|
}, this);
|
|
return { width: maxw, index: idx, line: lines[idx] };
|
|
},
|
|
|
|
_trim: function(lines){
|
|
var fn = function(arr){
|
|
// check if the first or last character is a space and if so, remove it.
|
|
if(!arr.length){ return; }
|
|
if(arr[arr.length-1].code == " "){ arr.splice(arr.length-1, 1); }
|
|
if(!arr.length){ return; }
|
|
if(arr[0].code == " "){ arr.splice(0, 1); }
|
|
};
|
|
|
|
if(dojo.isArray(lines[0])){
|
|
// more than one line.
|
|
dojo.forEach(lines, fn);
|
|
} else {
|
|
fn(lines);
|
|
}
|
|
return lines;
|
|
},
|
|
|
|
_split: function(chars, nLines){
|
|
// summary:
|
|
// split passed chars into nLines by finding the closest whitespace.
|
|
var w = this._getWidth(chars),
|
|
limit = Math.floor(w/nLines),
|
|
lines = [],
|
|
cw = 0,
|
|
c = [],
|
|
found = false;
|
|
|
|
for(var i=0, l=chars.length; i<l; i++){
|
|
if(chars[i].code == " "){ found = true; }
|
|
cw += chars[i].xAdvance;
|
|
if(i+1<l && chars[i].kern && chars[i].kern[chars[i+1].code]){
|
|
cw += chars[i].kern[chars[i+1].code].x;
|
|
}
|
|
|
|
if(cw>=limit){
|
|
var chr=chars[i];
|
|
while(found && chr.code != " " && i>=0){
|
|
chr = c.pop(); i--;
|
|
}
|
|
lines.push(c);
|
|
c=[];
|
|
cw=0;
|
|
found=false;
|
|
}
|
|
c.push(chars[i]);
|
|
}
|
|
if(c.length){ lines.push(c); }
|
|
// "trim" it
|
|
return this._trim(lines);
|
|
},
|
|
|
|
_getSizeFactor: function(size){
|
|
// given the size, return a scaling factor based on the height of the
|
|
// font as defined in the font definition file.
|
|
size += ""; // force the string cast.
|
|
var metrics = dojox.html.metrics.getCachedFontMeasurements(),
|
|
height=this.viewbox.height,
|
|
f=metrics["1em"],
|
|
unit=parseFloat(size, 10); // the default.
|
|
if(size.indexOf("em")>-1){
|
|
return this._round((metrics["1em"]*unit)/height);
|
|
}
|
|
else if(size.indexOf("ex")>-1){
|
|
return this._round((metrics["1ex"]*unit)/height);
|
|
}
|
|
else if(size.indexOf("pt")>-1){
|
|
return this._round(((metrics["12pt"] / 12)*unit) / height);
|
|
}
|
|
else if(size.indexOf("px")>-1){
|
|
return this._round(((metrics["16px"] / 16)*unit) / height);
|
|
}
|
|
else if(size.indexOf("%")>-1){
|
|
return this._round((metrics["1em"]*(unit / 100)) / height);
|
|
}
|
|
else {
|
|
f=metrics[size]||metrics.medium;
|
|
return this._round(f/height);
|
|
}
|
|
},
|
|
|
|
_getFitFactor: function(lines, w, h, l){
|
|
// summary:
|
|
// Find the scaling factor for the given phrase set.
|
|
if(!h){
|
|
// if no height was passed, we assume an array of glyphs instead of lines.
|
|
return this._round(w/this._getWidth(lines));
|
|
} else {
|
|
var maxw = this._getLongestLine(lines).width,
|
|
maxh = (lines.length*(this.viewbox.height*l))-((this.viewbox.height*l)-this.viewbox.height);
|
|
return this._round(Math.min(w/maxw, h/maxh));
|
|
}
|
|
},
|
|
_getBestFit: function(chars, w, h, ldng){
|
|
// summary:
|
|
// Get the best number of lines to return given w and h.
|
|
var limit=32,
|
|
factor=0,
|
|
lines=limit;
|
|
while(limit>0){
|
|
var f=this._getFitFactor(this._split(chars, limit), w, h, ldng);
|
|
if(f>factor){
|
|
factor = f;
|
|
lines=limit;
|
|
}
|
|
limit--;
|
|
}
|
|
return { scale: factor, lines: this._split(chars, lines) };
|
|
},
|
|
|
|
_getBestFlow: function(chars, w, scale){
|
|
// summary:
|
|
// Based on the given scale, do the best line splitting possible.
|
|
var lines = [],
|
|
cw = 0,
|
|
c = [],
|
|
found = false;
|
|
for(var i=0, l=chars.length; i<l; i++){
|
|
if(chars[i].code == " "){ found = true; }
|
|
var tw = chars[i].xAdvance;
|
|
if(i+1<l && chars[i].kern && chars[i].kern[chars[i+1].code]){
|
|
tw += chars[i].kern[chars[i+1].code].x;
|
|
}
|
|
cw += scale*tw;
|
|
|
|
if(cw>=w){
|
|
var chr=chars[i];
|
|
while(found && chr.code != " " && i>=0){
|
|
chr = c.pop(); i--;
|
|
}
|
|
lines.push(c);
|
|
c=[];
|
|
cw=0;
|
|
found=false;
|
|
}
|
|
c.push(chars[i]);
|
|
}
|
|
if(c.length){ lines.push(c); }
|
|
return this._trim(lines);
|
|
},
|
|
|
|
// public functions
|
|
getWidth: function(/* String */text, /* Float? */scale){
|
|
// summary:
|
|
// Get the width of the rendered text without actually rendering it.
|
|
return this._getWidth(dojo.map(this._normalize(text).split(""), function(chr){
|
|
return this.glyphs[chr] || { xAdvance: this.advance.missing.x };
|
|
}, this)) * (scale || 1); // Float
|
|
},
|
|
getLineHeight: function(/* Float? */scale){
|
|
// summary:
|
|
// return the height of a single line, sans leading, based on scale.
|
|
return this.viewbox.height * (scale || 1); // Float
|
|
},
|
|
|
|
// A note:
|
|
// Many SVG exports do not include information such as x-height, caps-height
|
|
// and other coords that may help alignment. We can calc the baseline and
|
|
// we can get a mean line (i.e. center alignment) but that's about all, reliably.
|
|
getCenterline: function(/* Float? */scale){
|
|
// summary:
|
|
// return the y coordinate that is the center of the viewbox.
|
|
return (scale||1) * (this.viewbox.height/2);
|
|
},
|
|
getBaseline: function(/* Float? */scale){
|
|
// summary:
|
|
// Find the baseline coord for alignment; adjust for scale if passed.
|
|
return (scale||1) * (this.viewbox.height+this.descent); // Float
|
|
},
|
|
|
|
draw: function(/* dojox.gfx.Container */group, /* dojox.gfx.__TextArgs */textArgs, /* dojox.gfx.__FontArgs */fontArgs, /* dojox.gfx.__FillArgs */fillArgs, /* dojox.gfx.__StrokeArgs? */strokeArgs){
|
|
// summary:
|
|
// based on the passed parameters, draw the given text using paths
|
|
// defined by this font.
|
|
//
|
|
// description:
|
|
// The main method of a VectorFont, draw() will take a text fragment
|
|
// and render it in a set of groups and paths based on the parameters
|
|
// passed.
|
|
//
|
|
// The basics of drawing text are simple enough: pass it your text as
|
|
// part of the textArgs object, pass size and family info as part of
|
|
// the fontArgs object, pass at least a color as the fillArgs object,
|
|
// and if you are looking to create an outline, pass the strokeArgs
|
|
// object as well. fillArgs and strokeArgs are the same as any other
|
|
// gfx fill and stroke arguments; they are simply applied to any path
|
|
// object generated by this method.
|
|
//
|
|
// Resulting GFX structure
|
|
// -----------------------
|
|
//
|
|
// The result of this function is a set of gfx objects in the following
|
|
// structure:
|
|
//
|
|
// | dojox.gfx.Group // the parent group generated by this function
|
|
// | + dojox.gfx.Group[] // a group generated for each line of text
|
|
// | + dojox.gfx.Path[] // each glyph/character in the text
|
|
//
|
|
// Scaling transformations (i.e. making the generated text the correct size)
|
|
// are always applied to the parent Group that is generated (i.e. the top
|
|
// node in the above example). In theory, if you are looking to do any kind
|
|
// of other transformations (such as a translation), you should apply it to
|
|
// the group reference you pass to this method. If you find that you need
|
|
// to apply transformations to the group that is returned by this method,
|
|
// you will need to reapply the scaling transformation as the *last* transform,
|
|
// like so:
|
|
//
|
|
// | textGroup.setTransform(new dojox.gfx.Matrix2D([
|
|
// | dojox.gfx.matrix.translate({ dx: dx, dy: dy }),
|
|
// | textGroup.getTransform()
|
|
// | ]));
|
|
//
|
|
// In general, this should never be necessary unless you are doing advanced
|
|
// placement of your text.
|
|
//
|
|
// Advanced Layout Functionality
|
|
// -----------------------------
|
|
//
|
|
// In addition to straight text fragments, draw() supports a few advanced
|
|
// operations not normally available with vector graphics:
|
|
//
|
|
// * Flow operations (i.e. wrap to a given width)
|
|
// * Fitting operations (i.e. find a best fit to a given rectangle)
|
|
//
|
|
// To enable either, pass a `fitting` property along with the textArgs object.
|
|
// The possible values are contained in the dojox.gfx.vectorFontFitting enum
|
|
// (NONE, FLOW, FIT).
|
|
//
|
|
// `Flow fitting`
|
|
// Flow fitting requires both a passed size (in the fontArgs object) and a
|
|
// width (passed with the textArgs object). draw() will attempt to split the
|
|
// passed text up into lines, at the closest whitespace according to the
|
|
// passed width. If a width is missing, it will revert to NONE.
|
|
//
|
|
// `Best fit fitting`
|
|
// Doing a "best fit" means taking the passed text, and finding the largest
|
|
// size and line breaks so that it is the closest fit possible. With best
|
|
// fit, any size arguments are ignored; if a height is missing, it will revert
|
|
// to NONE.
|
|
//
|
|
// Other notes
|
|
// -----------
|
|
//
|
|
// `a11y`
|
|
// Since the results of this method are rendering using pure paths (think
|
|
// "convert to outlines" in Adobe Illustrator), any text rendered by this
|
|
// code is NOT considered a11y-friendly. If a11y is a requirement, we
|
|
// suggest using other, more a11y-friendly methods.
|
|
//
|
|
// `Font sources`
|
|
// Always make sure that you are legally allowed to use any fonts that you
|
|
// convert to SVG format; we claim no responsibility for any licensing
|
|
// infractions that may be caused by the use of this code.
|
|
if(!this.initialized()){
|
|
throw new Error("dojox.gfx.VectorFont.draw(): we have not been initialized yet.");
|
|
}
|
|
// TODO: BIDI handling. Deal with layout/alignments based on font parameters.
|
|
|
|
// start by creating the overall group. This is the INNER group (the caller
|
|
// should be the outer).
|
|
var g = group.createGroup();
|
|
|
|
// do the x/y translation on the parent group
|
|
// FIXME: this is probably not the best way of doing this.
|
|
if(textArgs.x || textArgs.y){
|
|
group.applyTransform({ dx: textArgs.x||0, dy: textArgs.y||0 });
|
|
}
|
|
|
|
// go get the glyph array.
|
|
var text = dojo.map(this._normalize(textArgs.text).split(""), function(chr){
|
|
return this.glyphs[chr] || { path:null, xAdvance: this.advance.missing.x };
|
|
}, this);
|
|
|
|
// determine the font style info, ignore decoration.
|
|
var size = fontArgs.size,
|
|
fitting = textArgs.fitting,
|
|
width = textArgs.width,
|
|
height = textArgs.height,
|
|
align = textArgs.align,
|
|
leading = textArgs.leading||this._defaultLeading;
|
|
|
|
// figure out if we have to do fitting at all.
|
|
if(fitting){
|
|
// more than zero.
|
|
if((fitting==dojox.gfx.vectorFontFitting.FLOW && !width) || (fitting==dojox.gfx.vectorFontFitting.FIT && (!width || !height))){
|
|
// reset the fitting if we don't have everything we need.
|
|
fitting = dojox.gfx.vectorFontFitting.NONE;
|
|
}
|
|
}
|
|
|
|
// set up the lines array and the scaling factor.
|
|
var lines, scale;
|
|
switch(fitting){
|
|
case dojox.gfx.vectorFontFitting.FIT:
|
|
var o=this._getBestFit(text, width, height, leading);
|
|
scale = o.scale;
|
|
lines = o.lines;
|
|
break;
|
|
|
|
case dojox.gfx.vectorFontFitting.FLOW:
|
|
scale = this._getSizeFactor(size);
|
|
lines = this._getBestFlow(text, width, scale);
|
|
break;
|
|
|
|
default:
|
|
scale = this._getSizeFactor(size);
|
|
lines = [ text ];
|
|
|
|
}
|
|
|
|
// make sure lines doesn't have any empty lines.
|
|
lines = dojo.filter(lines, function(item){
|
|
return item.length>0;
|
|
});
|
|
|
|
// let's start drawing.
|
|
var cy = 0,
|
|
maxw = this._getLongestLine(lines).width;
|
|
|
|
for(var i=0, l=lines.length; i<l; i++){
|
|
var cx = 0,
|
|
line=lines[i],
|
|
linew = this._getWidth(line),
|
|
lg=g.createGroup();
|
|
|
|
// loop through the glyphs and add them to the line group (lg)
|
|
for (var j=0; j<line.length; j++){
|
|
var glyph=line[j];
|
|
if(glyph.path!==null){
|
|
var p = lg.createPath(glyph.path).setFill(fillArgs);
|
|
if(strokeArgs){ p.setStroke(strokeArgs); }
|
|
p.setTransform([
|
|
dojox.gfx.matrix.flipY,
|
|
dojox.gfx.matrix.translate(cx, -this.viewbox.height-this.descent)
|
|
]);
|
|
}
|
|
cx += glyph.xAdvance;
|
|
if(j+1<line.length && glyph.kern && glyph.kern[line[j+1].code]){
|
|
cx += glyph.kern[line[j+1].code].x;
|
|
}
|
|
}
|
|
|
|
// transform the line group.
|
|
var dx = 0;
|
|
if(align=="middle"){ dx = maxw/2 - linew/2; }
|
|
else if(align=="end"){ dx = maxw - linew; }
|
|
lg.setTransform({ dx: dx, dy: cy });
|
|
cy += this.viewbox.height * leading;
|
|
}
|
|
|
|
// scale the group
|
|
g.setTransform(dojox.gfx.matrix.scale(scale));
|
|
|
|
// return the overall group
|
|
return g; // dojox.gfx.Group
|
|
},
|
|
|
|
// events
|
|
onLoadBegin: function(/* String */url){ },
|
|
onLoad: function(/* dojox.gfx.VectorFont */font){ }
|
|
});
|
|
|
|
// TODO: dojox.gfx integration
|
|
/*
|
|
|
|
// Inherit from Group but attach Text properties to it.
|
|
dojo.declare("dojox.gfx.VectorText", dojox.gfx.Group, {
|
|
constructor: function(rawNode){
|
|
dojox.gfx.Group._init.call(this);
|
|
this.fontStyle = null;
|
|
},
|
|
|
|
// private methods.
|
|
_setFont: function(){
|
|
// render this using the font code.
|
|
var f = this.fontStyle;
|
|
var font = dojox.gfx._vectorFontCache[f.family];
|
|
if(!font){
|
|
throw new Error("dojox.gfx.VectorText._setFont: the passed font family '" + f.family + "' was not found.");
|
|
}
|
|
|
|
// the actual rendering belongs to the font itself.
|
|
font.draw(this, this.shape, this.fontStyle, this.fillStyle, this.strokeStyle);
|
|
},
|
|
|
|
getFont: function(){ return this.fontStyle; },
|
|
|
|
// overridden public methods.
|
|
setShape: function(newShape){
|
|
dojox.gfx.Group.setShape.call(this);
|
|
this.shape = dojox.gfx.makeParameters(this.shape, newShape);
|
|
this.bbox = null;
|
|
this._setFont();
|
|
return this;
|
|
},
|
|
|
|
// if we've been drawing, we should have exactly one child, and that
|
|
// child will contain the real children.
|
|
setFill: function(fill){
|
|
this.fillStyle = fill;
|
|
if(this.children[0]){
|
|
dojo.forEach(this.children[0].children, function(group){
|
|
dojo.forEach(group.children, function(path){
|
|
path.setFill(fill);
|
|
});
|
|
}, this);
|
|
}
|
|
return this;
|
|
},
|
|
setStroke: function(stroke){
|
|
this.strokeStyle = stroke;
|
|
if(this.children[0]){
|
|
dojo.forEach(this.children[0].children, function(group){
|
|
dojo.forEach(group.children, function(path){
|
|
path.setStroke(stroke);
|
|
});
|
|
}, this);
|
|
}
|
|
return this;
|
|
},
|
|
|
|
setFont: function(newFont){
|
|
// this will do the real rendering.
|
|
this.fontStyle = typeof newFont == "string" ? dojox.gfx.splitFontString(newFont)
|
|
: dojox.gfx.makeParameters(dojox.gfx.defaultFont, newFont);
|
|
this._setFont();
|
|
return this;
|
|
},
|
|
|
|
getBoundingBox: function(){
|
|
return this.bbox;
|
|
}
|
|
});
|
|
|
|
// TODO: figure out how to add this to container objects!
|
|
dojox.gfx.shape.Creator.createVectorText = function(text){
|
|
return this.createObject(dojox.gfx.VectorText, text);
|
|
}
|
|
*/
|
|
})();
|