static int OD_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
OutlineData *od = GDrawGetUserData(GGadgetGetWindow(g));
real width, gap;
int err = 0;
width = GetReal8(od->gw,CID_Width,_("Outline Width"),&err);
if ( od->isinline )
gap = GetReal8(od->gw,CID_Gap,_("_Gap:"),&err);
if ( err )
return(true);
def_outline_width = width;
if ( od->isinline ) {
def_gap_width = gap;
if ( od->fv!=NULL )
FVInline((FontViewBase *) od->fv,width,gap);
else if ( od->cv!=NULL )
CVInline(od->cv,width,gap);
else if ( od->mv!=NULL )
MVInline(od->mv,width,gap);
} else {
if ( od->fv!=NULL )
FVOutline((FontViewBase *) od->fv,width);
else if ( od->cv!=NULL )
CVOutline(od->cv,width);
else if ( od->mv!=NULL )
MVOutline(od->mv,width);
}
od->done = true;
}
return( true );
}
static int SD_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
OutlineData *od = GDrawGetUserData(GGadgetGetWindow(g));
real width, angle, len;
int err = 0;
width = GetReal8(od->gw,CID_Width,_("Outline Width"),&err);
len = GetReal8(od->gw,CID_ShadowLen,_("Shadow Length:"),&err);
angle = GetReal8(od->gw,CID_LightAngle,_("Light Angle:"),&err);
if ( err )
return(true);
def_outline_width = width;
def_shadow_len = len;
def_sun_angle = angle;
angle *= -3.1415926535897932/180;
angle -= 3.1415926535897932/2;
if ( od->fv!=NULL )
FVShadow((FontViewBase *) od->fv,angle,width,len,od->wireframe);
else if ( od->cv!=NULL )
CVShadow(od->cv,angle,width,len,od->wireframe);
else if ( od->mv!=NULL )
MVShadow(od->mv,angle,width,len,od->wireframe);
od->done = true;
}
return( true );
}
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 GCol_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
struct gcol_data *d = GDrawGetUserData(GGadgetGetWindow(g));
double *offs[7] = { &d->col.h, &d->col.s, &d->col.v, &d->col.r, &d->col.g, &d->col.b, &d->col.alpha };
int err = false, i;
double val;
for ( i=0; i<7; ++i ) {
val = GetReal8(d->gw,cids[i],_(labnames[i]),&err);
if ( err )
return( true );
if ( i==0 ) {
val = fmod(val,360);
if ( val<0 ) val += 360;
} else {
if ( val<0 || val>1 ) {
gwwv_post_error(_("Value out of bounds"), _("Saturation and Value, and the three colors must be between 0 and 1"));
return( true );
}
}
*offs[i] = val;
}
d->done = true;
}
return( true );
}
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 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 CH_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
CreateHintData *hd = GDrawGetUserData(GGadgetGetWindow(g));
real base, width;
int err = 0;
StemInfo *h;
int layer = CVLayer((CharViewBase *) hd->cv);
base = GetReal8(hd->gw,CID_Base,_("Base:"),&err);
width = GetReal8(hd->gw,CID_Width,_("Size:"),&err);
if ( err )
return(true);
if ( hd->preservehints ) {
SCPreserveHints(hd->cv->b.sc,layer);
SCHintsChanged(hd->cv->b.sc);
}
h = chunkalloc(sizeof(StemInfo));
if ( width==-21 || width==-20 ) {
base += width;
width = -width;
h->ghost = true;
}
h->start = base;
h->width = width;
if ( hd->ishstem ) {
SCGuessHHintInstancesAndAdd(hd->cv->b.sc,layer,h,0x80000000,0x80000000);
hd->cv->b.sc->hconflicts = StemListAnyConflicts(hd->cv->b.sc->hstem);
} else {
SCGuessVHintInstancesAndAdd(hd->cv->b.sc,layer,h,0x80000000,0x80000000);
hd->cv->b.sc->vconflicts = StemListAnyConflicts(hd->cv->b.sc->vstem);
}
hd->cv->b.sc->manualhints = true;
if ( h!=NULL && hd->cv->b.sc->parent->mm==NULL )
SCModifyHintMasksAdd(hd->cv->b.sc,layer,h);
else
SCClearHintMasks(hd->cv->b.sc,layer,true);
SCOutOfDateBackground(hd->cv->b.sc);
SCUpdateAll(hd->cv->b.sc);
hd->done = true;
}
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 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 );
}
int PointOfViewDlg(struct pov_data *pov, SplineFont *sf, int flags) {
static struct pov_data def = { or_center, or_value, 0, 0, .1,
0, 3.1415926535897932/16, .2, 0 };
double emsize = (sf->ascent + sf->descent);
struct nldlg d;
GRect pos;
GWindowAttrs wattrs;
GGadgetCreateData gcd[24], boxes[7], *varray[10][3], *harray1[3], *harray2[3],
*barray[9], *harray3[3], *harray4[3];
GTextInfo label[24];
int i,k,l;
char xval[40], yval[40], zval[40], dval[40], tval[40], dirval[40];
double x,y,z,dv,tilt,dir;
int err;
static int done = false;
if ( !done ) {
done = true;
for ( i=0; originx[i].text!=NULL; ++i )
originx[i].text = (unichar_t *) _((char *) originx[i].text);
for ( i=0; originy[i].text!=NULL; ++i )
originy[i].text = (unichar_t *) _((char *) originy[i].text);
}
*pov = def;
pov->x *= emsize; pov->y *= emsize; pov->z *= emsize; pov->d *= emsize;
if ( !(flags&1) ) {
if ( pov->xorigin == or_lastpress ) pov->xorigin = or_center;
if ( pov->yorigin == or_lastpress ) pov->yorigin = or_center;
}
memset(&d,'\0',sizeof(d));
memset(&wattrs,0,sizeof(wattrs));
wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_undercursor|wam_restrict|wam_isdlg;
wattrs.event_masks = ~(1<<et_charup);
wattrs.restrict_input_to_me = 1;
wattrs.is_dlg = 1;
wattrs.undercursor = 1;
wattrs.cursor = ct_pointer;
wattrs.utf8_window_title = _("Point of View Projection");
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,240));
pos.height = GDrawPointsToPixels(NULL,216);
d.gw = GDrawCreateTopWindow(NULL,&pos,nld_e_h,&d,&wattrs);
memset(gcd,0,sizeof(gcd));
memset(boxes,0,sizeof(boxes));
memset(label,0,sizeof(label));
k=l=0;
label[k].text = (unichar_t *) _("View Point");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 10; gcd[k].gd.pos.y = 8;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
varray[l][0] = &gcd[k-1]; varray[l][1] = GCD_ColSpan; varray[l++][2] = NULL;
label[k].text = (unichar_t *) _("_X");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 10; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y + 16;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
harray1[0] = &gcd[k-1];
for ( i=or_zero; i<or_undefined; ++i ) originx[i].selected = false;
originx[pov->xorigin].selected = true;
originx[or_lastpress].disabled = !(flags&1);
gcd[k].gd.pos.x = 23; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k].gd.label = &originx[pov->xorigin];
gcd[k].gd.u.list = originx;
gcd[k].gd.cid = CID_XType;
gcd[k++].creator = GListButtonCreate;
harray1[1] = &gcd[k-1]; harray1[2] = NULL;
boxes[2].gd.flags = gg_enabled|gg_visible;
boxes[2].gd.u.boxelements = harray1;
boxes[2].creator = GHBoxCreate;
varray[l][0] = &boxes[2];
sprintf( xval, "%g", rint(pov->x));
label[k].text = (unichar_t *) xval;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 160; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y; gcd[k].gd.pos.width = 60;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.handle_controlevent = PoV_Vanish;
gcd[k].gd.cid = CID_XValue;
gcd[k++].creator = GTextFieldCreate;
varray[l][1] = &gcd[k-1]; varray[l++][2] = NULL;
label[k].text = (unichar_t *) _("_Y");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = gcd[k-3].gd.pos.x; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y + 28;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
harray2[0] = &gcd[k-1];
for ( i=or_zero; i<or_undefined; ++i ) originy[i].selected = false;
originy[pov->yorigin].selected = true;
originy[or_lastpress].disabled = !(flags&1);
gcd[k].gd.pos.x = gcd[k-3].gd.pos.x; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k].gd.label = &originy[pov->yorigin];
gcd[k].gd.u.list = originy;
gcd[k].gd.cid = CID_YType;
gcd[k++].creator = GListButtonCreate;
harray2[1] = &gcd[k-1]; harray2[2] = NULL;
boxes[3].gd.flags = gg_enabled|gg_visible;
boxes[3].gd.u.boxelements = harray2;
boxes[3].creator = GHBoxCreate;
varray[l][0] = &boxes[3];
sprintf( yval, "%g", rint(pov->y));
label[k].text = (unichar_t *) yval;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = gcd[k-3].gd.pos.x; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y; gcd[k].gd.pos.width = gcd[k-3].gd.pos.width;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.cid = CID_YValue;
gcd[k].gd.handle_controlevent = PoV_Vanish;
gcd[k++].creator = GTextFieldCreate;
varray[l][1] = &gcd[k-1]; varray[l++][2] = NULL;
label[k].text = (unichar_t *) _("Distance to drawing plane:");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 10; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y + 28;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
varray[l][0] = &gcd[k-1];
sprintf( zval, "%g", rint(pov->z));
label[k].text = (unichar_t *) zval;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 160; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4; gcd[k].gd.pos.width = 60;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.handle_controlevent = PoV_Vanish;
gcd[k].gd.cid = CID_ZValue;
gcd[k++].creator = GTextFieldCreate;
varray[l][1] = &gcd[k-1]; varray[l++][2] = NULL;
label[k].text = (unichar_t *) _("Distance to projection plane:");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = gcd[k-2].gd.pos.x; gcd[k].gd.pos.y = gcd[k-2].gd.pos.y + 24;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
varray[l][0] = &gcd[k-1];
sprintf( dval, "%g", rint(pov->d));
label[k].text = (unichar_t *) dval;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 160; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4; gcd[k].gd.pos.width = 60;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.handle_controlevent = PoV_Vanish;
gcd[k].gd.cid = CID_DValue;
gcd[k++].creator = GTextFieldCreate;
varray[l][1] = &gcd[k-1]; varray[l++][2] = NULL;
label[k].text = (unichar_t *) _("Drawing plane tilt:");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = gcd[k-2].gd.pos.x; gcd[k].gd.pos.y = gcd[k-2].gd.pos.y + 24;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
varray[l][0] = &gcd[k-1];
sprintf( tval, "%g", rint(pov->tilt*180/3.1415926535897932));
label[k].text = (unichar_t *) tval;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 160; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4; gcd[k].gd.pos.width = 40;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.handle_controlevent = PoV_Vanish;
gcd[k].gd.cid = CID_Tilt;
gcd[k++].creator = GTextFieldCreate;
harray3[0] = &gcd[k-1];
label[k].text = (unichar_t *) U_("°");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = gcd[k-1].gd.pos.x+gcd[k-1].gd.pos.width+3; gcd[k].gd.pos.y = gcd[k-2].gd.pos.y;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
harray3[1] = &gcd[k-1]; harray3[2] = NULL;
boxes[4].gd.flags = gg_enabled|gg_visible;
boxes[4].gd.u.boxelements = harray3;
boxes[4].creator = GHBoxCreate;
varray[l][1] = &boxes[4]; varray[l++][2] = NULL;
label[k].text = (unichar_t *) _("Direction of gaze:");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = gcd[k-3].gd.pos.x; gcd[k].gd.pos.y = gcd[k-3].gd.pos.y + 24;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
varray[l][0] = &gcd[k-1];
sprintf( dirval, "%g", rint(pov->direction*180/3.1415926535897932));
label[k].text = (unichar_t *) dirval;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 160; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4; gcd[k].gd.pos.width = 40;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.handle_controlevent = PoV_Vanish;
gcd[k].gd.cid = CID_GazeDirection;
gcd[k++].creator = GTextFieldCreate;
harray4[0] = &gcd[k-1];
label[k].text = (unichar_t *) U_("°");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = gcd[k-1].gd.pos.x+gcd[k-1].gd.pos.width+3; gcd[k].gd.pos.y = gcd[k-2].gd.pos.y;
gcd[k].gd.flags = gg_visible | gg_enabled;
gcd[k++].creator = GLabelCreate;
harray4[1] = &gcd[k-1]; harray4[2] = NULL;
boxes[5].gd.flags = gg_enabled|gg_visible;
boxes[5].gd.u.boxelements = harray4;
boxes[5].creator = GHBoxCreate;
varray[l][1] = &boxes[5]; varray[l++][2] = NULL;
label[k].text = (unichar_t *) _("Vanishing Point:");
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 10; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y+18;
gcd[k].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[k].gd.popup_msg = (unichar_t *) _("This is the approximate location of the vanishing point.\nIt does not include the offset induced by \"Center of selection\"\nnor \"Last Press\".");
gcd[k++].creator = GLabelCreate;
varray[l][0] = &gcd[k-1];
label[k].text = (unichar_t *) "123456.,123456.";
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 160; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y;
gcd[k].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[k].gd.popup_msg = (unichar_t *) _("This is the approximate location of the vanishing point.\nIt does not include the offset induced by \"Center of selection\"\nnor \"Last Press\".");
gcd[k].gd.cid = CID_Vanish;
gcd[k++].creator = GLabelCreate;
varray[l][1] = &gcd[k-1]; varray[l++][2] = NULL;
gcd[k].gd.pos.x = 30-3; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y+18;
gcd[k].gd.pos.width = -1; gcd[k].gd.pos.height = 0;
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.cid = true;
gcd[k++].creator = GButtonCreate;
barray[0] = GCD_Glue; barray[1] = &gcd[k-1]; barray[2] = GCD_Glue;
gcd[k].gd.pos.x = -30; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y+3;
gcd[k].gd.pos.width = -1; gcd[k].gd.pos.height = 0;
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.cid = false;
gcd[k++].creator = GButtonCreate;
barray[3] = GCD_Glue; barray[4] = &gcd[k-1]; barray[5] = GCD_Glue; barray[6] = NULL;
boxes[6].gd.flags = gg_enabled|gg_visible;
boxes[6].gd.u.boxelements = barray;
boxes[6].creator = GHBoxCreate;
varray[l][0] = &boxes[6]; varray[l][1] = GCD_ColSpan; varray[l++][2] = NULL;
varray[l][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].creator = GHVGroupCreate;
GGadgetsCreate(d.gw,boxes);
GHVBoxFitWindow(boxes[0].ret);
PoV_DoVanish(&d);
GDrawSetVisible(d.gw,true);
while ( !d.done ) {
GDrawProcessOneEvent(NULL);
if ( d.done ) {
if ( !d.ok ) {
GDrawDestroyWindow(d.gw);
return( -1 );
}
err = false;
x = GetReal8(d.gw,CID_XValue,_("_X"),&err);
y = GetReal8(d.gw,CID_YValue,_("_Y"),&err);
z = GetReal8(d.gw,CID_ZValue,_("Distance to drawing plane:"),&err);
dv = GetReal8(d.gw,CID_DValue,_("Distance to projection plane:"),&err);
tilt = GetReal8(d.gw,CID_Tilt,_("Drawing plane tilt:"),&err);
dir = GetReal8(d.gw,CID_GazeDirection,_("Direction of gaze:"),&err);
if ( err ) {
d.done = d.ok = false;
continue;
}
pov->x = x; pov->y = y; pov->z = z; pov->d = dv;
pov->tilt = tilt*3.1415926535897932/180;
pov->direction = dir*3.1415926535897932/180;
pov->xorigin = GGadgetGetFirstListSelectedItem( GWidgetGetControl(d.gw,CID_XType));
pov->yorigin = GGadgetGetFirstListSelectedItem( GWidgetGetControl(d.gw,CID_YType));
}
}
GDrawDestroyWindow(d.gw);
def = *pov;
def.x /= emsize; def.y /= emsize; def.z /= emsize; def.d /= emsize;
return( 0 ); /* -1 => Canceled */
}
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 );
}
