static int CW_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
int err = false;
CreateWidthDlg *wd = GDrawGetUserData(GGadgetGetWindow(g));
if ( GGadgetIsChecked(GWidgetGetControl(wd->gw,CID_Set)) ) {
wd->wd.type = st_set;
wd->wd.setto = GetReal8(wd->gw,CID_SetVal,rb1[wd->wd.wtype],&err);
if ( wd->wd.setto<0 && wd->wd.wtype==wt_width ) {
char *yesno[3];
yesno[0] = _("_Yes");
yesno[1] = _("_No");
yesno[2] = NULL;
if ( gwwv_ask(_("Negative Width"), (const char **) yesno, 0, 1, _("Negative glyph widths are not allowed in TrueType\nDo you really want a negative width?") )==1 )
return( true );
}
} else if ( GGadgetIsChecked(GWidgetGetControl(wd->gw,CID_Incr)) ) {
wd->wd.type = st_incr;
wd->wd.increment = GetReal8(wd->gw,CID_IncrVal,rb2[wd->wd.wtype],&err);
} else {
wd->wd.type = st_scale;
wd->wd.scale = GetReal8(wd->gw,CID_ScaleVal,rb2[wd->wd.wtype],&err);
}
if ( err )
return(true);
(wd->wd.doit)((CreateWidthData *) wd);
}
return( true );
}
static int GetSystem(GWindow gw) {
if ( GGadgetIsChecked(GWidgetGetControl(gw,CID_X)) )
return( CID_X );
if ( GGadgetIsChecked(GWidgetGetControl(gw,CID_Win)) )
return( CID_Win );
return( CID_Mac );
}
static int L2L_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
L2LDlg *d = GDrawGetUserData(GGadgetGetWindow(g));
int from, to, clear;
int err=0;
double errbound;
from = GGadgetGetFirstListSelectedItem(GWidgetGetControl(d->gw,CID_FromLayer));
to = GGadgetGetFirstListSelectedItem(GWidgetGetControl(d->gw,CID_ToLayer));
if ( d->l2l==l2l_copy ) {
clear = GGadgetIsChecked(GWidgetGetControl(d->gw,CID_ClearOld));
if ( d->cv )
_DoCVCopy(d->cv,from,to,clear);
else
_DoFVCopy(d->fv,from,to,clear);
} else {
errbound = GetReal8(d->gw,CID_ErrorBound,_("Error Bound"),&err);
if ( err )
return( true );
if ( d->cv )
_DoCVCompare(d->cv,from,to,errbound);
else
_DoFVCompare(d->fv,from,to,errbound);
}
d->done = true;
}
return( true );
}
static void Do_OKRegen(ReviewHintData *hd) {
SplineChar *sc = hd->cv->b.sc;
StemInfo *curh = sc->hstem, *curv = sc->vstem;
int do_regen = GGadgetIsChecked(GWidgetGetControl(hd->gw,CID_RegenHM));
/* We go backwards here, but not for long. The point is to go back to */
/* the original hint state so we can preserve it, now that we know we*/
/* are going to modify it */
sc->hstem = hd->oldh; sc->vstem = hd->oldv;
SCPreserveHints(sc,CVLayer((CharViewBase *) hd->cv));
sc->hstem = curh; sc->vstem = curv;
StemInfosFree(hd->oldh);
StemInfosFree(hd->oldv);
if ( hd->lastactive!=NULL )
hd->lastactive->active = false;
if ( hd->changed ) {
SCClearHintMasks(hd->cv->b.sc,CVLayer((CharViewBase *) (hd->cv)),true);
if ( do_regen )
SCFigureHintMasks(hd->cv->b.sc,CVLayer((CharViewBase *) (hd->cv)));
}
/* Everything else got done as we went along... */
SCOutOfDateBackground(hd->cv->b.sc);
SCUpdateAll(hd->cv->b.sc);
SCHintsChanged(hd->cv->b.sc);
hd->done = true;
}
static int RH_HVStem(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_radiochanged ) {
ReviewHintData *hd = GDrawGetUserData(GGadgetGetWindow(g));
hd->ishstem = GGadgetIsChecked(GWidgetGetControl(GGadgetGetWindow(g),CID_HStem));
hd->active = hd->ishstem ? hd->cv->b.sc->hstem : hd->cv->b.sc->vstem;
RH_SetupHint(hd);
}
return( true );
}
static int FtPpem_PtYChanged(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_textchanged ) {
FtSizeData *fsd = GDrawGetUserData(GGadgetGetWindow(g));
if ( GGadgetIsChecked(GWidgetGetControl(fsd->gw,CID_SameAs))) {
const unichar_t *y = _GGadgetGetTitle(g);
GGadgetSetTitle(GWidgetGetControl(fsd->gw,CID_PointSizeX),y);
}
}
return( true );
}
static int FtPpem_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
FtSizeData *fsd = GDrawGetUserData(GGadgetGetWindow(g));
int _dpi, _depth;
real ptsize, ptsizex;
int err = 0;
CharView *cv = fsd->cv;
ptsize = GetReal8(fsd->gw,CID_PointSize,_("Pointsize Y"),&err);
if ( GGadgetIsChecked(GWidgetGetControl(fsd->gw,CID_SameAs)) )
ptsizex = ptsize;
else
ptsizex = GetReal8(fsd->gw,CID_PointSizeX,_("Pointsize X"),&err);
_dpi = GetInt8(fsd->gw,CID_DPI,_("DPI"),&err);
_depth = GGadgetIsChecked(GWidgetGetControl(fsd->gw,CID_BW)) ? 1 : 8;
if ( err )
return(true);
last_fpgm = GGadgetIsChecked(GWidgetGetControl(fsd->gw,CID_Debugfpgm));
cv->ft_pointsizey = ptsize; cv->ft_dpi = _dpi; cv->ft_depth = _depth;
cv->ft_pointsizex = ptsizex;
cv->ft_ppemy = rint(cv->ft_pointsizey*cv->ft_dpi/72.0);
cv->ft_ppemx = rint(cv->ft_pointsizex*cv->ft_dpi/72.0);
gridfit_dpi = _dpi; gridfit_pointsizey = ptsize; gridfit_depth = _depth;
gridfit_pointsizex = ptsizex; gridfit_x_sameas_y = GGadgetIsChecked(GWidgetGetControl(fsd->gw,CID_SameAs));
SavePrefs(true);
SplinePointListsFree(cv->b.gridfit); cv->b.gridfit = NULL;
FreeType_FreeRaster(cv->raster); cv->raster = NULL;
if ( fsd->debug )
CVDebugReInit(cv,true,last_fpgm);
else {
cv->show_ft_results = true;
CVGridFitChar(cv);
}
CVLayersSet(cv);
fsd->done = true;
SCRefreshTitles(cv->b.sc);
}
return( true );
}
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 );
}
static int FtPpem_SameAsChanged(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_radiochanged ) {
FtSizeData *fsd = GDrawGetUserData(GGadgetGetWindow(g));
if ( GGadgetIsChecked(g)) {
const uint32_t *y = _GGadgetGetTitle(GWidgetGetControl(fsd->gw,CID_PointSize));
GGadgetSetTitle(GWidgetGetControl(fsd->gw,CID_PointSizeX),y);
GGadgetSetEnabled(GWidgetGetControl(fsd->gw,CID_PointSizeX),false);
} else {
GGadgetSetEnabled(GWidgetGetControl(fsd->gw,CID_PointSizeX),true);
}
}
return( true );
}
static int SD_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
struct sd_data *sd = GDrawGetUserData(GGadgetGetWindow(g));
#if !defined(_NO_FFSCRIPT) && !defined(_NO_PYTHON)
if ( GGadgetIsChecked(GWidgetGetControl(GGadgetGetWindow(g),CID_Python)) )
ExecPython(g,e);
else
ExecNative(g,e);
#elif !defined(_NO_PYTHON)
ExecPython(g,e);
#elif !defined(_NO_FFSCRIPT)
ExecNative(g,e);
#endif
sd->done = true;
}
return( true );
}
static int RH_TextChanged(GGadget *g, GEvent *e) {
int wasconflict;
if ( e->type==et_controlevent && e->u.control.subtype == et_textchanged ) {
ReviewHintData *hd = GDrawGetUserData(GGadgetGetWindow(g));
if ( hd->active!=NULL ) {
int cid = GGadgetGetCid(g);
int err=0;
real start = GetCalmReal8(hd->gw,CID_Base,_("Base:"),&err);
real width = GetCalmReal8(hd->gw,CID_Width,_("Size:"),&err);
if ( err )
return( true );
if ( GGadgetIsChecked(GWidgetGetControl(GGadgetGetWindow(g),CID_MovePoints)) ) {
if ( width<0 )
RH_MovePoints(hd,hd->active,start+width,-width);
else
RH_MovePoints(hd,hd->active,start,width);
}
if ( cid==CID_Base )
hd->active->start = start;
else
hd->active->width = width;
if ( width<0 ) {
hd->active->ghost = true;
hd->active->width = -width;
hd->active->start = start+width;
} else
hd->active->ghost = false;
wasconflict = hd->active->hasconflicts;
if ( hd->ishstem )
hd->cv->b.sc->hconflicts = StemListAnyConflicts(hd->cv->b.sc->hstem);
else
hd->cv->b.sc->vconflicts = StemListAnyConflicts(hd->cv->b.sc->vstem);
hd->cv->b.sc->manualhints = true;
hd->changed = true;
if ( wasconflict!=hd->active->hasconflicts ) {
GGadgetSetVisible(GWidgetGetControl(hd->gw,CID_Overlap),hd->active->hasconflicts);
if ( hd->active->hasconflicts )
GHVBoxFitWindow(GWidgetGetControl(hd->gw,CID_TopBox));
}
SCOutOfDateBackground(hd->cv->b.sc);
SCUpdateAll(hd->cv->b.sc);
}
}
return( true );
}
static void _SD_LangChanged(struct sd_data *sd) {
GGadgetSetEnabled(GWidgetGetControl(sd->gw,CID_Call),
!GGadgetIsChecked(GWidgetGetControl(sd->gw,CID_Python)));
}
static int Trans_OK(GGadget *g, GEvent *e) {
real transform[6], trans[6], t[6];
bigreal angle, angle2;
int i, index, err;
int alllayers = false, round_2_int = false, dokerns = false, dokp=false;
int dogrid = false, dowidth = false;
BasePoint base;
int origin, bvpos=0;
BVTFunc bvts[TCnt+1];
static int warned = false;
int isapply = GGadgetGetCid(g) == CID_Apply;
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
TransData *td = GDrawGetUserData(GGadgetGetWindow(g));
transform[0] = transform[3] = 1.0;
transform[1] = transform[2] = transform[4] = transform[5] = 0;
base.x = base.y = 0;
origin = GGadgetGetFirstListSelectedItem( GWidgetGetControl(td->gw,CID_Origin));
if ( GWidgetGetControl(td->gw,CID_AllLayers)!=NULL )
alllayers = GGadgetIsChecked(GWidgetGetControl(td->gw,CID_AllLayers));
if ( GWidgetGetControl(td->gw,CID_DoGrid)!=NULL )
dogrid = GGadgetIsChecked(GWidgetGetControl(td->gw,CID_DoGrid));
if ( GWidgetGetControl(td->gw,CID_DoWidth)!=NULL )
dowidth = GGadgetIsChecked(GWidgetGetControl(td->gw,CID_DoWidth));
else
dowidth = true;
if ( GWidgetGetControl(td->gw,CID_DoSimplePos)!=NULL )
dokp = GGadgetIsChecked(GWidgetGetControl(td->gw,CID_DoSimplePos));
if ( GWidgetGetControl(td->gw,CID_DoKerns)!=NULL )
dokerns = GGadgetIsChecked(GWidgetGetControl(td->gw,CID_DoKerns));
round_2_int = GGadgetIsChecked(GWidgetGetControl(td->gw,CID_Round2Int));
if ( isapply )
alllayers = dogrid = dokp = dokerns = false;
if ( td->getorigin!=NULL ) {
(td->getorigin)(td->userdata,&base,origin );
transform[4] = -base.x;
transform[5] = -base.y;
}
for ( i=0; i<TCnt; ++i ) {
index = GGadgetGetFirstListSelectedItem(
GWidgetGetControl(td->gw,CID_Type+i*TBlock_CIDOffset));
trans[0] = trans[3] = 1.0;
trans[1] = trans[2] = trans[4] = trans[5] = 0;
err = 0;
switch ( index ) {
case 0: /* Do Nothing */
break;
case 1: /* Move */
trans[4] = GetReal8(td->gw,CID_XMove+i*TBlock_CIDOffset,_("X Movement"),&err);
trans[5] = GetReal8(td->gw,CID_YMove+i*TBlock_CIDOffset,_("Y Movement"),&err);
bvts[bvpos].x = trans[4]; bvts[bvpos].y = trans[5]; bvts[bvpos++].func = bvt_transmove;
break;
case 2: /* Rotate */
angle = GetReal8(td->gw,CID_Angle+i*TBlock_CIDOffset,_("Rotation Angle"),&err);
if ( GGadgetIsChecked( GWidgetGetControl(td->gw,CID_Clockwise+i*TBlock_CIDOffset)) )
angle = -angle;
if ( fmod(angle,90)!=0 )
bvts[0].func = bvt_none; /* Bad trans=> No trans */
else {
angle = fmod(angle,360);
if ( angle<0 ) angle+=360;
if ( angle==90 ) bvts[bvpos++].func = bvt_rotate90ccw;
else if ( angle==180 ) bvts[bvpos++].func = bvt_rotate180;
else if ( angle==270 ) bvts[bvpos++].func = bvt_rotate90cw;
}
angle *= 3.1415926535897932/180;
trans[0] = trans[3] = cos(angle);
trans[2] = -(trans[1] = sin(angle));
break;
case 3: /* Scale Uniformly */
trans[0] = trans[3] = GetReal8(td->gw,CID_Scale+i*TBlock_CIDOffset,_("Scale Factor"),&err)/100.0;
bvts[0].func = bvt_none; /* Bad trans=> No trans */
break;
case 4: /* Scale */
trans[0] = GetReal8(td->gw,CID_XScale+i*TBlock_CIDOffset,_("X Scale Factor"),&err)/100.0;
trans[3] = GetReal8(td->gw,CID_YScale+i*TBlock_CIDOffset,_("Y Scale Factor"),&err)/100.0;
bvts[0].func = bvt_none; /* Bad trans=> No trans */
break;
case 5: /* Flip */
if ( GGadgetIsChecked( GWidgetGetControl(td->gw,CID_Horizontal+i*TBlock_CIDOffset)) ) {
trans[0] = -1;
bvts[bvpos++].func = bvt_fliph;
} else {
trans[3] = -1;
bvts[bvpos++].func = bvt_flipv;
}
break;
case 6: /* Skew */
angle = GetReal8(td->gw,CID_SkewAng+i*TBlock_CIDOffset,_("Skew Angle"),&err);
if ( GGadgetIsChecked( GWidgetGetControl(td->gw,CID_CounterClockwise+i*TBlock_CIDOffset)) )
angle = -angle;
angle *= 3.1415926535897932/180;
trans[2] = tan(angle);
skewselect(&bvts[bvpos],trans[2]); ++bvpos;
break;
case 7: /* 3D rotate */
angle = GetReal8(td->gw,CID_XAxis+i*TBlock_CIDOffset,_("Rotation about X Axis"),&err) * 3.1415926535897932/180;
angle2 = GetReal8(td->gw,CID_YAxis+i*TBlock_CIDOffset,_("Rotation about Y Axis"),&err) * 3.1415926535897932/180;
trans[0] = cos(angle2);
trans[3] = cos(angle );
bvts[0].func = bvt_none; /* Bad trans=> No trans */
break;
default:
IError("Unexpected selection in Transform");
err = 1;
break;
}
if ( err )
return(true);
#if 0
printf( "(%g,%g,%g,%g,%g,%g)*(%g,%g,%g,%g,%g,%g) = ",
trans[0], trans[1], trans[2], trans[3], trans[4], trans[5],
transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]);
#endif
t[0] = transform[0]*trans[0] +
transform[1]*trans[2];
t[1] = transform[0]*trans[1] +
transform[1]*trans[3];
t[2] = transform[2]*trans[0] +
transform[3]*trans[2];
t[3] = transform[2]*trans[1] +
transform[3]*trans[3];
t[4] = transform[4]*trans[0] +
transform[5]*trans[2] +
trans[4];
t[5] = transform[4]*trans[1] +
transform[5]*trans[3] +
trans[5];
memcpy(transform,t,sizeof(t));
#if 0
printf( "(%g,%g,%g,%g,%g,%g)\n",
transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]);
#endif
}
bvts[bvpos++].func = bvt_none; /* Done */
for ( i=0; i<6; ++i )
if ( RealNear(transform[i],0)) transform[i] = 0;
transform[4] += base.x;
transform[5] += base.y;
if (( transform[1]!=0 || transform[2]!=0 ) && !warned ) {
ff_post_notice(_("Warning"),_("After rotating or skewing a glyph you should probably apply Element->Add Extrema"));
warned = true;
}
(td->transfunc)(td->userdata,transform,origin,bvts,
(alllayers?fvt_alllayers:0)|
(dogrid?fvt_dogrid:0)|
(dowidth?0:fvt_dontmovewidth)|
(round_2_int?fvt_round_to_int:0)|
(dokp?fvt_scalepstpos:0)|
(dokerns?fvt_scalekernclasses:0)|
(isapply?fvt_justapply:0));
td->done = !isapply;
td->applied = isapply;
}
return( true );
}
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 );
}
int GotoChar(SplineFont *sf,EncMap *map,int *merge_with_selection) {
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[9], boxes[3], *hvarray[6][2], *barray[10];
GTextInfo label[9];
static GotoData gd;
GTextInfo *ranges = NULL;
int k,j;
if ( !map->enc->only_1byte )
ranges = AvailableRanges(sf,map);
memset(&gd,0,sizeof(gd));
gd.sf = sf;
gd.map = map;
gd.ret = -1;
gd.ranges = ranges;
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 = _("Goto");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,170));
pos.height = GDrawPointsToPixels(NULL,90);
gd.gw = gw = GDrawCreateTopWindow(NULL,&pos,goto_e_h,&gd,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
k=j=0;
label[k].text = (unichar_t *) _("Enter the name of a glyph in the font");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].creator = GLabelCreate;
hvarray[j][0] = &gcd[k++]; hvarray[j++][1] = NULL;
gcd[k].gd.flags = gg_enabled|gg_visible|gg_text_xim;
gcd[k].gd.cid = CID_Name;
if ( ranges==NULL )
gcd[k].creator = GTextCompletionCreate;
else {
gcd[k].gd.u.list = ranges;
gcd[k].creator = GListFieldCreate;
}
hvarray[j][0] = &gcd[k++]; hvarray[j++][1] = NULL;
if ( merge_with_selection!=NULL ) {
label[k].text = (unichar_t *) _("Merge into selection");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.cid = CID_MergeWithSelection;
gcd[k].gd.flags = *merge_with_selection ?
gg_enabled|gg_visible|gg_cb_on :
gg_enabled|gg_visible;
gcd[k].creator = GCheckBoxCreate;
hvarray[j][0] = &gcd[k++]; hvarray[j++][1] = NULL;
}
hvarray[j][0] = GCD_Glue; hvarray[j++][1] = 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 = Goto_OK;
gcd[k].creator = GButtonCreate;
barray[0] = GCD_Glue; barray[1] = &gcd[k++]; barray[2] = GCD_Glue; barray[3] = 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 = Goto_Cancel;
gcd[k].creator = GButtonCreate;
barray[4] = GCD_Glue; barray[5] = &gcd[k++]; barray[6] = GCD_Glue; barray[7] = NULL;
boxes[2].gd.flags = gg_visible | gg_enabled;
boxes[2].gd.u.boxelements = barray;
boxes[2].creator = GHBoxCreate;
hvarray[j][0] = &boxes[2]; hvarray[j++][1] = NULL;
hvarray[j][0] = NULL;
boxes[0].gd.pos.x = boxes[0].gd.pos.y = 2;
boxes[0].gd.flags = gg_visible | gg_enabled;
boxes[0].gd.u.boxelements = hvarray[0];
boxes[0].creator = GHVGroupCreate;
GGadgetsCreate(gw,boxes);
GCompletionFieldSetCompletion(gcd[1].ret,GotoCompletion);
GCompletionFieldSetCompletionMode(gcd[1].ret,true);
GHVBoxSetExpandableRow(boxes[0].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[2].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[0].ret);
GDrawSetVisible(gw,true);
while ( !gd.done )
GDrawProcessOneEvent(NULL);
if ( merge_with_selection!=NULL )
*merge_with_selection = GGadgetIsChecked(GWidgetGetControl(gw,CID_MergeWithSelection));
GDrawDestroyWindow(gw);
return( gd.ret );
}
void CVReviewHints(CharView *cv) {
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[18], *harray1[6], *harray2[6], *harray3[6], *harray4[6],
*varray[7][2], boxes[8], *barray[6][6];
GTextInfo label[18];
static ReviewHintData hd;
int k;
hd.done = false;
hd.cv = cv;
if ( hd.gw==NULL ) {
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 = _("Review Hints");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,170));
pos.height = GDrawPointsToPixels(NULL,178);
hd.gw = gw = GDrawCreateTopWindow(NULL,&pos,rh_e_h,&hd,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
k=0;
label[k].text = (unichar_t *) _("_HStem");
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|gg_cb_on;
gcd[k].gd.cid = CID_HStem;
gcd[k].gd.handle_controlevent = RH_HVStem;
gcd[k].creator = GRadioCreate;
harray2[0] = &gcd[k++];
label[k].text = (unichar_t *) _("_VStem");
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_VStem;
gcd[k].gd.handle_controlevent = RH_HVStem;
gcd[k].creator = GRadioCreate;
harray2[1] = &gcd[k++];
label[k].text = (unichar_t *) "999/999 hstem3";
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.cid = CID_Count;
gcd[k].creator = GLabelCreate;
harray2[2] = GCD_HPad10; harray2[3] = &gcd[k++]; harray2[4] = GCD_Glue; harray2[5] = NULL;
label[k].text = (unichar_t *) _("_Move Points");
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|gg_utf8_popup;
gcd[k].gd.cid = CID_MovePoints;
gcd[k].gd.popup_msg = (unichar_t *) _("When the hint's position is changed\nadjust the postion of any points\nwhich lie on that hint");
gcd[k].creator = GCheckBoxCreate;
harray3[0] = &gcd[k++]; harray3[1] = GCD_Glue; harray3[2] = NULL;
label[k].text = (unichar_t *) _("_Base:");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 5; gcd[k].gd.pos.y = 14+17+5+3;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].creator = GLabelCreate;
harray1[0] = &gcd[k++];
gcd[k].gd.pos.width = 40;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.cid = CID_Base;
gcd[k].gd.handle_controlevent = RH_TextChanged;
gcd[k].creator = GTextFieldCreate;
harray1[1] = &gcd[k++];
label[k].text = (unichar_t *) _("_Size:");
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;
harray1[2] = &gcd[k++];
gcd[k].gd.pos.width = 40;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.cid = CID_Width;
gcd[k].gd.handle_controlevent = RH_TextChanged;
gcd[k].creator = GTextFieldCreate;
harray1[3] = &gcd[k++]; harray1[4] = GCD_Glue; harray1[5] = NULL;
gcd[k].gd.flags = gg_visible | gg_enabled;
label[k].text = (unichar_t *) "Overlaps another hint";
label[k].text_is_1byte = true;
label[k].fg = 0xff0000; label[k].bg = COLOR_DEFAULT; /* Doesn't work, needs to be in box */
gcd[k].gd.label = &label[k];
gcd[k].gd.cid = CID_Overlap;
gcd[k].creator = GLabelCreate;
harray4[0] = GCD_Glue; harray4[1] = &gcd[k++]; harray4[2] = GCD_Glue; harray4[3] = NULL;
gcd[k].gd.flags = gg_visible | gg_enabled;
label[k].text = (unichar_t *) _("Cr_eate");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.cid = CID_Add;
gcd[k].gd.handle_controlevent = RH_Add;
gcd[k].creator = GButtonCreate;
barray[0][0] = GCD_Glue; barray[0][1] = &gcd[k++]; barray[0][2] = GCD_Glue;
gcd[k].gd.flags = gg_visible | gg_enabled;
label[k].text = (unichar_t *) _("Re_move");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.cid = CID_Remove;
gcd[k].gd.handle_controlevent = RH_Remove;
gcd[k].creator = GButtonCreate;
barray[0][3] = &gcd[k++]; barray[0][4] = GCD_Glue; barray[0][5] = NULL;
gcd[k].gd.pos.width = 170-10;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].creator = GLineCreate;
barray[1][0] = GCD_Glue; barray[1][1] = &gcd[k++]; barray[1][2] = barray[1][3] = GCD_ColSpan; barray[1][4] = GCD_Glue; barray[1][5] = NULL;
gcd[k].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
label[k].text = (unichar_t *) _("< _Prev");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.cid = CID_Prev;
gcd[k].gd.popup_msg = (unichar_t *) _("Previous Hint.");
gcd[k].gd.handle_controlevent = RH_NextPrev;
gcd[k].creator = GButtonCreate;
barray[2][0] = GCD_Glue; barray[2][1] = &gcd[k++]; barray[2][2] = GCD_Glue;
gcd[k].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
label[k].text = (unichar_t *) _("_Next >");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.cid = CID_Next;
gcd[k].gd.popup_msg = (unichar_t *) _("Next Hint.");
gcd[k].gd.handle_controlevent = RH_NextPrev;
gcd[k].creator = GButtonCreate;
barray[2][3] = &gcd[k++]; barray[2][4] = GCD_Glue; barray[2][5] = NULL;
label[k].text = (unichar_t *) _("Regenerate Hint Substitution Points");
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|gg_cb_on|gg_utf8_popup;
gcd[k].gd.cid = CID_RegenHM;
gcd[k].gd.popup_msg = (unichar_t *) _("If you have made any changes to the hints,\nthen in addition to changing the glyph's hints\nrefigure it's hint masks and substitution points.");
gcd[k].creator = GCheckBoxCreate;
barray[3][0] = &gcd[k++]; barray[3][1] = barray[3][2] = barray[3][3] = barray[3][4] = GCD_ColSpan; barray[3][5] = NULL;
gcd[k].gd.flags = gg_visible | gg_enabled;
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 = RH_OK;
gcd[k].creator = GButtonCreate;
barray[4][0] = GCD_Glue; barray[4][1] = &gcd[k++]; barray[4][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 = RH_Cancel;
gcd[k].creator = GButtonCreate;
barray[4][3] = &gcd[k++]; barray[4][4] = GCD_Glue; barray[4][5] = NULL;
barray[5][0] = NULL;
boxes[2].gd.flags = gg_enabled|gg_visible;
boxes[2].gd.u.boxelements = harray2;
boxes[2].creator = GHBoxCreate;
boxes[3].gd.flags = gg_enabled|gg_visible;
boxes[3].gd.u.boxelements = harray3;
boxes[3].creator = GHBoxCreate;
boxes[4].gd.flags = gg_enabled|gg_visible;
boxes[4].gd.u.boxelements = harray1;
boxes[4].creator = GHBoxCreate;
boxes[5].gd.flags = gg_enabled|gg_visible;
boxes[5].gd.u.boxelements = harray4;
boxes[5].creator = GHBoxCreate;
boxes[6].gd.flags = gg_enabled|gg_visible;
boxes[6].gd.u.boxelements = barray[0];
boxes[6].creator = GHVBoxCreate;
varray[0][0] = &boxes[2]; varray[0][1] = NULL;
varray[1][0] = &boxes[3]; varray[1][1] = NULL;
varray[2][0] = &boxes[4]; varray[2][1] = NULL;
varray[3][0] = &boxes[5]; varray[3][1] = NULL;
varray[4][0] = &boxes[6]; varray[4][1] = NULL;
varray[5][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_TopBox;
boxes[0].creator = GHVGroupCreate;
GGadgetsCreate(gw,boxes);
GHVBoxSetExpandableRow(boxes[0].ret,3);
GHVBoxSetExpandableCol(boxes[2].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[3].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[4].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[5].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[6].ret,gb_expandglue);
GHVBoxFitWindow(boxes[0].ret);
} else {
gw = hd.gw;
GDrawSetTransientFor(gw,(GWindow) -1);
}
if ( cv->b.sc->hstem==NULL && cv->b.sc->vstem==NULL )
hd.active = NULL;
else if ( cv->b.sc->hstem!=NULL && cv->b.sc->vstem!=NULL ) {
if ( GGadgetIsChecked(GWidgetGetControl(gw,CID_HStem)))
hd.active = cv->b.sc->hstem;
else
hd.active = cv->b.sc->vstem;
} else if ( cv->b.sc->hstem!=NULL ) {
GGadgetSetChecked(GWidgetGetControl(gw,CID_HStem),true);
hd.active = cv->b.sc->hstem;
} else {
GGadgetSetChecked(GWidgetGetControl(gw,CID_VStem),true);
hd.active = cv->b.sc->vstem;
}
hd.ishstem = (hd.active==cv->b.sc->hstem);
hd.oldh = StemInfoCopy(cv->b.sc->hstem);
hd.oldv = StemInfoCopy(cv->b.sc->vstem);
hd.oldmanual = cv->b.sc->manualhints;
hd.changed = false;
RH_SetupHint(&hd);
if ( hd.active!=NULL ) {
GWidgetIndicateFocusGadget(GWidgetGetControl(gw,CID_Base));
GTextFieldSelect(GWidgetGetControl(gw,CID_Base),0,-1);
}
GWidgetHidePalettes();
GDrawSetVisible(gw,true);
while ( !hd.done )
GDrawProcessOneEvent(NULL);
GDrawSetVisible(gw,false);
}