void ScriptExport(SplineFont *sf, BDFFont *bdf, int format, int gid,
char *format_spec,EncMap *map) {
char buffer[100];
SplineChar *sc = sf->glyphs[gid];
BDFChar *bc = bdf!=NULL ? bdf->glyphs[gid] : NULL;
int good=true;
if ( sc==NULL )
return;
MakeExportName(buffer,sizeof(buffer),format_spec,sc,map);
if ( format==0 )
good = ExportEPS(buffer,sc,ly_fore);
else if ( format==1 )
good = ExportFig(buffer,sc,ly_fore);
else if ( format==2 )
good = ExportSVG(buffer,sc,ly_fore);
else if ( format==3 )
good = ExportGlif(buffer,sc,ly_fore);
else if ( format==4 )
good = ExportPDF(buffer,sc,ly_fore);
else if ( format==5 )
good = ExportPlate(buffer,sc,ly_fore);
else if ( bc!=NULL )
good = BCExportXBM(buffer,bc,format-6);
if ( !good )
ff_post_error(_("Save Failed"),_("Save Failed"));
}
static int GFD_Ok(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
struct gfc_data *d = GDrawGetUserData(GGadgetGetWindow(g));
GGadget *tf;
GFileChooserGetChildren(d->gfc,NULL,NULL,&tf);
if ( *_GGadgetGetTitle(tf)!='\0' ) {
extern int allow_utf8_glyphnames;
GTextInfo *ti = GGadgetGetListItemSelected(d->rename);
char *nlname = u2utf8_copy(ti->text);
force_names_when_opening = NameListByName(nlname);
free(nlname);
if ( force_names_when_opening!=NULL && force_names_when_opening->uses_unicode &&
!allow_utf8_glyphnames) {
ff_post_error(_("Namelist contains non-ASCII names"),_("Glyph names should be limited to characters in the ASCII character set, but there are names in this namelist which use characters outside that range."));
return(true);
}
d->done = true;
d->ret = GGadgetGetTitle(d->gfc);
// Trim trailing '/' if its there and put that string back as
// the d->gfc string.
int tmplen = u_strlen( d->ret );
if( tmplen > 0 ) {
if( d->ret[ tmplen-1 ] == '/' ) {
unichar_t* tmp = u_copy( d->ret );
tmp[ tmplen-1 ] = '\0';
GGadgetSetTitle(d->gfc, tmp);
free(tmp);
d->ret = GGadgetGetTitle(d->gfc);
}
}
}
}
return( true );
}
static int BdfP_FinishTextField(struct bdf_dlg *bd) {
if ( bd->active ) {
char *text = GGadgetGetTitle8(bd->tf);
char *pt, *end;
int val;
struct bdf_dlg_font *cur = bd->cur;
BDFFont *bdf = cur->bdf;
for ( pt=text; *pt; ++pt )
if ( *pt&0x80 ) {
ff_post_error(_("Not ASCII"),_("All characters in the value must be in ASCII"));
free(text);
return( false );
}
val = strtol(text,&end,10);
if ( NumericKey(bdf->props[cur->sel_prop].name) ) {
if ( *end!='\0' ) {
ff_post_error(_("Bad Number"),_("Must be a number"));
free(text);
return( false );
}
}
if ( (bdf->props[cur->sel_prop].type&~prt_property)==prt_string ||
(bdf->props[cur->sel_prop].type&~prt_property)==prt_atom )
free(bdf->props[cur->sel_prop].u.str);
if ( UnknownKey(bdf->props[cur->sel_prop].name) ) {
if ( *end!='\0' ) {
bdf->props[cur->sel_prop].type = prt_string | prt_property;
bdf->props[cur->sel_prop].u.str = copy(text);
} else {
if ( bdf->props[cur->sel_prop].type != (prt_uint | prt_property ))
bdf->props[cur->sel_prop].type = prt_int | prt_property;
bdf->props[cur->sel_prop].u.val = val;
}
} else if ( NumericKey(bdf->props[cur->sel_prop].name) ) {
bdf->props[cur->sel_prop].type = KeyType(bdf->props[cur->sel_prop].name);
bdf->props[cur->sel_prop].u.val = val;
} else {
bdf->props[cur->sel_prop].type = KeyType(bdf->props[cur->sel_prop].name);
bdf->props[cur->sel_prop].u.str = copy(text);
}
free(text);
bd->active = false;
GGadgetSetVisible(bd->tf,false);
}
return( true );
}
FILE *URLToTempFile(char *url, void *_lock)
{
(void) _lock;
(void) url;
ff_post_error(_("Could not parse URL"),
_("FontForge only handles ftp and http URLs at the moment"));
return (NULL);
}
int URLFromFile(const char *url,FILE *from) {
if ( strncasecmp(url,"ftp://",6)==0 ) {
return( FtpURLAndTempFile(url,NULL,from));
} else {
ff_post_error(_("Could not parse URL"),_("FontForge can only upload to ftp URLs at the moment"));
return( false );
}
}
static int SVParseDlg(SearchView *sv, int check_replace ) {
int err=false;
double fudge;
fudge = GetReal8(sv->gw,CID_Fuzzy,_("Match Fuzziness:"),&err);
if ( err )
return( false );
old_fudge = fudge;
sv->sd.tryreverse = true;
sv->sd.tryflips = GGadgetIsChecked(GWidgetGetControl(sv->gw,CID_Flipping));
sv->sd.tryscale = GGadgetIsChecked(GWidgetGetControl(sv->gw,CID_Scaling));
sv->sd.tryrotate = GGadgetIsChecked(GWidgetGetControl(sv->gw,CID_Rotating));
sv->sd.endpoints = GGadgetIsChecked(GWidgetGetControl(sv->gw,CID_Endpoints));
sv->sd.onlyselected = GGadgetIsChecked(GWidgetGetControl(sv->gw,CID_Selected));
SVResetPaths(&sv->sd);
if ( pathpointcnt(sv->sd.path)==0 )
ff_post_error(_("Bad search pattern"),_("Nothing to match."));
else if ( sv->sd.endpoints ) {
if ( pathpointcnt(sv->sd.path)<3 ||
(check_replace && pathpointcnt(sv->sd.replacepath)<3 && pathpointcnt(sv->sd.replacepath)!=0 )) {
if ( pathpointcnt(sv->sd.path)<0 )
ff_post_error(_("Bad search pattern"),_("When \"Endpoints specify minimum length and direction only\" is checked, the search pattern must be a single open contour."));
else if ( pathpointcnt(sv->sd.path)<3 )
ff_post_error(_("Bad search pattern"),_("When \"Endpoints specify minimum length and direction only\" is checked, the search pattern must be a single open contour with at least 3 points on it (otherwise there is nothing to match)."));
else
ff_post_error(_("Bad replace pattern"),_("When \"Endpoints specify minimum length and direction only\" is checked, the replace pattern must be a single open contour with at least 3 points on it."));
return( false );
}
} else if ( pathpointcnt(sv->sd.path)>0 ) {
/* It might make sense not to do a sub-pattern search if the */
/* replace pattern is closed... but that's kind of weird */
if ( check_replace && pathpointcnt(sv->sd.replacepath)<0 ) {
ff_post_error(_("Bad replace pattern"),_("When the search path is a single open contour, the replace pattern must also be."));
return( false );
}
}
sv->sd.fudge = fudge;
sv->sd.fudge_percent = sv->sd.tryrotate ? .01 : .001;
return( true );
}
int AW_ReadKernPairFile(char *fn,WidthInfo *wi) {
char *filename;
FILE *file;
int ch, format=0;
unichar_t buffer[300];
struct kernsets ks;
filename = utf82def_copy(fn);
file = fopen(filename,"r");
free( filename );
if ( file==NULL ) {
ff_post_error(_("Couldn't open file"), _("Couldn't open file %.200s"), fn );
free(fn);
return( false );
}
ch = getc(file);
if ( ch==0xff || ch==0xfe ) {
int ch2 = getc(file);
if ( ch==0xfe && ch2==0xff )
format = 1; /* normal ucs2 */
else if ( ch==0xff && ch2==0xfe )
format = 2; /* byte-swapped ucs2 */
else
rewind(file);
} else
ungetc(ch,file);
memset(&ks,0,sizeof(ks));
while ( ugetstr(file,format,buffer,sizeof(buffer)/sizeof(buffer[0]))!=NULL )
parsekernstr(buffer,&ks);
fclose(file);
if ( !figurekernsets(wi,&ks)) {
ff_post_error(_("No Kern Pairs"), _("No kerning pairs found in %.200s"), fn );
kernsetsfree(&ks);
return( false );
}
kernsetsfree(&ks);
free( fn );
return( true );
}
FILE *URLToTempFile(char *url,void *_lock) {
FILE *ret;
if ( strncasecmp(url,"http://",7)==0 )
return( HttpURLToTempFile(url,_lock));
else if ( strncasecmp(url,"ftp://",6)==0 ) {
if ( FtpURLAndTempFile(url,&ret,NULL))
return( ret );
return( NULL );
} else {
ff_post_error(_("Could not parse URL"),_("FontForge only handles ftp and http URLs at the moment"));
return( NULL );
}
}
static int SV_RplFind(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
SearchView *sv = (SearchView *) ((CharViewBase *) GDrawGetUserData(GGadgetGetWindow(g)))->container;
RefChar *rf;
if ( !SVParseDlg(sv,true))
return( true );
sv->sd.findall = sv->sd.replaceall = false;
for ( rf=sv->sd.sc_rpl.layers[ly_fore].refs; rf!=NULL; rf = rf->next ) {
if ( SCDependsOnSC(rf->sc,sv->sd.curchar)) {
ff_post_error(_("Self-referential glyph"),_("Attempt to make a glyph that refers to itself"));
return( true );
}
}
DoRpl(&sv->sd);
DoFindOne(sv,sv->sd.subpatternsearch);
}
return( true );
}
static int AnchorD_CorrectionChanged(GGadget *g, GEvent *e) {
AnchorDlg *a = GDrawGetUserData(GGadgetGetWindow(g));
if ( e->type==et_controlevent && e->u.control.subtype == et_textchanged ) {
const unichar_t *ret = _GGadgetGetTitle(g);
int is_y = GGadgetGetCid(g)==CID_YCor;
unichar_t *end;
int correction = u_strtol(ret,&end,10);
while ( *end==' ' ) ++end;
if ( *end!='\0' )
return( true );
if ( correction<-128 || correction>127 ) {
ff_post_error( _("Out of Range"), _("Corrections must be between -128 and 127 (and should be smaller)") );
return( true );
}
DeviceTableSet(is_y?&a->yadjust:&a->xadjust,a->pixelsize,correction);
GDrawRequestExpose(a->gw,NULL,false);
}
return( true );
}
Encoding *ParseEncodingNameFromList(GGadget *listfield) {
const unichar_t *name = _GGadgetGetTitle(listfield);
int32 len;
GTextInfo **ti = GGadgetGetList(listfield,&len);
int i;
Encoding *enc = NULL;
for ( i=0; i<len; ++i ) if ( ti[i]->text!=NULL ) {
if ( u_strcmp(name,ti[i]->text)==0 ) {
enc = FindOrMakeEncoding(ti[i]->userdata);
break;
}
}
if ( enc == NULL ) {
char *temp = u2utf8_copy(name);
enc = FindOrMakeEncoding(temp);
free(temp);
}
if ( enc==NULL )
ff_post_error(_("Bad Encoding"),_("Bad Encoding"));
return( enc );
}
static FILE *HttpURLToTempFile(const char *url, void *_lock) {
pthread_mutex_t *lock = _lock;
struct sockaddr_in addr;
char *pt, *host, *filename, *username, *password;
int port;
FILE *ret;
char buffer[300];
int first, code;
int soc;
int datalen, len;
char *databuf;
snprintf(buffer,sizeof(buffer),_("Downloading from %s"), url);
if ( strncasecmp(url,"http://",7)!=0 ) {
if ( lock!=NULL )
pthread_mutex_lock(lock);
ff_post_error(_("Could not parse URL"),_("Got something else when expecting an http URL"));
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( NULL );
}
if ( lock!=NULL )
pthread_mutex_lock(lock);
filename = decomposeURL(url, &host, &port, &username, &password);
/* I don't support username/passwords for http */
free( username ); free( password );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
if ( lock==NULL ) {
ff_progress_start_indicator(0,_("Font Download..."),buffer,
_("Resolving host"),1,1);
ff_progress_enable_stop(false);
ff_progress_allow_events();
ff_progress_allow_events();
}
/* This routine contains it's own lock */
if ( !findHTTPhost(&addr, host, port)) {
if ( lock==NULL )
ff_progress_end_indicator();
else
pthread_mutex_lock(lock);
ff_post_error(_("Could not find host"),_("Could not find \"%s\"\nAre you connected to the internet?"), host );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( false );
}
soc = makeConnection(&addr);
if ( soc==-1 ) {
if ( lock==NULL )
ff_progress_end_indicator();
else
pthread_mutex_lock(lock);
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), host );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( false );
}
if ( lock!=NULL )
pthread_mutex_lock(lock);
datalen = 8*8*1024;
databuf = malloc(datalen+1);
if ( lock!=NULL )
pthread_mutex_unlock(lock);
else
ChangeLine2_8(_("Requesting font..."));
sprintf( databuf,"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: FontForge\r\n"
"Connection: close\r\n\r\n", filename, host );
if ( write(soc,databuf,strlen(databuf))==-1 ) {
if ( lock==NULL )
ff_progress_end_indicator();
if ( lock!=NULL )
pthread_mutex_lock(lock);
ff_post_error(_("Could not send request"),_("Could not send request to \"%s\"."), host );
close( soc );
free( databuf );
free( host ); free( filename );
free( host ); free( filename );
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( NULL );
}
if ( lock==NULL )
ChangeLine2_8(_("Downloading font..."));
if ( lock!=NULL )
pthread_mutex_lock(lock);
ret = tmpfile();
if ( lock!=NULL )
pthread_mutex_unlock(lock);
first = 1;
code = 404;
while ((len = read(soc,databuf,datalen))>0 ) {
if ( first ) {
databuf[len] = '\0';
sscanf(databuf,"HTTP/%*f %d", &code );
first = 0;
/* check for redirects */
if ( code>=300 && code<399 && (pt=strstr(databuf,"Location: "))!=NULL ) {
char *newurl = pt + strlen("Location: ");
pt = strchr(newurl,'\r');
if ( *pt )
*pt = '\0';
close( soc );
if ( lock!=NULL )
pthread_mutex_lock(lock);
fclose(ret);
free(host); free( filename );
free(databuf);
if ( lock!=NULL )
pthread_mutex_unlock(lock);
ret = URLToTempFile(newurl,lock);
return( ret );
}
pt = strstr(databuf,"Content-Length: ");
if ( lock==NULL && pt!=NULL ) {
pt += strlen( "Content-Length: ");
ff_progress_change_total(strtol(pt,NULL,10));
}
pt = strstr(databuf,"\r\n\r\n");
if ( pt!=NULL ) {
pt += strlen("\r\n\r\n");
fwrite(pt,1,len-(pt-databuf),ret);
if ( lock==NULL )
ff_progress_increment(len-(pt-databuf));
}
} else {
fwrite(databuf,1,len,ret);
if ( lock==NULL )
ff_progress_increment(len);
}
}
if ( lock==NULL )
ff_progress_end_indicator();
close( soc );
free( databuf );
if ( lock!=NULL )
pthread_mutex_lock(lock);
free( host ); free( filename );
if ( len==-1 ) {
ff_post_error(_("Could not download data"),_("Could not download data.") );
fclose(ret);
ret = NULL;
} else if ( code<200 || code>299 ) {
ff_post_error(_("Could not download data"),_("HTTP return code: %d."), code );
fclose(ret);
ret = NULL;
} else
rewind(ret);
if ( lock!=NULL )
pthread_mutex_unlock(lock);
return( ret );
}
/* by LoadSplineFont (which does) and by RevertFile (which knows what it's doing) */
SplineFont *_ReadSplineFont(FILE *file,char *filename,enum openflags openflags) {
SplineFont *sf;
char ubuf[250], *temp;
int fromsfd = false;
int i;
char *pt, *strippedname, *oldstrippedname, *tmpfile=NULL, *paren=NULL, *fullname=filename, *rparen;
int len;
int checked;
int compression=0;
int wasurl = false, nowlocal = true;
if ( filename==NULL )
return( NULL );
strippedname = filename;
pt = strrchr(filename,'/');
if ( pt==NULL ) pt = filename;
/* Someone gave me a font "Nafees Nastaleeq(Updated).ttf" and complained */
/* that ff wouldn't open it */
/* Now someone will complain about "Nafees(Updated).ttc(fo(ob)ar)" */
if ( (paren = strrchr(pt,'('))!=NULL &&
(rparen = strrchr(paren,')'))!=NULL &&
rparen[1]=='\0' ) {
strippedname = copy(filename);
strippedname[paren-filename] = '\0';
}
pt = strrchr(strippedname,'.');
i = -1;
if ( pt!=NULL ) for ( i=0; compressors[i].ext!=NULL; ++i )
if ( strcmp(compressors[i].ext,pt)==0 )
break;
oldstrippedname = strippedname;
if ( i==-1 || compressors[i].ext==NULL )
i=-1;
else {
if ( file!=NULL ) {
char *spuriousname = ForceFileToHaveName(file,compressors[i].ext);
tmpfile = Decompress(spuriousname,i);
fclose(file); file = NULL;
unlink(spuriousname); free(spuriousname);
} else
tmpfile = Decompress(strippedname,i);
if ( tmpfile!=NULL ) {
strippedname = tmpfile;
} else {
ff_post_error(_("Decompress Failed!"),_("Decompress Failed!"));
return( NULL );
}
compression = i+1;
if ( strippedname!=filename && paren!=NULL ) {
fullname = galloc(strlen(strippedname)+strlen(paren)+1);
strcpy(fullname,strippedname);
strcat(fullname,paren);
} else
fullname = strippedname;
}
/* If there are no pfaedit windows, give them something to look at */
/* immediately. Otherwise delay a bit */
strcpy(ubuf,_("Loading font from "));
len = strlen(ubuf);
if ( !wasurl || i==-1 ) /* If it wasn't compressed, or it wasn't an url, then the fullname is reasonable, else use the original name */
strncat(ubuf,temp = copy(GFileNameTail(fullname)),100);
else
strncat(ubuf,temp = copy(GFileNameTail(filename)),100);
free(temp);
ubuf[100+len] = '\0';
ff_progress_start_indicator(FontViewFirst()==NULL?0:10,_("Loading..."),ubuf,_("Reading Glyphs"),0,1);
ff_progress_enable_stop(0);
if ( file==NULL ) {
file = fopen(strippedname,"rb");
nowlocal = true;
}
sf = NULL;
checked = false;
/* checked == false => not checked */
/* checked == 'u' => UFO */
/* checked == 't' => TTF/OTF */
/* checked == 'p' => pfb/general postscript */
/* checked == 'P' => pdf */
/* checked == 'c' => cff */
/* checked == 'S' => svg */
/* checked == 'f' => sfd */
/* checked == 'F' => sfdir */
/* checked == 'b' => bdf */
/* checked == 'i' => ikarus */
if ( file!=NULL ) {
/* Try to guess the file type from the first few characters... */
int ch1 = getc(file);
int ch2 = getc(file);
int ch3 = getc(file);
int ch4 = getc(file);
int ch9, ch10;
fseek(file, 98, SEEK_SET);
ch9 = getc(file);
ch10 = getc(file);
rewind(file);
if (( ch1==0 && ch2==1 && ch3==0 && ch4==0 ) ||
(ch1=='O' && ch2=='T' && ch3=='T' && ch4=='O') ||
(ch1=='t' && ch2=='r' && ch3=='u' && ch4=='e') ||
(ch1=='t' && ch2=='t' && ch3=='c' && ch4=='f') ) {
sf = _SFReadTTF(file,0,openflags,fullname,NULL);
checked = 't';
} else if (( ch1=='%' && ch2=='!' ) ||
( ch1==0x80 && ch2=='\01' ) ) { /* PFB header */
sf = _SFReadPostscript(file,fullname);
checked = 'p';
} else if ( ch1==1 && ch2==0 && ch3==4 ) {
int len;
fseek(file,0,SEEK_END);
len = ftell(file);
fseek(file,0,SEEK_SET);
sf = _CFFParse(file,len,NULL);
checked = 'c';
} /* Too hard to figure out a valid mark for a mac resource file */
if ( file!=NULL ) fclose(file);
}
if ( sf!=NULL )
/* good */;
else if (( strmatch(fullname+strlen(fullname)-4, ".ttf")==0 ||
strmatch(fullname+strlen(strippedname)-4, ".ttc")==0 ||
strmatch(fullname+strlen(fullname)-4, ".gai")==0 ||
strmatch(fullname+strlen(fullname)-4, ".otf")==0 ||
strmatch(fullname+strlen(fullname)-4, ".otb")==0 ) && checked!='t') {
sf = SFReadTTF(fullname,0,openflags);
} else if ( strmatch(fullname+strlen(strippedname)-4, ".bin")==0 ||
strmatch(fullname+strlen(strippedname)-4, ".hqx")==0 ||
strmatch(fullname+strlen(strippedname)-6, ".dfont")==0 ) {
sf = SFReadMacBinary(fullname,0,openflags);
} else if ( (strmatch(fullname+strlen(fullname)-4, ".pfa")==0 ||
strmatch(fullname+strlen(fullname)-4, ".pfb")==0 ||
strmatch(fullname+strlen(fullname)-4, ".pf3")==0 ||
strmatch(fullname+strlen(fullname)-4, ".cid")==0 ||
strmatch(fullname+strlen(fullname)-4, ".gsf")==0 ||
strmatch(fullname+strlen(fullname)-4, ".pt3")==0 ||
strmatch(fullname+strlen(fullname)-3, ".ps")==0 ) && checked!='p' ) {
sf = SFReadPostscript(fullname);
} else if ( strmatch(fullname+strlen(fullname)-4, ".cff")==0 && checked!='c' ) {
sf = CFFParse(fullname);
} else {
sf = SFReadMacBinary(fullname,0,openflags);
}
ff_progress_end_indicator();
if ( sf!=NULL ) {
SplineFont *norm = sf->mm!=NULL ? sf->mm->normal : sf;
if ( compression!=0 ) {
free(sf->filename);
*strrchr(oldstrippedname,'.') = '\0';
sf->filename = copy( oldstrippedname );
}
if ( fromsfd )
sf->compression = compression;
free( norm->origname );
if ( sf->chosenname!=NULL && strippedname==filename ) {
norm->origname = galloc(strlen(filename)+strlen(sf->chosenname)+8);
strcpy(norm->origname,filename);
strcat(norm->origname,"(");
strcat(norm->origname,sf->chosenname);
strcat(norm->origname,")");
} else
norm->origname = copy(filename);
free( norm->chosenname ); norm->chosenname = NULL;
if ( sf->mm!=NULL ) {
int j;
for ( j=0; j<sf->mm->instance_count; ++j ) {
free(sf->mm->instances[j]->origname);
sf->mm->instances[j]->origname = copy(norm->origname);
}
}
} else if ( !GFileExists(filename) )
ff_post_error(_("Couldn't open font"),_("The requested file, %.100s, does not exist"),GFileNameTail(filename));
else if ( !GFileReadable(filename) )
ff_post_error(_("Couldn't open font"),_("You do not have permission to read %.100s"),GFileNameTail(filename));
else
ff_post_error(_("Couldn't open font"),_("%.100s is not in a known format (or is so badly corrupted as to be unreadable)"),GFileNameTail(filename));
if ( oldstrippedname!=filename )
free(oldstrippedname);
if ( fullname!=filename && fullname!=strippedname )
free(fullname);
if ( tmpfile!=NULL ) {
unlink(tmpfile);
free(tmpfile);
}
if ( (openflags&of_fstypepermitted) && sf!=NULL && (sf->pfminfo.fstype&0xff)==0x0002 ) {
/* Ok, they have told us from a script they have access to the font */
} else if ( !fromsfd && sf!=NULL && (sf->pfminfo.fstype&0xff)==0x0002 ) {
char *buts[3];
buts[0] = _("_Yes"); buts[1] = _("_No"); buts[2] = NULL;
if ( ff_ask(_("Restricted Font"),(const char **) buts,1,1,_("This font is marked with an FSType of 2 (Restricted\nLicense). That means it is not editable without the\npermission of the legal owner.\n\nDo you have such permission?"))==1 ) {
SplineFontFree(sf);
return( NULL );
}
}
return( sf );
}
static int gettoken(struct context *c, real *val) {
int ch, i;
char *end, *pt;
char buffer[40];
if ( c->backed_token!=op_base ) {
ch = c->backed_token;
if ( ch==op_value )
*val = c->backed_val;
c->backed_token = op_base;
return( ch );
}
while (( ch = *(c->cur++))==' ' );
if ( isdigit(ch) || ch=='.' ) {
--(c->cur);
*val = strtod(c->cur,&end);
c->cur = end;
return( op_value );
} else if ( isalpha(ch)) {
pt = buffer; *pt++=ch;
while ( isalnum(c->cur[0])) {
if ( pt<buffer+sizeof(buffer)-1)
*pt++ = c->cur[0];
++c->cur;
}
*pt = '\0';
for ( i=0; builtins[i].name!=NULL; ++i ) {
if ( strcmp(buffer,builtins[i].name)==0 )
return( builtins[i].op );
}
ff_post_error(_("Bad Token"), _("Bad token \"%.30s\"\nnear ...%40s"), buffer, c->cur );
c->had_error = true;
while (( ch = *(c->cur++))==' ' );
if ( ch=='(' )
return( op_abs );
*val = 0;
return( op_value );
} else switch ( ch ) {
case '\0':
--(c->cur);
return( 0 );
case '!':
if ( *c->cur=='=' ) {
++c->cur;
return( op_ne );
}
return( op_not );
case '-':
return( op_sub );
case '+':
return( op_add );
case '*':
return( op_times );
case '/':
return( op_div );
case '%':
return( op_mod );
case '^':
return( op_pow );
case '>':
if ( *c->cur=='=' ) {
++c->cur;
return( op_ge );
}
return( op_gt );
case '<':
if ( *c->cur=='=' ) {
++c->cur;
return( op_le );
}
return( op_lt );
case '=':
if ( *c->cur=='=' ) {
++c->cur;
return( op_eq );
}
ff_post_error(_("Bad Token"), _("Bad token. Expected \"%.10s\" got \"%.10s\"\nnear ...%40s"), "==", "=" , c->cur );
c->had_error = true;
return( op_eq );
case '|':
if ( *c->cur=='|' ) {
++c->cur;
return( op_or );
}
ff_post_error(_("Bad Token"), _("Bad token. Expected \"%.10s\" got \"%.10s\"\nnear ...%40s"), "||", "|" , c->cur );
c->had_error = true;
return( op_or );
case '&':
if ( *c->cur=='&' ) {
++c->cur;
return( op_and );
}
ff_post_error(_("Bad Token"), _("Bad token. Expected \"%.10s\" got \"%.10s\"\nnear ...%40s"), "&&", "&" , c->cur );
c->had_error = true;
return( op_and );
case '?':
return( op_if );
case '(': case ')': case ':': case ',':
return( ch );
default:
ff_post_error(_("Bad Token"), _("Bad token. got \"%1$c\"\nnear ...%2$40s"), ch , c->cur );
c->had_error = true;
*val = 0;
return( op_value );
}
}
void DeltaSuggestionDlg(FontView *fv,CharView *cv) {
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[13], boxes[4];
GTextInfo label[13];
GGadgetCreateData *varray[7][5], *barray[9];
char dpi_buffer[40], within_buffer[40];
QGData *data;
int failed = false;
int k, r;
FontView *savefv;
if ( !hasFreeType() ) {
ff_post_error(_("No FreeType"),_("You must install the freetype library before using this command."));
return;
}
if ( !hasFreeTypeByteCode() ) {
ff_post_error(_("No FreeType"),_("Your version of the freetype library does not contain the bytecode interpreter."));
return;
}
if ( delta_sizes==NULL )
delta_sizes = copy("7-40,72,80,88,96");
data = calloc(1,sizeof(QGData));
data->fv = (FontViewBase *) fv;
data->cv = cv;
if ( cv!=NULL ) {
data->sc = cv->b.sc;
savefv = (FontView *) cv->b.fv;
data->layer = CVLayer((CharViewBase *) cv);
if ( !data->sc->parent->layers[data->layer].order2 )
failed = true;
if ( !failed && data->sc->ttf_instrs_len==0 )
ff_post_notice(_("No Instructions"),_("This glyph has no instructions. Adding instructions (a DELTA) may change its rasterization significantly."));
cv->qg = data;
cv->note_x = cv->note_y = 32766;
} else {
savefv = fv;
data->layer = fv->b.active_layer;
if ( !fv->b.sf->layers[data->layer].order2 )
failed = true;
}
if ( failed ) {
ff_post_error(_("Not quadratic"),_("This must be a truetype layer."));
free(data);
if ( cv!=NULL )
cv->qg = NULL;
return;
}
savefv->qg = data;
memset(&wattrs,0,sizeof(wattrs));
wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_undercursor|wam_isdlg|wam_restrict;
wattrs.event_masks = ~(1<<et_charup);
wattrs.restrict_input_to_me = 1;
wattrs.undercursor = 1;
wattrs.cursor = ct_pointer;
wattrs.utf8_window_title = _("DELTA suggestions");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,190));
pos.height = GDrawPointsToPixels(NULL,106);
data->gw = gw = GDrawCreateTopWindow(NULL,&pos,delta_e_h,data,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
k=r=0;
label[k].text = (unichar_t *) _(
"When a curve passes very close to the center of a\n"
"pixel you might want to check that the curve is on\n"
"the intended side of that pixel.\n"
"If it's on the wrong side, consider using a DELTA\n"
"instruction to adjust the closest point at the\n"
"current pixelsize."
);
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
label[k].text = (unichar_t *) _("Rasterize at sizes:");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
label[k].text = (unichar_t *) delta_sizes;
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.cid = CID_Sizes;
gcd[k++].creator = GTextFieldCreate;
varray[r][0] = &gcd[k-2]; varray[r][1] = &gcd[k-1]; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
label[k].text = (unichar_t *) _("DPI:");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
sprintf( dpi_buffer, "%d", delta_dpi );
label[k].text = (unichar_t *) dpi_buffer;
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.width = 40;
gcd[k].gd.cid = CID_DPI;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GTextFieldCreate;
label[k].text = (unichar_t *) _("_Mono");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = delta_depth==1 ? (gg_enabled|gg_visible|gg_cb_on) : (gg_enabled|gg_visible);
gcd[k].gd.cid = CID_BW;
gcd[k++].creator = GRadioCreate;
varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_HPad10;
label[k].text = (unichar_t *) _("_Anti-Aliased");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = delta_depth!=1 ? (gg_enabled|gg_visible|gg_cb_on) : (gg_enabled|gg_visible);
gcd[k++].creator = GRadioCreate;
varray[r][0] = &gcd[k-4]; varray[r][1] = &gcd[k-3]; varray[r][2] = &gcd[k-2]; varray[r][3] = &gcd[k-1]; varray[r++][4] = NULL;
label[k].text = (unichar_t *) _("Proximity:");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
sprintf( within_buffer, "%g", delta_within );
label[k].text = (unichar_t *) within_buffer;
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.pos.width = 40;
gcd[k].gd.cid = CID_Within;
gcd[k++].creator = GTextFieldCreate;
label[k].text = (unichar_t *) _("pixels");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
varray[r][0] = &gcd[k-3]; varray[r][1] = &gcd[k-2]; varray[r][2] = &gcd[k-1]; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
label[k].text = (unichar_t *) _( "This may take a while. Please be patient..." );
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled;
gcd[k].gd.cid = CID_Msg;
gcd[k++].creator = GLabelCreate;
varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
gcd[k].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[k].text = (unichar_t *) _("_OK");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.handle_controlevent = Delta_OK;
gcd[k].gd.cid = CID_Ok;
gcd[k++].creator = GButtonCreate;
barray[0] = GCD_Glue; barray[1] = &gcd[k-1]; barray[2] = GCD_Glue;
gcd[k].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[k].text = (unichar_t *) _("_Cancel");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.handle_controlevent = Delta_Cancel;
gcd[k].gd.cid = CID_Cancel;
gcd[k++].creator = GButtonCreate;
barray[3] = GCD_Glue; barray[4] = &gcd[k-1]; barray[5] = GCD_Glue; barray[6] = NULL;
boxes[2].gd.flags = gg_enabled|gg_visible;
boxes[2].gd.u.boxelements = barray;
boxes[2].creator = GHBoxCreate;
varray[r][0] = &boxes[2]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
varray[r][0] = NULL;
boxes[0].gd.pos.x = boxes[0].gd.pos.y = 2;
boxes[0].gd.flags = gg_enabled|gg_visible;
boxes[0].gd.u.boxelements = varray[0];
boxes[0].gd.cid = CID_Top;
boxes[0].creator = GHVGroupCreate;
GGadgetsCreate(gw,boxes);
GHVBoxFitWindow(boxes[0].ret);
GDrawSetVisible(gw,true);
while ( !data->done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
if ( data->cv!=NULL )
data->cv->qg = NULL;
if ( savefv->qg == data )
savefv->qg = NULL;
}
static int Delta_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
QGData *qg = GDrawGetUserData(GGadgetGetWindow(g));
int err=false;
int dpi, depth;
double within;
char *sizes;
within = GetReal8(qg->gw,CID_Within,_("Proximity"),&err);
dpi = GetInt8(qg->gw,CID_DPI,_("DPI"),&err);
if ( err )
return(true);
if ( within<=0 || within>=.5 ) {
ff_post_error(_("Bad Number"),_("The \"Proximity\" field must be more than 0 and less than a half."));
return( true );
}
if ( dpi<10 || dpi>5000 ) {
ff_post_error(_("Unreasonable DPI"),_("The \"DPI\" field must be more than 10 and less than 5000."));
return( true );
}
depth = GGadgetIsChecked(GWidgetGetControl(qg->gw,CID_BW)) ? 1 : 8;
sizes = GGadgetGetTitle8(GWidgetGetControl(qg->gw,CID_Sizes));
GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Msg),true);
GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Ok),false);
GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Cancel),false);
GDrawSetCursor(qg->gw,ct_watch);
GDrawProcessPendingEvents(NULL);
qg->within = within;
qg->dpi = dpi;
qg->pixelsizes = sizes;
qg->depth = depth;
TopFindQuestionablePoints(qg);
GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Msg),false);
GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Ok),true);
GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Cancel),true);
GDrawSetCursor(qg->gw,ct_pointer);
GDrawProcessPendingEvents(NULL);
if ( qg->error!=qg_ok ) {
switch ( qg->error ) {
case qg_notnumber:
ff_post_error(_("Bad Number"),_("An entry in the \"Sizes\" field is not a number."));
break;
case qg_badnumber:
ff_post_error(_("Bad Number"),_("An entry in the \"Sizes\" field is unreasonable."));
break;
case qg_badrange:
ff_post_error(_("Bad Number"),_("An range in the \"Sizes\" field is incorrectly ordered."));
break;
case qg_nofont:
ff_post_error(_("FreeType unavailable"),_("FreeType unavailable."));
break;
default:
IError(_("Unexpected error"));
break;
}
free(sizes);
qg->cur = 0;
return( true );
}
free(delta_sizes);
delta_within = within;
delta_dpi = dpi;
delta_depth = depth;
delta_sizes = sizes;
if ( qg->cur==0 ) {
ff_post_error(_("Nothing found"),_("Nothng found."));
qg->done = true;
return( true );
}
if ( qg->cur >= qg->max )
qg->qg = realloc(qg->qg,(qg->max += 1) * sizeof(QuestionableGrid));
memset(qg->qg+qg->cur,0,sizeof(QuestionableGrid));
GDrawSetVisible(qg->gw,false);
StartDeltaDisplay(qg);
qg->done = true;
}
return( true );
}
void SFUndoPerform( SFUndoes* undo, SplineFont* sf )
{
char* sfdchunk = 0;
FILE* sfd = 0;
switch(undo->type) {
case sfut_fontinfo:
sfdchunk = undo->sfdchunk;
printf("font level undo, font info sfd:%s\n", sfdchunk );
sfd = MakeTemporaryFile();
fwrite( sfdchunk, strlen(sfdchunk), 1, sfd );
fseek( sfd, 0, SEEK_SET );
SFD_GetFontMetaDataData d;
SFD_GetFontMetaDataData_Init( &d );
visitSFDFragment( sfd, sf, SFD_GetFontMetaData, &d );
break;
case sfut_lookups_kerns:
case sfut_lookups:
sfdchunk = undo->sfdchunk;
if( !sfdchunk ) {
ff_post_error(_("Undo information incomplete"),_("There is a splinefont level undo, but it does not contain any information to perform the undo. This is an application error, please report what you last did to the lookup tables so the developers can try to reproduce the issue and fix it."));
SFUndoRemoveAndFree( sf, undo );
return;
}
// Roll it on back!
sfd = MakeTemporaryFile();
fwrite( sfdchunk, strlen(sfdchunk), 1, sfd );
fseek( sfd, 0, SEEK_SET );
while( 1 ) {
char* name = SFDMoveToNextStartChar( sfd );
if( !name )
break;
int unienc = 0;
SplineChar *sc;
sc = SFGetChar( sf, unienc, name );
if( !sc ) {
ff_post_error(_("Bad undo"),_("couldn't find the character %s"), name );
break;
}
if( sc ) {
// Free the stuff in sc->psts so we don't leak it.
if( undo->type == sfut_lookups ) {
PSTFree(sc->possub);
sc->possub = 0;
}
char tok[2000];
getname( sfd, tok );
SFDGetPSTs( sfd, sc, tok );
SFDGetKerns( sfd, sc, tok );
}
free(name);
}
if( undo->type == sfut_lookups_kerns ) {
SFDFixupRefs( sf );
}
break;
}
}
static int FtpURLAndTempFile(const char *url,FILE **to,FILE *from) {
struct sockaddr_in addr, data_addr;
char *host, *filename, *username, *password;
int port;
FILE *ret;
char buffer[300];
int soc, data;
int datalen, len;
char *databuf, *cmd;
if ( from==NULL ) {
snprintf(buffer,sizeof(buffer),_("Downloading from %s"), url);
*to = NULL;
} else
snprintf(buffer,sizeof(buffer),_("Uploading to %s"), url);
if ( strncasecmp(url,"ftp://",6)!=0 ) {
ff_post_error(_("Could not parse URL"),_("Got something else when expecting an ftp URL"));
return( false );
}
filename = decomposeURL(url, &host, &port, &username, &password);
ff_progress_start_indicator(0,_("Font Download..."),buffer,
_("Resolving host"),1,1);
ff_progress_enable_stop(false);
ff_progress_allow_events();
ff_progress_allow_events();
if ( !findFTPhost(&addr, host, port)) {
ff_progress_end_indicator();
ff_post_error(_("Could not find host"),_("Could not find \"%s\"\nAre you connected to the internet?"), host );
free( host ); free( filename );
return( false );
}
soc = makeConnection(&addr);
if ( soc==-1 ) {
ff_progress_end_indicator();
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), host );
free( host ); free( filename );
return( false );
}
datalen = 8*8*1024;
databuf = malloc(datalen+1);
cmd = databuf;
ChangeLine2_8(_("Logging in..."));
if ( getresponse(soc,databuf,datalen) == -1 ) { /* ftp servers say "Hi" when then connect */
ff_progress_end_indicator();
ff_post_error(_("Could not connect to host"),_("Could not connect to \"%s\"."), host );
free( host ); free( filename ); free(username); free(password);
close( soc );
return( false );
}
free( host );
if ( username==NULL ) {
username=copy("anonymous");
if ( password==NULL )
password=copy("FontForge");
} else if ( password==NULL )
password = copy("");
sprintf(cmd,"USER %s\r\n", username);
if ( ftpsendr(soc,cmd,databuf,datalen)== -1 ) {
ff_progress_end_indicator();
close( soc ); free(filename); free(databuf); free(username); free(password);
return( false );
}
sprintf(cmd,"PASS %s\r\n", password);
free(username); free(password);
if ( ftpsendr(soc,cmd,databuf,datalen)<=0 ) {
ff_progress_end_indicator();
LogError(_("Bad Username/Password\n"));
close( soc ); free(filename); free(databuf);
return( false );
}
if ( ftpsendr(soc,"TYPE I\r\n",databuf,datalen)==-1 ) { /* Binary */
ff_progress_end_indicator();
close( soc ); free(filename); free(databuf);
return( false );
}
if ( from==NULL )
ChangeLine2_8(_("Requesting font..."));
else
ChangeLine2_8(_("Transmitting font..."));
if ( ftpsendpassive(soc,&data_addr,databuf,datalen)<= 0 ) {
ff_progress_end_indicator();
close( soc ); free(filename); free(databuf);
return( false );
}
if (( data = socket(PF_INET,SOCK_STREAM,0))==-1 ||
connect(data,(struct sockaddr *) &data_addr,sizeof(data_addr))== -1 ) {
ff_progress_end_indicator();
if ( data!=-1 )
close(data);
close( soc ); free(filename); free(databuf);
LogError(_("FTP passive Data Connect failed\n"));
return( 0 );
}
if ( from==NULL ) {
sprintf(cmd,"RETR %s\r\n", filename);
if ( ftpsendr(soc,cmd, databuf, datalen)<=0 ) {
ff_progress_end_indicator();
ff_post_error(_("Could not download data"),_("Could not find file.") );
close(data);
close( soc ); free(filename); free(databuf);
return( false );
}
ChangeLine2_8(_("Downloading font..."));
ret = tmpfile();
while ((len = read(data,databuf,datalen))>0 ) {
fwrite(databuf,1,len,ret);
}
*to = ret;
rewind(ret);
} else {
sprintf(cmd,"STOR %s\r\n", filename);
if ( ftpsendr(soc,cmd, databuf, datalen)<=0 ) {
ff_progress_end_indicator();
ff_post_error(_("Could not download data"),_("Could not find file.") );
close(data);
close( soc ); free(filename); free(databuf);
return( false );
}
ChangeLine2_8(_("Uploading font..."));
rewind(from);
while ((len = fread(databuf,1,datalen,from))>0 ) {
if ( (len = write(data,databuf,len))<0 )
break;
}
ret = NULL;
}
ff_progress_end_indicator();
close( soc ); close( data );
free( databuf );
free( filename );
if ( len==-1 ) {
ff_post_error(_("Could not transmit data"),_("Could not transmit data.") );
if ( ret!=NULL ) fclose(ret);
return( false );
}
return( true );
}
static SplineChar *AddAnchor(AnchorDlg *a, SplineFont *sf, AnchorClass *ac,
int ismarklike) {
char *ret, *def;
SplineChar *sc;
int isliga = false, ismrk=false, maxlig=-1;
AnchorPoint *ap;
PST *pst;
int i;
def = copy(".notdef");
for (;;) {
ret = gwwv_ask_string(_("Provide a glyph name"),def,_("Please identify a glyph by name, and FontForge will add an anchor to that glyph."));
free(def);
if ( ret==NULL )
return( NULL );
sc = SFGetChar(sf,-1,ret);
def = ret;
if ( sc==NULL )
ff_post_error(_("Non-existant glyph"), _("The glyph, %.80s, is not in the font"), ret );
else {
isliga = ismrk = false;
for ( ap=sc->anchor ; ap!=NULL; ap=ap->next ) {
if ( ap->type == at_baselig )
isliga = true;
else if ( ap->type == at_basemark || ap->type == at_mark )
ismrk = true;
if ( ap->anchor == ac ) {
if ( (ap->type == at_centry ||
(ap->type == at_mark && ac->type==act_mkmk) ||
ap->type == at_baselig ) && ismarklike==-1 )
ismarklike = false;
else if ( (ap->type == at_cexit || (ap->type == at_basemark && ac->type==act_mkmk)) && ismarklike==-1 )
ismarklike = true;
else if ( ap->type != at_baselig ||
( ap->type == at_baselig && ismarklike>0 ))
ff_post_error(_("Duplicate Anchor Class"), _("The glyph, %.80s, already contains an anchor in this class, %.80s."), ret, ac->name );
else if ( maxlig<ap->lig_index )
maxlig = ap->lig_index;
break;
}
}
if ( ap==NULL )
break;
}
}
ap = chunkalloc(sizeof(AnchorPoint));
ap->anchor = ac;
ap->me.x = ap->me.y = 0;
ap->next = sc->anchor;
sc->anchor = ap;
SCCharChangedUpdate(sc,ly_none);
if ( sc->width==0 ) ismrk = true;
for ( pst=sc->possub; pst!=NULL; pst=pst->next ) {
if ( pst->type == pst_ligature || pst->type == pst_lcaret ) {
isliga = true;
break;
}
}
if ( isliga || (ac->type==act_mklg && ismarklike==0 ) ) {
ap->type = at_baselig;
ap->lig_index = maxlig+1;
} else if ( ismrk && ismarklike!=0 )
ap->type = at_mark;
else if ( ismarklike==0 && (ismrk || ac->type==act_mkmk) )
ap->type = at_basemark;
else if ( ac->type == act_curs ) {
if ( ismarklike==true )
ap->type = at_centry;
else
ap->type = at_cexit;
} else if ( ismarklike==true )
ap->type = at_mark;
else
ap->type = at_basechar;
if ( a!=NULL ) {
GTextInfo **ti = AnchorD_GlyphsInClass(a);
GGadgetSetList(GWidgetGetControl(a->gw,CID_Glyph),ti,false);
for ( i=0; ti[i]->text!=NULL || ti[i]->line; ++i ) {
if ( ti[i]->userdata == ap ) {
GGadgetSelectOneListItem(GWidgetGetControl(a->gw,CID_Glyph),i);
break;
}
}
AnchorD_ChangeGlyph(a,sc,ap);
}
return( sc );
}