static void GProgressDisplay(void) {
GDrawSetVisible(current->gw,true);
current->visible = true;
if ( current->prev!=NULL && current->prev->visible ) {
GDrawSetVisible(current->prev->gw,false);
current->prev->visible = false;
}
}
static void ManagePalettesVis(GTopLevelD *td, int is_visible ) {
GTopLevelD *palette;
if ( td->w!=last_paletted_focus_window )
return;
for ( palette=td->palettes; palette!=NULL; palette = palette->nextp ) {
if ( is_visible && palette->w->visible_request )
GDrawSetVisible(palette->w,true);
else if ( !is_visible && palette->w->visible_request ) {
GDrawSetVisible(palette->w,false);
palette->w->visible_request = true;
}
}
}
static int AW2_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
GWindow gw = GGadgetGetWindow(g);
struct widthinfo *wi = GDrawGetUserData(gw);
int err = false;
int separation, min_side, max_side, height, loop;
separation = GetInt8(gw,CID_Separation, _("Separation"),&err);
min_side = GetInt8(gw,CID_MinSep, _("Min Bearing"),&err);
max_side = GetInt8(gw,CID_MaxSep, _("Max Bearing"),&err);
height = GetInt8(gw,CID_Height, _("Height"),&err);
loop = GetInt8(gw,CID_Loop, _("Loop Count"),&err);
if ( err )
return( true );
GDrawSetVisible(gw,false);
GDrawSync(NULL);
GDrawProcessPendingEvents(NULL);
width_last_em_size = wi->sf->ascent + wi->sf->descent;
width_separation = separation;
wi->sf->width_separation=separation;
if ( wi->sf->italicangle==0 )
width_min_side_bearing = min_side;
width_max_side_bearing = max_side;
width_chunk_height = height;
width_loop_cnt = loop;
AutoWidth2((FontViewBase *) wi->fv,separation,min_side,max_side,
height, loop);
wi->done = true;
}
return( true );
}
static int progress_eh(GWindow gw, GEvent *event) {
GProgress *p = GDrawGetUserData(gw);
switch ( event->type ) {
case et_destroy:
free(p->line1);
free(p->line2);
free(p);
break;
case et_close:
p->aborted = true;
GDrawSetVisible(gw,false);
break;
case et_expose:
GProgressDraw(p,gw,&event->u.expose.rect);
break;
case et_controlevent:
if ( event->u.control.subtype == et_buttonactivate )
p->aborted = true;
break;
case et_char:
if ( (event->u.chr.state&ksm_control) && event->u.chr.chars[0]=='.' )
p->aborted = true;
break;
case et_map:
p->sawmap = true;
break;
}
return( true );
}
static void GTabSetChangeSel(GTabSet *gts, int sel,int sendevent) {
int i, width;
int oldsel = gts->sel;
if ( sel==-2 ) /* left arrow */
--gts->toff;
else if ( sel==-3 )
++gts->toff;
else if ( sel<0 || sel>=gts->tabcnt || gts->tabs[sel].disabled )
return;
else {
if ( gts->vertical )
gts->sel = sel;
else {
for ( i=0; i<gts->rcnt && sel>=gts->rowstarts[i+1]; ++i );
if ( gts->active_row != i ) {
gts->active_row = i;
if ( gts->rcnt>1 && (!gts->filllines || gts->offset_per_row!=0))
GTabSetFigureWidths(gts);
}
gts->sel = sel;
if ( sel<gts->toff )
gts->toff = sel;
else if ( gts->scrolled ) {
for ( i=gts->toff; i<sel && gts->tabs[i].x!=0x7fff; ++i );
if ( gts->tabs[i].x==0x7fff ) {
width = gts->g.r.width-2*gts->arrow_width; /* it will have a left arrow */
if ( sel!=gts->tabcnt )
width -= gts->arrow_width; /* it might have a right arrow */
for ( i=sel; i>=0 && width-gts->tabs[i].width>=0; --i )
width -= gts->tabs[i].width;
if ( ++i>sel ) i = sel;
gts->toff = i;
}
}
}
if ( oldsel!=sel ) {
if ( sendevent )
GTabSetChanged(gts,oldsel);
if ( gts->tabs[oldsel].w!=NULL )
GDrawSetVisible(gts->tabs[oldsel].w,false);
if ( gts->tabs[gts->sel].w!=NULL )
GDrawSetVisible(gts->tabs[gts->sel].w,true);
}
}
_ggadget_redraw(>s->g);
}
void CVMouseDownRuler(CharView *cv, GEvent *event) {
cv->autonomous_ruler_w = false;
RulerPlace(cv,event);
cv->p.rubberlining = true;
GDrawSetVisible(cv->ruler_w,true);
}
void GWidgetRequestVisiblePalette(GWindow palette,int visible) {
GTopLevelD *td = (GTopLevelD *) (palette->widget_data);
if ( td->owner!=NULL ) {
palette->visible_request = visible;
if ( td->owner->w == last_paletted_focus_window )
GDrawSetVisible(palette,visible);
}
}
static void start_splash_screen(void){
GDrawSetVisible(splashw,true);
GDrawSync(NULL);
GDrawProcessPendingEvents(NULL);
GDrawProcessPendingEvents(NULL);
splasht = GDrawRequestTimer(splashw,1000,1000,NULL);
localsplash = false;
}
static int DoFindOne(SearchView *sv,int startafter) {
int i, gid;
SplineChar *startcur = sv->sd.curchar;
/* It is possible that some idiot deleted the current character since */
/* the last search... do some mild checks */
if ( sv->sd.curchar!=NULL &&
sv->sd.curchar->parent == sv->sd.fv->sf &&
sv->sd.curchar->orig_pos>=0 && sv->sd.curchar->orig_pos<sv->sd.fv->sf->glyphcnt &&
sv->sd.curchar==sv->sd.fv->sf->glyphs[sv->sd.curchar->orig_pos] )
/* Looks ok */;
else
sv->sd.curchar=startcur=NULL;
if ( !sv->sd.subpatternsearch ) startafter = false;
if ( sv->showsfindnext && sv->sd.curchar!=NULL )
i = sv->sd.fv->map->backmap[sv->sd.curchar->orig_pos]+1-startafter;
else {
startafter = false;
if ( !sv->sd.onlyselected )
i = 0;
else {
for ( i=0; i<sv->sd.fv->map->enccount; ++i )
if ( sv->sd.fv->selected[i] && (gid=sv->sd.fv->map->map[i])!=-1 &&
sv->sd.fv->sf->glyphs[gid]!=NULL )
break;
}
}
for ( ; i<sv->sd.fv->map->enccount; ++i ) {
if (( !sv->sd.onlyselected || sv->sd.fv->selected[i]) && (gid=sv->sd.fv->map->map[i])!=-1 &&
sv->sd.fv->sf->glyphs[gid]!=NULL ) {
SCSplinePointsUntick(sv->sd.fv->sf->glyphs[gid],sv->sd.fv->active_layer);
if ( SearchChar(&sv->sd,gid,startafter) )
break;
}
startafter = false;
}
if ( i>=sv->sd.fv->map->enccount ) {
ff_post_notice(_("Not Found"),sv->showsfindnext?_("The search pattern was not found again in the font %.100s"):_("The search pattern was not found in the font %.100s"),sv->sd.fv->sf->fontname);
sv->sd.curchar = startcur;
GGadgetSetTitle8(GWidgetGetControl(sv->gw,CID_Find),_("Find"));
sv->showsfindnext = false;
return( false );
}
SVSelectSC(sv);
if ( sv->lastcv!=NULL && sv->lastcv->b.sc==startcur && sv->lastcv->b.fv== sv->sd.fv ) {
CVChangeSC(sv->lastcv,sv->sd.curchar);
GDrawSetVisible(sv->lastcv->gw,true);
GDrawRaise(sv->lastcv->gw);
} else
sv->lastcv = CharViewCreate(sv->sd.curchar,(FontView *) sv->sd.fv,-1);
GGadgetSetTitle8(GWidgetGetControl(sv->gw,CID_Find),_("Find Next"));
sv->showsfindnext = true;
return( true );
}
void CPStartInfo(CharView *cv, GEvent *event) {
if ( !cv->showcpinfo )
return;
cv->autonomous_ruler_w = false;
CpInfoPlace(cv,event);
GDrawSetVisible(cv->ruler_w,true);
}
static int GFD_New(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
struct gfc_data *d = GDrawGetUserData(GGadgetGetWindow(g));
d->done = true;
GDrawSetVisible(GGadgetGetWindow(g),false);
FontNew();
}
return( true );
}
void ShowErrorWindow(void) {
if ( errdata.gw==NULL )
return;
GDrawSetVisible(errdata.gw,true);
GDrawRaise(errdata.gw);
if ( errdata.showing )
GDrawRequestExpose(errdata.v,NULL,false);
errdata.showing = true;
}
void ShowAboutScreen(void) {
static int first=1;
if ( first ) {
GDrawResize(splashw,splashimage.u.image->width,splashimage.u.image->height+linecnt*fh);
first = false;
}
if ( splasht!=NULL )
GDrawCancelTimer(splasht);
splasht=NULL;
GDrawSetVisible(splashw,true);
}
void GWidgetHidePalettes(void) {
GTopLevelD *td, *palette;
if ( last_paletted_focus_window==NULL )
return;
td = (GTopLevelD *) (last_paletted_focus_window->widget_data);
for ( palette=td->palettes; palette!=NULL; palette = palette->nextp ) {
if ( palette->w->visible_request ) {
GDrawSetVisible(palette->w,false);
palette->w->visible_request = true;
}
}
}
static void CreateErrorWindow(void) {
GWindowAttrs wattrs;
FontRequest rq;
GRect pos,size;
int as, ds, ld;
GWindow gw;
GGadgetData gd;
extern int _GScrollBar_Width;
GDrawGetSize(GDrawGetRoot(NULL),&size);
memset(&wattrs,0,sizeof(wattrs));
wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_isdlg|wam_positioned;
wattrs.event_masks = ~(1<<et_charup);
wattrs.is_dlg = true;
wattrs.cursor = ct_pointer;
wattrs.positioned = true;
wattrs.utf8_window_title = _("Warnings");
pos.width = GDrawPointsToPixels(NULL,GGadgetScale(400));
pos.height = GDrawPointsToPixels(NULL,GGadgetScale(100));
pos.x = size.width - pos.width - 10;
pos.y = size.height - pos.height - 30;
errdata.gw = gw = GDrawCreateTopWindow(NULL,&pos,warnings_e_h,&errdata,&wattrs);
memset(&rq,0,sizeof(rq));
rq.utf8_family_name = SANS_UI_FAMILIES;
rq.point_size = 10;
rq.weight = 400;
errdata.font = GDrawInstanciateFont(NULL,&rq);
errdata.font = GResourceFindFont("Warnings.Font",errdata.font);
GDrawWindowFontMetrics(errdata.gw,errdata.font,&as,&ds,&ld);
errdata.as = as;
errdata.fh = as+ds;
memset(&gd,0,sizeof(gd));
gd.pos.y = 0;
gd.pos.height = pos.height;
gd.pos.width = GDrawPointsToPixels(gw,_GScrollBar_Width);
gd.pos.x = pos.width-gd.pos.width;
gd.flags = gg_visible|gg_enabled|gg_pos_in_pixels|gg_sb_vert;
errdata.vsb = GScrollBarCreate(gw,&gd,&errdata);
pos.width -= gd.pos.width;
pos.x = pos.y = 0;
wattrs.mask = wam_events|wam_cursor;
errdata.v = GWidgetCreateSubWindow(gw,&pos,warningsv_e_h,&errdata,&wattrs);
GDrawSetVisible(errdata.v,true);
errdata.linecnt = pos.height/errdata.fh;
errdata.start_l = errdata.end_l = -1;
}
void CVMouseMoveRuler(CharView *cv, GEvent *event) {
if ( cv->autonomous_ruler_w )
return;
if ( !cv->p.pressed && (event->u.mouse.state&ksm_alt) ) {
if ( cv->ruler_w!=NULL && GDrawIsVisible(cv->ruler_w)) {
GDrawDestroyWindow(cv->ruler_w);
cv->ruler_w = NULL;
}
return;
}
if ( !cv->p.pressed )
CVMouseAtSpline(cv,event);
RulerPlace(cv,event);
if ( !cv->p.pressed )
GDrawSetVisible(cv->ruler_w,true);
GDrawSync(NULL);
GDrawProcessPendingEvents(NULL); /* The resize needs to happen before the expose */
if ( !cv->p.pressed && (event->u.mouse.state&ksm_alt) ) /* but a mouse up might sneak in... */
return;
GDrawRequestExpose(cv->ruler_w,NULL,false);
GDrawRequestExpose(cv->v,NULL,false);
}
unichar_t *FVOpenFont(char *title, const char *defaultfile, int mult) {
GRect pos;
int i, filter, renamei;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[11], boxes[5], *varray[9], *harray1[7], *harray2[4], *harray3[9];
GTextInfo label[10];
struct gfc_data d;
int bs = GIntGetResource(_NUM_Buttonsize), bsbigger, totwid, spacing;
GGadget *tf;
unichar_t *temp;
char **nlnames;
GTextInfo *namelistnames, **filts;
int cnt;
memset(&d,'\0',sizeof(d));
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.is_dlg = true;
wattrs.undercursor = 1;
wattrs.cursor = ct_pointer;
wattrs.utf8_window_title = title;
pos.x = pos.y = 0;
totwid = GGadgetScale(295);
bsbigger = 4*bs+4*14>totwid; totwid = bsbigger?4*bs+4*12:totwid;
spacing = (totwid-4*bs-2*12)/3;
pos.width = GDrawPointsToPixels(NULL,totwid);
pos.height = GDrawPointsToPixels(NULL,247);
gw = GDrawCreateTopWindow(NULL,&pos,e_h,&d,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
i=0;
gcd[i].gd.pos.x = 12; gcd[i].gd.pos.y = 6; gcd[i].gd.pos.width = totwid*100/GIntGetResource(_NUM_ScaleFactor)-24; gcd[i].gd.pos.height = 180;
gcd[i].gd.flags = gg_visible | gg_enabled;
if ( RecentFiles[0]!=NULL )
gcd[i].gd.flags = gg_visible | gg_enabled | gg_file_pulldown;
if ( mult )
gcd[i].gd.flags |= gg_file_multiple;
varray[0] = &gcd[i]; varray[1] = NULL;
gcd[i++].creator = GFileChooserCreate;
label[i].text = (unichar_t *) _("Filter:");
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = 8; gcd[i].gd.pos.y = 188+6;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[i].gd.popup_msg = (unichar_t *) _("Display files of this type" );
harray1[0] = GCD_Glue; harray1[1] = &gcd[i];
gcd[i++].creator = GLabelCreate;
gcd[i].gd.pos.x = 0; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y-6;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[i].gd.popup_msg = (unichar_t *) _("Display files of this type");
gcd[i].gd.handle_controlevent = GFD_FilterSelected;
harray1[2] = &gcd[i]; harray1[3] = GCD_Glue; harray1[4] = GCD_Glue; harray1[5] = GCD_Glue; harray1[6] = NULL;
gcd[i++].creator = GListButtonCreate;
boxes[2].gd.flags = gg_visible | gg_enabled;
boxes[2].gd.u.boxelements = harray1;
boxes[2].creator = GHBoxCreate;
varray[2] = &boxes[2]; varray[3] = NULL;
label[i].text = (unichar_t *) _("Force glyph names to:");
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = 8; gcd[i].gd.pos.y = 188+6;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[i].gd.popup_msg = (unichar_t *) _("In the saved font, force all glyph names to match those in the specified namelist");
harray2[0] = &gcd[i];
gcd[i++].creator = GLabelCreate;
renamei = i;
gcd[i].gd.pos.x = 0; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y-6;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[i].gd.popup_msg = (unichar_t *) _("In the saved font, force all glyph names to match those in the specified namelist");
gcd[i].creator = GListButtonCreate;
nlnames = AllNamelistNames();
for ( cnt=0; nlnames[cnt]!=NULL; ++cnt);
namelistnames = calloc(cnt+3,sizeof(GTextInfo));
namelistnames[0].text = (unichar_t *) _("No Rename");
namelistnames[0].text_is_1byte = true;
if ( force_names_when_opening==NULL ) {
namelistnames[0].selected = true;
gcd[i].gd.label = &namelistnames[0];
}
namelistnames[1].line = true;
for ( cnt=0; nlnames[cnt]!=NULL; ++cnt) {
namelistnames[cnt+2].text = (unichar_t *) nlnames[cnt];
namelistnames[cnt+2].text_is_1byte = true;
if ( force_names_when_opening!=NULL &&
strcmp(_(force_names_when_opening->title),nlnames[cnt])==0 ) {
namelistnames[cnt+2].selected = true;
gcd[i].gd.label = &namelistnames[cnt+2];
}
}
harray2[1] = &gcd[i]; harray2[2] = GCD_Glue; harray2[3] = NULL;
gcd[i++].gd.u.list = namelistnames;
boxes[3].gd.flags = gg_visible | gg_enabled;
boxes[3].gd.u.boxelements = harray2;
boxes[3].creator = GHBoxCreate;
varray[4] = &boxes[3]; varray[5] = NULL;
gcd[i].gd.pos.x = 12; gcd[i].gd.pos.y = 216-3;
gcd[i].gd.pos.width = -1;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[i].text = (unichar_t *) _("_OK");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.mnemonic = 'O';
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = GFD_Ok;
harray3[0] = GCD_Glue; harray3[1] = &gcd[i];
gcd[i++].creator = GButtonCreate;
gcd[i].gd.pos.x = -(spacing+bs)*100/GIntGetResource(_NUM_ScaleFactor)-12; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y+3;
gcd[i].gd.pos.width = -1;
gcd[i].gd.flags = gg_visible | gg_enabled;
label[i].text = (unichar_t *) S_("Font|_New");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.mnemonic = 'N';
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = GFD_New;
harray3[2] = GCD_Glue; harray3[3] = &gcd[i];
gcd[i++].creator = GButtonCreate;
filter = i;
gcd[i].gd.pos.x = (spacing+bs)*100/GIntGetResource(_NUM_ScaleFactor)+12; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y;
gcd[i].gd.pos.width = -1;
gcd[i].gd.flags = /* gg_visible |*/ gg_enabled;
label[i].text = (unichar_t *) _("_Filter");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.mnemonic = 'F';
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = GFileChooserFilterEh;
harray3[4] = &gcd[i];
gcd[i++].creator = GButtonCreate;
gcd[i].gd.pos.x = -12; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y;
gcd[i].gd.pos.width = -1;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[i].text = (unichar_t *) _("_Cancel");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.mnemonic = 'C';
gcd[i].gd.handle_controlevent = GFD_Cancel;
harray3[5] = GCD_Glue; harray3[6] = &gcd[i]; harray3[7] = GCD_Glue; harray3[8] = NULL;
gcd[i++].creator = GButtonCreate;
boxes[4].gd.flags = gg_visible | gg_enabled;
boxes[4].gd.u.boxelements = harray3;
boxes[4].creator = GHBoxCreate;
varray[6] = &boxes[4]; varray[7] = NULL;
varray[8] = 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 = varray;
boxes[0].creator = GHVGroupCreate;
gcd[i].gd.pos.x = 2; gcd[i].gd.pos.y = 2;
gcd[i].gd.pos.width = pos.width-4; gcd[i].gd.pos.height = pos.height-4;
gcd[i].gd.flags = gg_enabled | gg_visible | gg_pos_in_pixels;
gcd[i++].creator = GGroupCreate;
GGadgetsCreate(gw,boxes);
d.gfc = gcd[0].ret;
d.rename = gcd[renamei].ret;
filts = StandardFilters();
GGadgetSetList(harray1[2]->ret,filts,true);
GHVBoxSetExpandableRow(boxes[0].ret,0);
GHVBoxSetExpandableCol(boxes[2].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[3].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[4].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[0].ret);
free(namelistnames);
GGadgetSetUserData(gcd[filter].ret,gcd[0].ret);
GFileChooserConnectButtons(gcd[0].ret,harray3[1]->ret,gcd[filter].ret);
temp = utf82u_copy(filts[default_font_filter_index]->userdata);
GFileChooserSetFilterText(gcd[0].ret,temp);
free(temp);
GFileChooserGetChildren(gcd[0].ret,NULL, NULL, &tf);
if ( RecentFiles[0]!=NULL ) {
GGadgetSetList(tf,GTextInfoFromChars(RecentFiles,RECENT_MAX),false);
}
GGadgetSetTitle8(gcd[0].ret,defaultfile);
GWidgetHidePalettes();
GDrawSetVisible(gw,true);
while ( !d.done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
GDrawProcessPendingEvents(NULL); /* Give the window a chance to vanish... */
GDrawSync(NULL);
GDrawProcessPendingEvents(NULL); /* Give the window a chance to vanish... */
free( d.lastpopupfontname );
GTextInfoArrayFree(filts);
for ( cnt=0; nlnames[cnt]!=NULL; ++cnt) {
free(nlnames[cnt]);
}
free(nlnames);
return(d.ret);
}
void ShadowDlg(FontView *fv, CharView *cv,MetricsView *mv,int wireframe) {
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[10], *butarray[7], *hvarray[16], boxes[3];
GTextInfo label[10];
OutlineData od;
char buffer[20], buffer2[20], buffer3[20];
int i, k;
od.done = false;
od.fv = fv;
od.cv = cv;
od.mv = mv;
od.wireframe = wireframe;
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 = _("Shadow");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,160));
pos.height = GDrawPointsToPixels(NULL,125);
od.gw = gw = GDrawCreateTopWindow(NULL,&pos,od_e_h,&od,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
i = k = 0;
label[i].text = (unichar_t *) _("Outline Width:");
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = 7; gcd[i].gd.pos.y = 7+3;
gcd[i].gd.flags = gg_enabled|gg_visible;
gcd[i++].creator = GLabelCreate;
hvarray[k++] = &gcd[i-1];
sprintf( buffer, "%g", def_outline_width );
label[i].text = (unichar_t *) buffer;
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = 90; gcd[i].gd.pos.y = 7; gcd[i].gd.pos.width = 50;
gcd[i].gd.flags = gg_enabled|gg_visible;
gcd[i].gd.cid = CID_Width;
gcd[i++].creator = GTextFieldCreate;
hvarray[k++] = &gcd[i-1]; hvarray[k++] = NULL;
label[i].text = (unichar_t *) _("Shadow Length:");
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = gcd[i-2].gd.pos.x; gcd[i].gd.pos.y = gcd[i-2].gd.pos.y+26;
gcd[i].gd.flags = gg_enabled|gg_visible;
gcd[i++].creator = GLabelCreate;
hvarray[k++] = &gcd[i-1];
sprintf( buffer2, "%g", def_shadow_len );
label[i].text = (unichar_t *) buffer2;
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = gcd[i-2].gd.pos.x; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y-3; gcd[i].gd.pos.width = gcd[i-2].gd.pos.width;
gcd[i].gd.flags = gg_enabled|gg_visible;
gcd[i].gd.cid = CID_ShadowLen;
gcd[i++].creator = GTextFieldCreate;
hvarray[k++] = &gcd[i-1]; hvarray[k++] = NULL;
label[i].text = (unichar_t *) _("Light Angle:");
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = gcd[i-2].gd.pos.x; gcd[i].gd.pos.y = gcd[i-2].gd.pos.y+26;
gcd[i].gd.flags = gg_enabled|gg_visible;
gcd[i++].creator = GLabelCreate;
hvarray[k++] = &gcd[i-1];
sprintf( buffer3, "%g", def_sun_angle );
label[i].text = (unichar_t *) buffer3;
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = gcd[i-2].gd.pos.x; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y-3; gcd[i].gd.pos.width = gcd[i-2].gd.pos.width;
gcd[i].gd.flags = gg_enabled|gg_visible;
gcd[i].gd.cid = CID_LightAngle;
gcd[i++].creator = GTextFieldCreate;
hvarray[k++] = &gcd[i-1]; hvarray[k++] = NULL;
hvarray[k++] = &boxes[2]; hvarray[k++] = GCD_ColSpan; hvarray[k++] = NULL;
hvarray[k++] = GCD_Glue; hvarray[k++] = GCD_Glue; hvarray[k++] = NULL;
hvarray[k] = NULL;
k = 0;
gcd[i].gd.pos.x = 20-3; gcd[i].gd.pos.y = gcd[i-2].gd.pos.y+30;
gcd[i].gd.pos.width = -1; gcd[i].gd.pos.height = 0;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[i].text = (unichar_t *) _("_OK");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = SD_OK;
gcd[i++].creator = GButtonCreate;
butarray[k++] = GCD_Glue; butarray[k++] = &gcd[i-1]; butarray[k++] = GCD_Glue;
gcd[i].gd.pos.x = -20; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y+3;
gcd[i].gd.pos.width = -1; gcd[i].gd.pos.height = 0;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[i].text = (unichar_t *) _("_Cancel");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = OD_Cancel;
gcd[i++].creator = GButtonCreate;
butarray[k++] = GCD_Glue; butarray[k++] = &gcd[i-1]; butarray[k++] = GCD_Glue;
butarray[k] = NULL;
boxes[2].gd.flags = gg_enabled|gg_visible;
boxes[2].gd.u.boxelements = butarray;
boxes[2].creator = GHBoxCreate;
boxes[0].gd.pos.x = boxes[0].gd.pos.y = 2;
boxes[0].gd.flags = gg_enabled|gg_visible;
boxes[0].gd.u.boxelements = hvarray;
boxes[0].creator = GHVGroupCreate;
gcd[i].gd.pos.x = 2; gcd[i].gd.pos.y = 2;
gcd[i].gd.pos.width = pos.width-4; gcd[i].gd.pos.height = pos.height-4;
gcd[i].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels;
gcd[i].creator = GGroupCreate;
GGadgetsCreate(gw,boxes);
GHVBoxSetExpandableRow(boxes[0].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[2].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[0].ret);
GWidgetIndicateFocusGadget(GWidgetGetControl(gw,CID_ShadowLen));
GTextFieldSelect(GWidgetGetControl(gw,CID_ShadowLen),0,-1);
GWidgetHidePalettes();
GDrawSetVisible(gw,true);
while ( !od.done )
GDrawProcessOneEvent(NULL);
GDrawSetVisible(gw,false);
}
static void FilterDlg(void) {
static struct col_init cols[] = {
{ me_string, NULL, NULL, NULL, N_("Name") },
{ me_string, NULL, NULL, NULL, N_("Filter") }
};
static int inited = false;
static struct matrixinit mi = {
2, cols,
0, NULL,
NULL,
filter_candelete,
NULL,
NULL,
NULL,
NULL
};
struct matrix_data *md;
int k, cnt, i, ptwidth;
GGadgetCreateData gcd[3], boxes[3], *varray[7], *harray[7];
GTextInfo label[3];
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
struct filter_d d;
if ( !inited ) {
inited = true;
cols[0].title = _(cols[0].title);
cols[1].title = _(cols[1].title);
}
for ( k=0; k<2; ++k ) {
cnt = 0;
for ( i=0; def_font_filters[i].name!=NULL; ++i ) {
if ( *(char *) def_font_filters[i].name != '-' ) {
if ( k ) {
md[2*cnt].u.md_str = copy(_(def_font_filters[i].name));
md[2*cnt].frozen = true;
md[2*cnt+1].u.md_str = copy(def_font_filters[i].filter);
md[2*cnt+1].frozen = true;
}
++cnt;
}
}
if ( user_font_filters!=NULL ) {
for ( i=0; user_font_filters[i].name!=NULL; ++i ) {
if ( *(char *) user_font_filters[i].name != '-' ) {
if ( k ) {
md[2*cnt].u.md_str = copy(user_font_filters[i].name);
md[2*cnt].frozen = false;
md[2*cnt+1].u.md_str = copy(user_font_filters[i].filter);
md[2*cnt+1].frozen = false;
}
++cnt;
}
}
}
if ( !k )
md = calloc(2*cnt,sizeof(struct matrix_data));
}
mi.initial_row_cnt = cnt;
mi.matrix_data = md;
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 = true;
wattrs.undercursor = 1;
wattrs.cursor = ct_pointer;
wattrs.utf8_window_title = _("Edit Font Filters");
pos.x = pos.y = 0;
ptwidth = 2*GIntGetResource(_NUM_Buttonsize)+GGadgetScale(60);
pos.width =GDrawPointsToPixels(NULL,ptwidth);
pos.height = GDrawPointsToPixels(NULL,90);
gw = GDrawCreateTopWindow(NULL,&pos,filter_e_h,&d,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
gcd[0].gd.pos.x = 10; gcd[0].gd.pos.y = 6;
gcd[0].gd.pos.width = 300; gcd[0].gd.pos.height = 200;
gcd[0].gd.flags = gg_visible | gg_enabled;
gcd[0].creator = GMatrixEditCreate;
gcd[0].gd.u.matrix = &mi;
varray[0] = &gcd[0]; varray[1] = NULL;
gcd[1].gd.pos.x = 20-3; gcd[1].gd.pos.y = 90-35-3;
gcd[1].gd.pos.width = -1; gcd[1].gd.pos.height = 0;
gcd[1].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[1].text = (unichar_t *) _("_OK");
label[1].text_is_1byte = true;
label[1].text_in_resource = true;
gcd[1].gd.label = &label[1];
gcd[1].gd.handle_controlevent = Filter_OK;
gcd[1].creator = GButtonCreate;
harray[0] = GCD_Glue; harray[1] = &gcd[1]; harray[2] = GCD_Glue;
gcd[2].gd.pos.x = -20; gcd[2].gd.pos.y = 90-35;
gcd[2].gd.pos.width = -1; gcd[2].gd.pos.height = 0;
gcd[2].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[2].text = (unichar_t *) _("_Cancel");
label[2].text_is_1byte = true;
label[2].text_in_resource = true;
gcd[2].gd.label = &label[2];
gcd[2].gd.handle_controlevent = Filter_Cancel;
gcd[2].creator = GButtonCreate;
harray[3] = GCD_Glue; harray[4] = &gcd[2]; harray[5] = GCD_Glue;
harray[6] = NULL;
varray[2] = &boxes[2]; varray[3] = NULL;
varray[4] = 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;
boxes[0].creator = GHVGroupCreate;
boxes[2].gd.flags = gg_enabled|gg_visible;
boxes[2].gd.u.boxelements = harray;
boxes[2].creator = GHBoxCreate;
GGadgetsCreate(gw,boxes);
GHVBoxSetExpandableRow(boxes[0].ret,0);
GHVBoxSetExpandableCol(boxes[2].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[0].ret);
GMatrixEditSetNewText(gcd[0].ret,S_("Filter|New"));
d.gme = gcd[0].ret;
GDrawSetVisible(gw,true);
while ( !d.done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
for ( i=0; i<cnt; ++i ) {
free(md[2*i].u.md_str);
free(md[2*i+1].u.md_str);
}
free(md);
}
void TransformDlgCreate(void *data,void (*transfunc)(void *,real *,int,BVTFunc *,enum fvtrans_flags),
int (*getorigin)(void *,BasePoint *,int), enum transdlg_flags flags,
enum cvtools cvt) {
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[12+TCnt*25], boxes[4], *subarray[TCnt*27], *array[2*(TCnt+8)+4], *buttons[13], *origarray[4];
GTextInfo label[9+TCnt*24];
static TransData td;
int i, y, gci, subai, ai;
int32 len;
GGadget *orig;
BasePoint junk;
GTextInfo **ti;
static int done = false;
if ( !done ) {
int i;
for ( i=0; transformtypes[i].text!=NULL; ++i )
transformtypes[i].text = (unichar_t *) _((char *) transformtypes[i].text);
for ( i=0; origin[i].text!=NULL; ++i )
origin[i].text = (unichar_t *) _((char *) origin[i].text);
done = true;
}
td.userdata = data;
td.transfunc = transfunc;
td.getorigin = getorigin;
td.done = false;
if ( td.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 = _("Transform");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,TBlock_Width));
pos.height = GDrawPointsToPixels(NULL,TBlock_Top+TCnt*TBlock_Height+110);
td.gw = gw = GDrawCreateTopWindow(NULL,&pos,trans_e_h,&td,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
label[0].text = (unichar_t *) _("Origin:");
label[0].text_is_1byte = true;
label[0].text_in_resource = true;
gcd[0].gd.label = &label[0];
gcd[0].gd.pos.x = 5; gcd[0].gd.pos.y = 4;
gcd[0].gd.flags = (getorigin==NULL) ? gg_visible : (gg_visible | gg_enabled);
gcd[0].creator = GLabelCreate;
gcd[1].gd.pos.x = 5; gcd[1].gd.pos.y = 4;
gcd[1].gd.flags = (getorigin==NULL) ? gg_visible : (gg_visible | gg_enabled);
gcd[1].gd.label = &origin[1];
gcd[1].gd.u.list = origin;
gcd[1].gd.cid = CID_Origin;
gcd[1].creator = GListButtonCreate;
origin[1].selected = true;
origarray[0] = &gcd[0]; origarray[1] = &gcd[1]; origarray[2] = GCD_Glue; origarray[3] = NULL;
boxes[3].gd.flags = gg_enabled|gg_visible;
boxes[3].gd.u.boxelements = origarray;
boxes[3].creator = GHBoxCreate;
array[0] = &boxes[3]; array[1] = NULL;
gci = 2; subai = 0; ai = 2;
for ( i=0; i<TCnt; ++i ) {
array[ai++] = MakeTransBlock(&td,i,gcd+gci,label+gci,subarray+subai);
array[ai++] = NULL;
gci += 23; subai += 27;
}
y = TBlock_Top+TCnt*TBlock_Height+4;
gcd[gci].gd.pos.x = 10; gcd[gci].gd.pos.y = y;
gcd[gci].gd.flags = (flags&tdf_enableback) ? (gg_visible | gg_enabled) : gg_visible;
label[gci].text = (unichar_t *) _("Transform _All Layers");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.cid = CID_AllLayers;
gcd[gci++].creator = GCheckBoxCreate;
array[ai++] = &gcd[gci-1]; array[ai++] = NULL;
y += 16;
gcd[gci].gd.pos.x = 10; gcd[gci].gd.pos.y = y;
gcd[gci].gd.flags = (flags&tdf_enableback) ? (gg_visible | gg_enabled) : gg_visible;
label[gci].text = (unichar_t *) _("Transform _Guide Layer Too");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.cid = CID_DoGrid;
gcd[gci++].creator = GCheckBoxCreate;
array[ai++] = &gcd[gci-1]; array[ai++] = NULL;
y += 16;
gcd[gci].gd.pos.x = 10; gcd[gci].gd.pos.y = y;
gcd[gci].gd.flags = (flags&tdf_enableback) ? (gg_visible | gg_enabled | gg_cb_on) : gg_visible;
label[gci].text = (unichar_t *) _("Transform _Width Too");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.cid = CID_DoWidth;
gcd[gci++].creator = GCheckBoxCreate;
array[ai++] = &gcd[gci-1]; array[ai++] = NULL;
y += 16;
gcd[gci].gd.pos.x = 10; gcd[gci].gd.pos.y = y;
gcd[gci].gd.flags = gg_visible | (flags&tdf_enablekerns ? gg_enabled : 0) |
(flags&tdf_defaultkerns ? gg_cb_on : 0);
label[gci].text = (unichar_t *) _("Transform kerning _classes too");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.cid = CID_DoKerns;
gcd[gci++].creator = GCheckBoxCreate;
array[ai++] = &gcd[gci-1]; array[ai++] = NULL;
y += 16;
gcd[gci].gd.pos.x = 10; gcd[gci].gd.pos.y = y;
gcd[gci].gd.flags = gg_visible |
(flags&tdf_enableback ? gg_enabled : 0) |
(flags&tdf_enablekerns ? gg_cb_on : 0);
label[gci].text = (unichar_t *) _("Transform simple positioning features & _kern pairs");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.cid = CID_DoSimplePos;
gcd[gci++].creator = GCheckBoxCreate;
array[ai++] = &gcd[gci-1]; array[ai++] = NULL;
y += 16;
gcd[gci].gd.pos.x = 10; gcd[gci].gd.pos.y = y;
gcd[gci].gd.flags = gg_visible | gg_enabled;
label[gci].text = (unichar_t *) _("Round To _Int");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.cid = CID_Round2Int;
gcd[gci++].creator = GCheckBoxCreate;
array[ai++] = &gcd[gci-1]; array[ai++] = NULL;
y += 24;
array[ai++] = GCD_Glue; array[ai++] = NULL;
gcd[gci].gd.pos.x = 30-3; gcd[gci].gd.pos.y = y;
gcd[gci].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[gci].text = (unichar_t *) _("_OK");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.mnemonic = 'O';
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.handle_controlevent = Trans_OK;
gcd[gci++].creator = GButtonCreate;
buttons[0] = GCD_Glue; buttons[1] = &gcd[gci-1]; buttons[2] = GCD_Glue; buttons[3] = GCD_Glue;
gcd[gci].gd.flags = gg_visible | gg_enabled;
label[gci].text = (unichar_t *) _("_Apply");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.handle_controlevent = Trans_OK;
gcd[gci].gd.cid = CID_Apply;
gcd[gci++].creator = GButtonCreate;
buttons[4] = GCD_Glue; buttons[5] = &gcd[gci-1]; buttons[6] = GCD_Glue; buttons[7] = GCD_Glue;
gcd[gci].gd.pos.x = -30; gcd[gci].gd.pos.y = gcd[gci-1].gd.pos.y+3;
gcd[gci].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[gci].text = (unichar_t *) _("_Cancel");
label[gci].text_is_1byte = true;
label[gci].text_in_resource = true;
gcd[gci].gd.label = &label[gci];
gcd[gci].gd.mnemonic = 'C';
gcd[gci].gd.handle_controlevent = Trans_Cancel;
gcd[gci++].creator = GButtonCreate;
buttons[8] = GCD_Glue; buttons[9] = &gcd[gci-1]; buttons[10] = GCD_Glue;
buttons[11] = NULL;
boxes[2].gd.flags = gg_enabled|gg_visible;
boxes[2].gd.u.boxelements = buttons;
boxes[2].creator = GHBoxCreate;
array[ai++] = &boxes[2]; array[ai++] = NULL; array[ai++] = 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 = array;
boxes[0].creator = GHVGroupCreate;
GGadgetsCreate(gw,boxes);
GHVBoxSetExpandableRow(boxes[0].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[2].ret,gb_expandgluesame);
GHVBoxSetExpandableCol(boxes[3].ret,gb_expandglue);
for ( i=0; i<TCnt; ++i ) {
GHVBoxSetPadding( GWidgetGetControl(gw,CID_ClockBox+i*TBlock_CIDOffset),0,0);
GHVBoxSetPadding( GWidgetGetControl(gw,CID_HVBox+i*TBlock_CIDOffset),0,0);
GHVBoxSetExpandableCol( GWidgetGetControl(gw,CID_HBox+i*TBlock_CIDOffset),gb_expandglue);
}
GGadgetSelectOneListItem( GWidgetGetControl(gw,CID_Type), 1);
GWidgetToDesiredSize(gw);
} else
GDrawSetTransientFor(td.gw,(GWindow) -1);
gw = td.gw;
GGadgetSetEnabled( GWidgetGetControl(gw,CID_AllLayers), flags&tdf_enableback);
GGadgetSetEnabled( GWidgetGetControl(gw,CID_DoGrid), flags&tdf_enableback);
GGadgetSetEnabled( GWidgetGetControl(gw,CID_DoSimplePos), flags&tdf_enableback);
GGadgetSetEnabled( GWidgetGetControl(gw,CID_DoKerns), flags&tdf_enablekerns);
GGadgetSetVisible( GWidgetGetControl(gw,CID_Apply), flags&tdf_addapply);
if ( !(flags&tdf_enableback) ) {
GGadgetSetChecked( GWidgetGetControl(gw,CID_AllLayers), false );
GGadgetSetChecked( GWidgetGetControl(gw,CID_DoGrid), false );
}
GGadgetSetChecked( GWidgetGetControl(gw,CID_DoKerns),
!(flags&tdf_enablekerns)?false:(flags&tdf_defaultkerns)?true:false );
/* Yes, this is set differently from the previous, that's intended */
GGadgetSetChecked( GWidgetGetControl(gw,CID_DoSimplePos),
!(flags&tdf_enableback)?false:(flags&tdf_enablekerns)?true:false );
orig = GWidgetGetControl(gw,CID_Origin);
GGadgetSetEnabled( orig, getorigin!=NULL );
ti = GGadgetGetList(orig,&len);
for ( i=0; i<len; ++i ) {
ti[i]->disabled = !getorigin(data,&junk,i);
if ( ti[i]->disabled && ti[i]->selected ) {
ti[i]->selected = false;
ti[0]->selected = true;
GGadgetSetTitle(orig,ti[0]->text);
}
}
if ( cvt!=cvt_none ) {
int index = cvt == cvt_scale ? 4 :
cvt == cvt_flip ? 5 :
cvt == cvt_rotate ? 2 :
cvt == cvt_skew ? 6 :
/* 3d rot*/ 7 ;
GGadget *firstoption = GWidgetGetControl(td.gw,CID_Type);
GEvent dummy;
GGadgetSelectOneListItem( firstoption, index );
memset(&dummy,0,sizeof(dummy));
dummy.type = et_controlevent; dummy.u.control.subtype = et_listselected;
Trans_TypeChange( firstoption, &dummy );
}
for ( i=0; i<TCnt; ++i ) {
int index = GGadgetGetFirstListSelectedItem(GWidgetGetControl(td.gw,CID_Type+i*TBlock_CIDOffset));
if ( selcid[index]!=0 ) {
GGadget *tf = GWidgetGetControl(td.gw,selcid[index]+i*TBlock_CIDOffset);
GWidgetIndicateFocusGadget(tf);
GTextFieldSelect(tf,0,-1);
break;
}
}
GWidgetHidePalettes();
GDrawSetVisible(gw,true);
while ( !td.done )
GDrawProcessOneEvent(NULL);
GDrawSetVisible(gw,false);
}
static uint32_t *
GWidgetOpenFileWPath (const uint32_t *title, const uint32_t *defaultfile,
const uint32_t *initial_filter, char **mimetypes,
GFileChooserFilterType filter, char **path)
{
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[7], boxes[3], *varray[5], *harray[8];
GTextInfo label[4];
struct gfc_data d;
int bs = GIntGetResource (_NUM_Buttonsize), bsbigger, totwid;
GProgressPauseTimer ();
memset (&wattrs, 0, sizeof (wattrs));
wattrs.mask =
wam_events | wam_cursor | wam_wtitle | wam_undercursor | wam_restrict |
wam_isdlg;
wattrs.event_masks = ~(1 << et_charup);
wattrs.restrict_input_to_me = 1;
wattrs.undercursor = 1;
wattrs.is_dlg = 1;
wattrs.cursor = ct_pointer;
wattrs.window_title = (uint32_t *) title;
pos.x = pos.y = 0;
totwid = GGadgetScale (223);
bsbigger = 3 * bs + 4 * 14 > totwid;
totwid = bsbigger ? 3 * bs + 4 * 12 : totwid;
pos.width = GDrawPointsToPixels (NULL, totwid);
pos.height = GDrawPointsToPixels (NULL, 223);
gw = GDrawCreateTopWindow (NULL, &pos, e_h, &d, &wattrs);
memset (&label, 0, sizeof (label));
memset (&gcd, 0, sizeof (gcd));
memset (&boxes, 0, sizeof (boxes));
gcd[0].gd.pos.x = 12;
gcd[0].gd.pos.y = 6;
gcd[0].gd.pos.width = 223 - 24;
gcd[0].gd.pos.height = 180;
gcd[0].gd.flags = gg_visible | gg_enabled;
gcd[0].creator = GFileChooserCreate;
varray[0] = &gcd[0];
varray[1] = NULL;
gcd[1].gd.pos.x = 12;
gcd[1].gd.pos.y = 192 - 3;
gcd[1].gd.pos.width = -1;
gcd[1].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[1].text = (uint32_t *) _("_OK");
label[1].text_is_1byte = true;
label[1].text_has_mnemonic = true;
gcd[1].gd.label = &label[1];
gcd[1].gd.handle_controlevent = GFD_Ok;
gcd[1].creator = GButtonCreate;
harray[0] = GCD_Glue;
harray[1] = &gcd[1];
gcd[2].gd.pos.x =
(totwid - bs) * 100 / GIntGetResource (_NUM_ScaleFactor) / 2;
gcd[2].gd.pos.y = gcd[1].gd.pos.y + 3;
gcd[2].gd.pos.width = -1;
gcd[2].gd.flags = gg_visible | gg_enabled;
label[2].text = (uint32_t *) _("_Filter");
label[2].text_is_1byte = true;
label[2].text_has_mnemonic = true;
gcd[2].gd.label = &label[2];
gcd[2].gd.handle_controlevent = GFileChooserFilterEh;
gcd[2].creator = GButtonCreate;
harray[2] = GCD_Glue;
harray[3] = &gcd[2];
gcd[3].gd.pos.x = -gcd[1].gd.pos.x;
gcd[3].gd.pos.y = gcd[2].gd.pos.y;
gcd[3].gd.pos.width = -1;
gcd[3].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[3].text = (uint32_t *) _("_Cancel");
label[3].text_is_1byte = true;
label[3].text_has_mnemonic = true;
gcd[3].gd.label = &label[3];
gcd[3].gd.handle_controlevent = GFD_Cancel;
gcd[3].creator = GButtonCreate;
harray[4] = GCD_Glue;
harray[5] = &gcd[3];
harray[6] = GCD_Glue;
harray[7] = NULL;
boxes[2].gd.flags = gg_visible | gg_enabled;
boxes[2].gd.u.boxelements = harray;
boxes[2].creator = GHBoxCreate;
varray[2] = &boxes[2];
varray[3] = NULL;
varray[4] = 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 = varray;
boxes[0].creator = GHVGroupCreate;
gcd[4].gd.pos.x = 2;
gcd[4].gd.pos.y = 2;
gcd[4].gd.pos.width = pos.width - 4;
gcd[4].gd.pos.height = pos.height - 4;
gcd[4].gd.flags = gg_enabled | gg_visible | gg_pos_in_pixels;
gcd[4].creator = GGroupCreate;
GGadgetsCreate (gw, boxes);
GGadgetSetUserData (gcd[2].ret, gcd[0].ret);
GHVBoxSetExpandableRow (boxes[0].ret, 0);
GHVBoxSetExpandableCol (boxes[2].ret, gb_expandgluesame);
GHVBoxFitWindow (boxes[0].ret);
GFileChooserConnectButtons (gcd[0].ret, gcd[1].ret, gcd[2].ret);
GFileChooserSetFilterText (gcd[0].ret, initial_filter);
GFileChooserSetFilterFunc (gcd[0].ret, filter);
GFileChooserSetMimetypes (gcd[0].ret, mimetypes);
GFileChooserSetPaths (gcd[0].ret, path);
GGadgetSetTitle (gcd[0].ret, defaultfile);
memset (&d, '\0', sizeof (d));
d.gfc = gcd[0].ret;
GDrawSetVisible (gw, true);
while (!d.done)
GDrawProcessOneEvent (NULL);
GDrawDestroyWindow (gw);
GDrawProcessPendingEvents (NULL); /* Give the window a chance to vanish... */
GDrawSync (NULL);
GDrawProcessPendingEvents (NULL); /* Give the window a chance to vanish... */
GProgressResumeTimer ();
return (d.ret);
}
static int _GWidget_TopLevel_eh(GWindow gw, GEvent *event) {
GTopLevelD *td;
int ret;
if ( !GDrawNativeWindowExists(NULL,event->native_window) )
return( true );
td = (GTopLevelD *) (gw->widget_data);
if ( td==NULL ) /* Dying */
return( true );
GGadgetPopupExternalEvent(event);
if ( event->type==et_focus ) {
if ( event->u.focus.gained_focus ) {
if ( gw->is_toplevel && !gw->is_popup && !gw->is_dying ) {
if ( last_input_window!=gw )
previous_focus_window = last_input_window;
current_focus_window = gw;
}
} else if ( current_focus_window==gw ) {
current_focus_window = NULL;
}
if ( !td->ispalette && gw->is_visible && event->u.focus.gained_focus && !gw->is_dying ) {
GWindow dlg = GDrawGetRedirectWindow(NULL);
if ( dlg==NULL || dlg==gw ) {
/* If top level window loses the focus all its palettes go invisible */
/* if it gains focus then all palettes that are supposed to be vis */
/* become visible */
/* But not if we've got an active dialog */
GTopLevelD *palette;
if ( last_paletted_focus_window!=NULL && !last_paletted_focus_window->is_dying ) {
GTopLevelD *lpfw_td = (GTopLevelD *) (last_paletted_focus_window->widget_data);
for ( palette=lpfw_td->palettes; palette!=NULL; palette = palette->nextp ) {
if ( !palette->w->is_visible && palette->w->visible_request ) {
GDrawSetVisible(palette->w,false);
palette->w->visible_request = true;
}
}
}
for ( palette=td->palettes; palette!=NULL; palette = palette->nextp ) {
if ( !palette->w->is_visible && palette->w->visible_request )
GDrawSetVisible(palette->w,true);
}
last_paletted_focus_window = gw;
}
}
if ( !gw->is_dying && td->gfocus!=NULL && td->gfocus->funcs->handle_focus!=NULL ) {
{ oldtd = td; oldgfocus = td->gfocus; } /* Debug!!!! */
(td->gfocus->funcs->handle_focus)(td->gfocus,event);
} else if ( !gw->is_dying && td->wfocus!=NULL ) {
if ( td->wfocus->widget_data!=NULL ) {
if ( td->wfocus->widget_data->e_h!=NULL )
(td->wfocus->widget_data->e_h)(td->wfocus,event);
} else if ( td->wfocus->eh!=NULL )
(td->wfocus->eh)(td->wfocus,event);
}
if ( !gw->is_dying && td->e_h!=NULL )
(td->e_h)(gw,event);
return( true );
} else if ( !gw->is_dying && event->type == et_crossing ) {
GiveToAll((GContainerD *) td,event);
return( true );
} else if ( event->type == et_char || event->type == et_charup ) {
return( _GWidget_TopLevel_Key(gw,gw,event));
} else if ( !gw->is_dying && event->type == et_resize ) {
GRect r;
if ( td->gmenubar!=NULL ) {
GGadgetGetSize(td->gmenubar,&r);
GGadgetResize(td->gmenubar,event->u.resize.size.width,r.height);
GGadgetRedraw(td->gmenubar);
} /* status line, toolbar, etc. */
if ( td->palettes!=NULL && event->u.resize.moved ) {
GTopLevelD *palette;
for ( palette=td->palettes; palette!=NULL; palette = palette->nextp ) {
if ( !broken_palettes || !palette->positioned_yet ) {
int x = gw->pos.x + palette->owner_off_x,
y = gw->pos.y + palette->owner_off_y;
if ( x<0 ) x=0;
if ( y<0 ) y=0;
if ( x+palette->w->pos.width>GDrawGetRoot(NULL)->pos.width )
x = GDrawGetRoot(NULL)->pos.width-palette->w->pos.width;
if ( y+palette->w->pos.height>GDrawGetRoot(NULL)->pos.height )
y = GDrawGetRoot(NULL)->pos.height-palette->w->pos.height;
++palette->programmove;
if ( gw->is_visible )
GDrawTrueMove(palette->w, x, y);
else
GDrawMove(palette->w, x, y);
palette->positioned_yet = true;
}
}
}
if ( td->ispalette ) {
if ( td->programmove>0 )
--td->programmove;
else {
td->owner_off_x = gw->pos.x - td->owner->w->pos.x;
td->owner_off_y = gw->pos.y - td->owner->w->pos.y;
}
}
} else if ( event->type == et_close && td->ispalette ) {
GDrawSetVisible(gw,false);
return( true );
} else if ( !gw->is_dying && event->type == et_visibility ) {
if ( broken_palettes )
/* Do Nothing */;
else if ( td->ispalette && event->u.visibility.state!=vs_unobscured ) {
if ( !GDrawIsAbove(gw,td->owner->w))
GDrawRaiseAbove(gw,td->owner->w);
}
} else if ( !gw->is_dying && event->type == et_map && !td->ispalette ) {
/* If top level window goes invisible all its palettes follow */
/* if it goes visible then all palettes that are supposed to be vis */
/* follow */
ManagePalettesVis(td, event->u.map.is_visible );
}
if ( event->type == et_destroy ) {
if ( td->palettes!=NULL ) {
struct gtopleveldata *palettes, *next;
for ( palettes=td->palettes; palettes!=NULL; palettes = next ) {
next = palettes->nextp;
GDrawDestroyWindow(palettes->w);
}
/* Palettes must die before our widget data are freed */
GDrawSync(GDrawGetDisplayOfWindow(gw));
GDrawProcessPendingEvents(GDrawGetDisplayOfWindow(gw));
}
}
ret = _GWidget_Container_eh(gw,event);
if ( event->type == et_destroy ) {
if ( gw==current_focus_window )
current_focus_window = NULL;
if ( gw==previous_focus_window )
previous_focus_window = NULL;
if ( gw==last_input_window )
last_input_window = NULL;
if ( gw==last_paletted_focus_window )
last_paletted_focus_window = NULL;
ret = true;
}
return( ret );
}
void CVFtPpemDlg(CharView *cv,int debug) {
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[16], boxes[8];
GTextInfo label[16];
FtSizeData fsd;
char buffer[20], buffer2[20], buffer3[20];
GGadgetCreateData *varray[7][4], *barray[9], *harray1[3], *harray2[3], *harray3[3];
int k,r;
memset(&fsd,0,sizeof(fsd));
fsd.cv = cv;
fsd.debug = debug;
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 = _("Grid Fit Parameters");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,190));
pos.height = GDrawPointsToPixels(NULL,106);
fsd.gw = gw = GDrawCreateTopWindow(NULL,&pos,fsd_e_h,&fsd,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
k=r=0;
label[k].text = (unichar_t *) _("Debug _fpgm/prep");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 80; gcd[k].gd.pos.y = 4;
gcd[k].gd.flags = debug ? (gg_enabled|gg_visible) : 0;
if ( last_fpgm )
gcd[k].gd.flags |= gg_cb_on;
gcd[k].gd.cid = CID_Debugfpgm;
gcd[k++].creator = GCheckBoxCreate;
varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r++][3] = NULL;
label[k].text = (unichar_t *) _("Scale X/Y the same");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 110; gcd[k].gd.pos.y = 17+5+6;
gcd[k].gd.flags = gg_enabled|gg_visible;
if ( gridfit_x_sameas_y )
gcd[k].gd.flags |= gg_cb_on;
gcd[k].gd.cid = CID_SameAs;
gcd[k].gd.handle_controlevent = FtPpem_SameAsChanged;
gcd[k++].creator = GCheckBoxCreate;
varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_HPad10;
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.pos.x = 110; gcd[k].gd.pos.y = 17+5+6;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
harray1[0] = &gcd[k-1];
sprintf( buffer2, "%d", gridfit_dpi );
label[k].text = (unichar_t *) buffer2;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 140; gcd[k].gd.pos.y = 17+5; gcd[k].gd.pos.width = 40;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.cid = CID_DPI;
gcd[k++].creator = GTextFieldCreate;
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[r][2] = &boxes[2]; varray[r++][3] = NULL;
label[k].text = (unichar_t *) _("_Pointsize Y:");
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 = 17+5+6;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
harray2[0] = &gcd[k-1];
sprintf( buffer, "%g", gridfit_pointsizey );
label[k].text = (unichar_t *) buffer;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 57; gcd[k].gd.pos.y = 17+5; gcd[k].gd.pos.width = 40;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.handle_controlevent = FtPpem_PtYChanged;
gcd[k].gd.cid = CID_PointSize;
gcd[k++].creator = GTextFieldCreate;
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[r][0] = &boxes[3]; varray[r][1] = GCD_HPad10;
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 = 5; gcd[k].gd.pos.y = 17+5+6;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
harray3[0] = &gcd[k-1];
sprintf( buffer3, "%g", gridfit_x_sameas_y ? gridfit_pointsizey : gridfit_pointsizex);
label[k].text = (unichar_t *) buffer3;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 57; gcd[k].gd.pos.y = 17+5; gcd[k].gd.pos.width = 40;
gcd[k].gd.flags = gg_enabled|gg_visible;
if ( gridfit_x_sameas_y )
gcd[k].gd.flags = gg_visible;
gcd[k].gd.cid = CID_PointSizeX;
gcd[k++].creator = GTextFieldCreate;
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[r][2] = &boxes[4]; varray[r++][3] = NULL;
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.pos.x = 20; gcd[k].gd.pos.y = 14+31;
gcd[k].gd.flags = gridfit_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.pos.x = 80; gcd[k].gd.pos.y = gcd[9].gd.pos.y;
gcd[k].gd.flags = gridfit_depth!=1 ? (gg_enabled|gg_visible|gg_cb_on) : (gg_enabled|gg_visible);
gcd[k++].creator = GRadioCreate;
varray[r][2] = &gcd[k-1]; varray[r++][3] = NULL;
gcd[k].gd.pos.x = 5; gcd[k].gd.pos.y = 17+31+16;
gcd[k].gd.pos.width = 190-10;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLineCreate;
varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r++][3] = NULL;
gcd[k].gd.pos.x = 20-3; gcd[k].gd.pos.y = 17+37+16;
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.mnemonic = 'O';
gcd[k].gd.label = &label[k];
gcd[k].gd.handle_controlevent = FtPpem_OK;
gcd[k++].creator = GButtonCreate;
barray[0] = GCD_Glue; barray[1] = &gcd[k-1]; barray[2] = GCD_Glue;
gcd[k].gd.pos.x = -20; gcd[k].gd.pos.y = gcd[4].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.mnemonic = 'C';
gcd[k].gd.handle_controlevent = FtPpem_Cancel;
gcd[k++].creator = GButtonCreate;
barray[3] = GCD_Glue; barray[4] = &gcd[k-1]; barray[5] = GCD_Glue; barray[6] = NULL;
boxes[5].gd.flags = gg_enabled|gg_visible;
boxes[5].gd.u.boxelements = barray;
boxes[5].creator = GHBoxCreate;
varray[r][0] = &boxes[5]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r++][3] = 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].creator = GHVGroupCreate;
GGadgetsCreate(gw,boxes);
GHVBoxFitWindow(boxes[0].ret);
GWidgetIndicateFocusGadget(GWidgetGetControl(gw,CID_PointSize));
GTextFieldSelect(GWidgetGetControl(gw,CID_PointSize),0,-1);
GWidgetHidePalettes();
GDrawSetVisible(gw,true);
while ( !fsd.done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
}
void JustifyDlg(SplineFont *sf) {
Jstf_Dlg jd;
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[4], boxes[3];
GGadgetCreateData *varray[6], *harray3[8];
GTextInfo label[4];
struct matrixinit mi;
int i,j,k;
LookupUIInit();
JustUIInit();
memset(&jd,0,sizeof(jd));
jd.sf = sf;
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.is_dlg = true;
wattrs.restrict_input_to_me = 1;
wattrs.undercursor = 1;
wattrs.cursor = ct_pointer;
wattrs.utf8_window_title = _("Justified Scripts");
pos.x = pos.y = 0;
pos.width =GDrawPointsToPixels(NULL,GGadgetScale(268));
pos.height = GDrawPointsToPixels(NULL,375);
jd.gw = gw = GDrawCreateTopWindow(NULL,&pos,jscripts_e_h,&jd,&wattrs);
JScriptMatrixInit(&mi,sf->justify);
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
memset(&label,0,sizeof(label));
k=j=0;
gcd[k].gd.pos.x = 10; gcd[k].gd.pos.y = gcd[1].gd.pos.y+14;
gcd[k].gd.flags = gg_enabled | gg_visible | gg_utf8_popup;
gcd[k].gd.cid = CID_Scripts;
gcd[k].gd.u.matrix = &mi;
gcd[k].gd.popup_msg = (unichar_t *) _( "A list of scripts with special justification needs");
gcd[k].creator = GMatrixEditCreate;
varray[j++] = &gcd[k++]; varray[j++] = NULL;
gcd[k].gd.pos.x = 30-3;
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.handle_controlevent = JSTF_Script_OK;
gcd[k].gd.cid = CID_OK;
gcd[k++].creator = GButtonCreate;
gcd[k].gd.pos.x = -30;
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.handle_controlevent = Justify_Cancel;
gcd[k].gd.cid = CID_Cancel;
gcd[k++].creator = GButtonCreate;
harray3[0] = harray3[2] = harray3[3] = harray3[4] = harray3[6] = GCD_Glue;
harray3[7] = NULL;
harray3[1] = &gcd[k-2]; harray3[5] = &gcd[k-1];
boxes[0].gd.flags = gg_enabled|gg_visible;
boxes[0].gd.u.boxelements = harray3;
boxes[0].creator = GHBoxCreate;
varray[j++] = &boxes[0]; varray[j++] = NULL; varray[j] = NULL;
boxes[1].gd.pos.x = boxes[1].gd.pos.y = 2;
boxes[1].gd.flags = gg_enabled|gg_visible;
boxes[1].gd.u.boxelements = varray;
boxes[1].creator = GHVGroupCreate;
GGadgetsCreate(gw,boxes+1);
for ( i=0; i<mi.initial_row_cnt; ++i ) {
free( mi.matrix_data[2*i+0].u.md_str );
}
free( mi.matrix_data );
GMatrixEditSetNewText(gcd[0].ret,S_("Script|New"));
GMatrixEditSetUpDownVisible(gcd[0].ret,true);
GMatrixEditShowColumn(gcd[0].ret,3,false);
GHVBoxSetExpandableCol(boxes[0].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[1].ret);
GDrawSetVisible(gw,true);
while ( !jd.done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
}
static int splash_e_h(GWindow gw, GEvent *event) {
static int splash_cnt;
GRect old;
int i, y, x;
static char *foolishness[] = {
/* GT: These strings are for fun. If they are offensive or incomprehensible */
/* GT: simply translate them as something dull like: "FontForge" */
/* GT: This is a spoof of political slogans, designed to point out how foolish they are */
N_("A free press discriminates\nagainst the illiterate."),
N_("A free press discriminates\nagainst the illiterate."),
/* GT: This is a pun on the old latin drinking song "Gaudeamus igature!" */
N_("Gaudeamus Ligature!"),
N_("Gaudeamus Ligature!"),
/* GT: Spoof on the bible */
N_("In the beginning was the letter..."),
/* GT: Some wit at MIT came up with this ("ontology recapitulates phylogony" is the original) */
N_("fontology recapitulates file-ogeny")
};
switch ( event->type ) {
case et_create:
GDrawGrabSelection(gw,sn_user1);
break;
case et_expose:
GDrawPushClip(gw,&event->u.expose.rect,&old);
GDrawDrawImage(gw,&splashimage,NULL,0,0);
GDrawSetFont(gw,splash_font);
y = splashimage.u.image->height + as + fh/2;
for ( i=1; i<linecnt; ++i ) {
if ( is>=lines[i-1]+1 && is<lines[i] ) {
x = 8+GDrawDrawText(gw,8,y,lines[i-1]+1,is-lines[i-1]-1,0x000000);
GDrawSetFont(gw,splash_italic);
GDrawDrawText(gw,x,y,is,lines[i]-is,0x000000);
} else if ( ie>=lines[i-1]+1 && ie<lines[i] ) {
x = 8+GDrawDrawText(gw,8,y,lines[i-1]+1,ie-lines[i-1]-1,0x000000);
GDrawSetFont(gw,splash_font);
GDrawDrawText(gw,x,y,ie,lines[i]-ie,0x000000);
} else
GDrawDrawText(gw,8,y,lines[i-1]+1,lines[i]-lines[i-1]-1,0x000000);
y += fh;
}
GDrawPopClip(gw,&old);
break;
case et_map:
splash_cnt = 0;
break;
case et_timer:
if ( event->u.timer.timer==autosave_timer ) {
DoAutoSaves();
} else if ( event->u.timer.timer==splasht ) {
if ( ++splash_cnt==1 )
GDrawResize(gw,splashimage.u.image->width,splashimage.u.image->height-30);
else if ( splash_cnt==2 )
GDrawResize(gw,splashimage.u.image->width,splashimage.u.image->height);
else if ( splash_cnt>=7 ) {
GGadgetEndPopup();
GDrawSetVisible(gw,false);
GDrawCancelTimer(splasht);
splasht = NULL;
}
} else {
DoDelayedEvents(event);
}
break;
case et_char:
case et_mousedown:
case et_close:
GGadgetEndPopup();
GDrawSetVisible(gw,false);
break;
case et_mousemove:
GGadgetPreparePopup8(gw,_(foolishness[rand()%(sizeof(foolishness)/sizeof(foolishness[0]))]) );
break;
case et_selclear:
/* If this happens, it means someone wants to send us a message with a*/
/* filename to open. So we need to ask for it, process it, and then */
/* take the selection back again */
if ( event->u.selclear.sel == sn_user1 ) {
int len;
char *arg;
arg = GDrawRequestSelection(splashw,sn_user1,"STRING",&len);
if ( arg==NULL )
return( true );
if ( strcmp(arg,"-new")==0 || strcmp(arg,"--new")==0 )
FontNew();
else if ( strcmp(arg,"-open")==0 || strcmp(arg,"--open")==0 )
_FVMenuOpen(NULL);
else if ( strcmp(arg,"-quit")==0 || strcmp(arg,"--quit")==0 )
MenuExit(NULL,NULL,NULL);
else
ViewPostScriptFont(arg,0);
free(arg);
GDrawGrabSelection(splashw,sn_user1);
}
break;
case et_destroy:
IError("Who killed the splash screen?");
break;
}
return( true );
}
void help(char *file) {
char fullspec[1024], *temp, *pt;
if ( browser[0]=='\0' )
findbrowser();
#ifndef __CygWin
if ( browser[0]=='\0' ) {
gwwv_post_error(_("No Browser"),_("Could not find a browser. Set the BROWSER environment variable to point to one"));
return;
}
#endif
if ( strstr(file,"http://")==NULL ) {
fullspec[0] = 0;
if ( ! GFileIsAbsolute(file) ) {
if ( helpdir==NULL || *helpdir=='\0' ) {
#ifdef DOCDIR
strcpy(fullspec,DOCDIR "/");
#elif defined(SHAREDIR)
strcpy(fullspec,SHAREDIR "/doc/fontforge/");
#else
strcpy(fullspec,"/usr/local/share/doc/fontforge/");
#endif
} else {
strcpy(fullspec,helpdir);
}
}
strcat(fullspec,file);
if (( pt = strrchr(fullspec,'#') )!=NULL ) *pt ='\0';
if ( !GFileReadable( fullspec )) {
if ( *file!='/' ) {
strcpy(fullspec,"/usr/share/doc/fontforge/");
strcat(fullspec,file);
if (( pt = strrchr(fullspec,'#') )!=NULL ) *pt ='\0';
}
}
if ( !GFileReadable( fullspec )) {
strcpy(fullspec,"http://fontforge.sf.net/");
AppendSupportedLocale(fullspec);
strcat(fullspec,file);
} else if ( pt!=NULL )
*pt = '#';
} else
strcpy(fullspec,file);
#if __CygWin
if ( (strstrmatch(browser,"/cygdrive")!=NULL || browser[0]=='\0') &&
strstr(fullspec,":/")==NULL ) {
/* It looks as though the browser is a windows application, so we */
/* should give it a windows file name */
char *pt, *tpt;
temp = galloc(1024);
cygwin_conv_to_full_win32_path(fullspec,temp);
for ( pt = fullspec, tpt = temp; *tpt && pt<fullspec+sizeof(fullspec)-3; *pt++ = *tpt++ )
if ( *tpt=='\\' )
*pt++ = '\\';
*pt = '\0';
free(temp);
}
#endif
#if __Mac
if ( strcmp(browser,"open")==0 )
/* open doesn't want "file:" prepended */;
else
#endif
if ( strstr(fullspec,":/")==NULL ) {
char *t1 = galloc(strlen(fullspec)+strlen("file:")+20);
#if __CygWin
sprintf( t1, "file:\\\\\\%s", fullspec );
#else
sprintf( t1, "file:%s", fullspec);
#endif
strcpy(fullspec,t1);
free(t1);
}
#if 0 && __Mac
/* Starting a Mac application is weird... system() can't do it */
/* Thanks to Edward H. Trager giving me an example... */
if ( strstr(browser,".app")!=NULL ) {
*strstr(browser,".app") = '\0';
pt = strrchr(browser,'/');
if ( pt==NULL ) pt = browser-1;
++pt;
temp = galloc(strlen(pt)+strlen(fullspec) +
strlen( "osascript -l AppleScript -e \"Tell application \"\" to getURL \"\"\"" )+
20);
/* this doesn't work on Max OS X.0 (osascript does not support -e) */
sprintf( temp, "osascript -l AppleScript -e \"Tell application \"%s\" to getURL \"%s\"\"",
pt, fullspec);
system(temp);
ff_post_notice(_("Leave X"),_("A browser is probably running in the native Mac windowing system. You must leave the X environment to view it. Try Cmd-Opt-A"));
} else {
#elif __Mac
/* This seems a bit easier... Thanks to riggle */
if ( strcmp(browser,"open")==0 ) {
char *str = "DYLD_LIBRARY_PATH=\"\"; open ";
temp = galloc(strlen(str) + strlen(fullspec) + 20);
sprintf( temp, "%s \"%s\" &", str, fullspec );
system(temp);
} else {
#elif __CygWin
if ( browser[0]=='\0' ) {
do_windows_browser(fullspec);
temp = NULL;
} else {
#else
{
#endif
temp = galloc(strlen(browser) + strlen(fullspec) + 20);
sprintf( temp, strcmp(browser,"kfmclient openURL")==0 ? "%s \"%s\" &" : "\"%s\" \"%s\" &", browser, fullspec );
system(temp);
}
free(temp);
}
#endif
static void UI_IError(const char *format,...) {
va_list ap;
char buffer[300];
va_start(ap,format);
vsnprintf(buffer,sizeof(buffer),format,ap);
GDrawIError("%s",buffer);
va_end(ap);
}
#define MAX_ERR_LINES 400
static struct errordata {
char *errlines[MAX_ERR_LINES];
GFont *font;
int fh, as;
GGadget *vsb;
GWindow gw, v;
int cnt, linecnt;
int offtop;
int showing;
int start_l, start_c, end_l, end_c;
int down;
} errdata;
static void ErrHide(void) {
GDrawSetVisible(errdata.gw,false);
errdata.showing = false;
}
static void ErrScroll(struct sbevent *sb) {
int newpos = errdata.offtop;
switch( sb->type ) {
case et_sb_top:
newpos = 0;
break;
case et_sb_uppage:
newpos -= errdata.linecnt;
break;
case et_sb_up:
--newpos;
break;
case et_sb_down:
++newpos;
break;
case et_sb_downpage:
newpos += errdata.linecnt;
break;
case et_sb_bottom:
newpos = errdata.cnt-errdata.linecnt;
break;
case et_sb_thumb:
case et_sb_thumbrelease:
newpos = sb->pos;
break;
}
if ( newpos>errdata.cnt-errdata.linecnt )
newpos = errdata.cnt-errdata.linecnt;
if ( newpos<0 ) newpos =0;
if ( newpos!=errdata.offtop ) {
errdata.offtop = newpos;
GScrollBarSetPos(errdata.vsb,errdata.offtop);
GDrawRequestExpose(errdata.v,NULL,false);
}
}
void NonLinearDlg(FontView *fv,CharView *cv) {
static unichar_t *lastx, *lasty;
struct nldlg d;
GRect pos;
GWindowAttrs wattrs;
GGadgetCreateData gcd[8], boxes[4], *hvarray[3][3], *barray[9], *varray[3][2];
GTextInfo label[8];
struct context c;
char *expstr;
memset(&d,'\0',sizeof(d));
memset(&c,'\0',sizeof(c));
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 = _("Non Linear Transform");
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,200));
pos.height = GDrawPointsToPixels(NULL,97);
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));
/* GT: an expression describing the transformation applied to the X coordinate */
label[0].text = (unichar_t *) _("X Expr:");
label[0].text_is_1byte = true;
gcd[0].gd.label = &label[0];
gcd[0].gd.pos.x = 10; gcd[0].gd.pos.y = 8;
gcd[0].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[0].gd.popup_msg = (unichar_t *) _("These expressions may contain the operators +,-,*,/,%,^ (which means raise to the power of here), and ?: It may also contain a few standard functions. Basic terms are real numbers, x and y.\nExamples:\n x^3+2.5*x^2+5\n (x-300)*(y-200)/100\n y+sin(100*x)");
gcd[0].creator = GLabelCreate;
hvarray[0][0] = &gcd[0];
if ( lastx!=NULL )
label[1].text = lastx;
else {
label[1].text = (unichar_t *) "x";
label[1].text_is_1byte = true;
}
gcd[1].gd.label = &label[1];
gcd[1].gd.pos.x = 55; gcd[1].gd.pos.y = 5; gcd[1].gd.pos.width = 135;
gcd[1].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[1].gd.popup_msg = (unichar_t *) _("These expressions may contain the operators +,-,*,/,%,^ (which means raise to the power of here), and ?: It may also contain a few standard functions. Basic terms are real numbers, x and y.\nExamples:\n x^3+2.5*x^2+5\n (x-300)*(y-200)/100\n y+sin(100*x)");
gcd[1].creator = GTextFieldCreate;
hvarray[0][1] = &gcd[1]; hvarray[0][2] = NULL;
/* GT: an expression describing the transformation applied to the Y coordinate */
label[2].text = (unichar_t *) _("Y Expr:");
label[2].text_is_1byte = true;
gcd[2].gd.label = &label[2];
gcd[2].gd.pos.x = 10; gcd[2].gd.pos.y = gcd[0].gd.pos.y+26;
gcd[2].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[2].gd.popup_msg = (unichar_t *) _("These expressions may contain the operators +,-,*,/,%,^ (which means raise to the power of here), and ?: It may also contain a few standard functions. Basic terms are real numbers, x and y.\nExamples:\n x^3+2.5*x^2+5\n (x-300)*(y-200)/100\n y+sin(100*x)");
gcd[2].creator = GLabelCreate;
hvarray[1][0] = &gcd[2];
if ( lasty!=NULL )
label[3].text = lasty;
else {
label[3].text = (unichar_t *) "y";
label[3].text_is_1byte = true;
}
gcd[3].gd.label = &label[3];
gcd[3].gd.pos.x = gcd[1].gd.pos.x; gcd[3].gd.pos.y = gcd[1].gd.pos.y+26;
gcd[3].gd.pos.width = gcd[1].gd.pos.width;
gcd[3].gd.flags = gg_visible | gg_enabled | gg_utf8_popup;
gcd[3].gd.popup_msg = (unichar_t *) _("These expressions may contain the operators +,-,*,/,%,^ (which means raise to the power of here), and ?: It may also contain a few standard functions. Basic terms are real numbers, x and y.\nExamples:\n x^3+2.5*x^2+5\n (x-300)*(y-200)/100\n y+sin(100*x)");
gcd[3].creator = GTextFieldCreate;
hvarray[1][1] = &gcd[3]; hvarray[1][2] = NULL; hvarray[2][0] = NULL;
boxes[2].gd.flags = gg_enabled|gg_visible;
boxes[2].gd.u.boxelements = hvarray[0];
boxes[2].creator = GHVBoxCreate;
varray[0][0] = &boxes[2]; varray[0][1] = NULL;
gcd[4].gd.pos.x = 30-3; gcd[4].gd.pos.y = gcd[3].gd.pos.y+30;
gcd[4].gd.pos.width = -1; gcd[4].gd.pos.height = 0;
gcd[4].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[4].text = (unichar_t *) _("_OK");
label[4].text_is_1byte = true;
label[4].text_in_resource = true;
gcd[4].gd.label = &label[4];
gcd[4].gd.cid = true;
gcd[4].creator = GButtonCreate;
barray[0] = GCD_Glue; barray[1] = &gcd[4]; barray[2] = GCD_Glue;
gcd[5].gd.pos.x = -30; gcd[5].gd.pos.y = gcd[4].gd.pos.y+3;
gcd[5].gd.pos.width = -1; gcd[5].gd.pos.height = 0;
gcd[5].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[5].text = (unichar_t *) _("_Cancel");
label[5].text_is_1byte = true;
label[5].text_in_resource = true;
gcd[5].gd.label = &label[5];
gcd[5].gd.cid = false;
gcd[5].creator = GButtonCreate;
barray[3] = GCD_Glue; barray[4] = &gcd[5]; barray[5] = GCD_Glue; barray[6] = NULL;
boxes[3].gd.flags = gg_enabled|gg_visible;
boxes[3].gd.u.boxelements = barray;
boxes[3].creator = GHBoxCreate;
varray[1][0] = &boxes[3]; varray[1][1] = NULL;
varray[2][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);
GHVBoxSetExpandableCol(boxes[2].ret,1);
GHVBoxSetExpandableCol(boxes[3].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[0].ret);
GDrawSetVisible(d.gw,true);
while ( !d.done ) {
GDrawProcessOneEvent(NULL);
if ( d.done && d.ok ) {
expstr = cu_copy(_GGadgetGetTitle(gcd[1].ret));
c.had_error = false;
if ( (c.x_expr = nlt_parseexpr(&c,expstr))==NULL )
d.done = d.ok = false;
else {
free(expstr);
c.had_error = false;
expstr = cu_copy(_GGadgetGetTitle(gcd[3].ret));
if ( (c.y_expr = nlt_parseexpr(&c,expstr))==NULL ) {
d.done = d.ok = false;
nlt_exprfree(c.x_expr);
} else {
free(expstr);
free(lasty); free(lastx);
lastx = GGadgetGetTitle(gcd[1].ret);
lasty = GGadgetGetTitle(gcd[3].ret);
}
}
}
}
if ( d.ok ) {
if ( fv!=NULL )
_SFNLTrans((FontViewBase *) fv,&c);
else
CVNLTrans((CharViewBase *) cv,&c);
nlt_exprfree(c.x_expr);
nlt_exprfree(c.y_expr);
}
GDrawDestroyWindow(d.gw);
}
void SFBdfProperties(SplineFont *sf, EncMap *map, BDFFont *thisone) {
struct bdf_dlg bd;
int i;
BDFFont *bdf;
GTextInfo *ti;
char buffer[40];
char title[130];
GRect pos, subpos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[10];
GTextInfo label[9];
FontRequest rq;
static GFont *font = NULL;
extern int _GScrollBar_Width;
int sbwidth;
static unichar_t sans[] = { 'h','e','l','v','e','t','i','c','a',',','c','l','e','a','r','l','y','u',',','u','n','i','f','o','n','t', '\0' };
static GBox small = { 0 };
GGadgetData gd;
/* I don't use a MatrixEdit here because I want to be able to display */
/* non-standard properties. And a MatrixEdit can only disply things in */
/* its pull-down list */
memset(&bd,0,sizeof(bd));
bd.map = map;
bd.sf = sf;
for ( bdf = sf->bitmaps, i=0; bdf!=NULL; bdf=bdf->next, ++i );
if ( i==0 )
return;
bd.fcnt = i;
bd.fonts = gcalloc(i,sizeof(struct bdf_dlg_font));
bd.cur = &bd.fonts[0];
for ( bdf = sf->bitmaps, i=0; bdf!=NULL; bdf=bdf->next, ++i ) {
bd.fonts[i].bdf = bdf;
bd.fonts[i].old_prop_cnt = bdf->prop_cnt;
bd.fonts[i].old_props = BdfPropsCopy(bdf->props,bdf->prop_cnt);
bd.fonts[i].sel_prop = -1;
bdf->prop_max = bdf->prop_cnt;
if ( bdf==thisone )
bd.cur = &bd.fonts[i];
}
ti = gcalloc((i+1),sizeof(GTextInfo));
for ( bdf = sf->bitmaps, i=0; bdf!=NULL; bdf=bdf->next, ++i ) {
if ( bdf->clut==NULL )
sprintf( buffer, "%d", bdf->pixelsize );
else
sprintf( buffer, "%d@%d", bdf->pixelsize, BDFDepth(bdf));
ti[i].text = (unichar_t *) copy(buffer);
ti[i].text_is_1byte = true;
}
ti[bd.cur-bd.fonts].selected = true;
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.is_dlg = true;
wattrs.restrict_input_to_me = 1;
wattrs.undercursor = 1;
wattrs.cursor = ct_pointer;
snprintf(title,sizeof(title),_("Strike Information for %.90s"),
sf->fontname);
wattrs.utf8_window_title = title;
pos.x = pos.y = 0;
pos.width = GDrawPointsToPixels(NULL,GGadgetScale(268));
pos.height = GDrawPointsToPixels(NULL,375);
bd.gw = gw = GDrawCreateTopWindow(NULL,&pos,bdfp_e_h,&bd,&wattrs);
sbwidth = GDrawPointsToPixels(bd.gw,_GScrollBar_Width);
subpos.x = 0; subpos.y = GDrawPointsToPixels(NULL,28);
subpos.width = pos.width-sbwidth;
subpos.height = pos.height - subpos.y - GDrawPointsToPixels(NULL,70);
wattrs.mask = wam_events;
bd.v = GWidgetCreateSubWindow(gw,&subpos,bdfpv_e_h,&bd,&wattrs);
bd.vwidth = subpos.width; bd.vheight = subpos.height;
bd.width = pos.width; bd.height = pos.height;
bd.value_x = GDrawPointsToPixels(bd.gw,135);
if ( font==NULL ) {
memset(&rq,0,sizeof(rq));
rq.family_name = sans;
rq.point_size = 10;
rq.weight = 400;
font = GDrawInstanciateFont(GDrawGetDisplayOfWindow(gw),&rq);
font = GResourceFindFont("BDFProperties.Font",font);
}
bd.font = font;
{
int as, ds, ld;
GDrawFontMetrics(bd.font,&as,&ds,&ld);
bd.as = as; bd.fh = as+ds;
}
memset(gcd,0,sizeof(gcd));
memset(label,0,sizeof(label));
i=0;
gcd[i].gd.pos.x = 10; gcd[i].gd.pos.y = 3;
gcd[i].gd.flags = gg_visible | gg_enabled;
gcd[i].gd.u.list = ti;
gcd[i].gd.handle_controlevent = BdfP_ChangeBDF;
gcd[i++].creator = GListButtonCreate;
gcd[i].gd.pos.x = bd.vwidth; gcd[i].gd.pos.y = subpos.y-1;
gcd[i].gd.pos.width = sbwidth; gcd[i].gd.pos.height = subpos.height+2;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_sb_vert | gg_pos_in_pixels;
gcd[i].gd.handle_controlevent = _BdfP_VScroll;
gcd[i++].creator = GScrollBarCreate;
label[i].text = (unichar_t *) _("Delete");
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = 4; gcd[i].gd.pos.y = GDrawPixelsToPoints(gw,subpos.y+subpos.height)+6;
gcd[i].gd.flags = gg_visible | gg_enabled ;
gcd[i].gd.handle_controlevent = BdfP_DeleteCurrent;
gcd[i].gd.cid = CID_Delete;
gcd[i++].creator = GButtonCreate;
label[i].text = (unichar_t *) _("Default All");
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.x = 80; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y;
gcd[i].gd.flags = gg_visible | gg_enabled ;
gcd[i].gd.handle_controlevent = BdfP_DefaultAll;
gcd[i].gd.cid = CID_DefAll;
gcd[i++].creator = GButtonCreate;
label[i].text = (unichar_t *) _("Default This");
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.y = gcd[i-1].gd.pos.y;
gcd[i].gd.flags = gg_visible | gg_enabled ;
gcd[i].gd.handle_controlevent = BdfP_DefaultCurrent;
gcd[i].gd.cid = CID_DefCur;
gcd[i++].creator = GButtonCreate;
/* I want the 2 pronged arrow, but gdraw can't find a nice one */
/* label[i].text = (unichar_t *) "⇑"; *//* Up Arrow */
label[i].text = (unichar_t *) "↑"; /* Up Arrow */
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.y = gcd[i-1].gd.pos.y;
gcd[i].gd.flags = gg_visible | gg_enabled ;
gcd[i].gd.handle_controlevent = BdfP_Up;
gcd[i].gd.cid = CID_Up;
gcd[i++].creator = GButtonCreate;
/* I want the 2 pronged arrow, but gdraw can't find a nice one */
/* label[i].text = (unichar_t *) "⇓"; *//* Down Arrow */
label[i].text = (unichar_t *) "↓"; /* Down Arrow */
label[i].text_is_1byte = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.pos.y = gcd[i-1].gd.pos.y;
gcd[i].gd.flags = gg_visible | gg_enabled ;
gcd[i].gd.handle_controlevent = BdfP_Down;
gcd[i].gd.cid = CID_Down;
gcd[i++].creator = GButtonCreate;
gcd[i].gd.pos.x = 30-3; gcd[i].gd.pos.y = GDrawPixelsToPoints(NULL,pos.height)-32-3;
gcd[i].gd.pos.width = -1; gcd[i].gd.pos.height = 0;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[i].text = (unichar_t *) _("_OK");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = BdfP_OK;
gcd[i].gd.cid = CID_OK;
gcd[i++].creator = GButtonCreate;
gcd[i].gd.pos.x = -30; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y+3;
gcd[i].gd.pos.width = -1; gcd[i].gd.pos.height = 0;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[i].text = (unichar_t *) _("_Cancel");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = BdfP_Cancel;
gcd[i].gd.cid = CID_Cancel;
gcd[i++].creator = GButtonCreate;
GGadgetsCreate(gw,gcd);
GTextInfoListFree(gcd[0].gd.u.list);
bd.vsb = gcd[1].ret;
small.main_background = small.main_foreground = COLOR_DEFAULT;
small.main_foreground = 0x0000ff;
memset(&gd,'\0',sizeof(gd));
memset(&label[0],'\0',sizeof(label[0]));
label[0].text = (unichar_t *) "\0\0\0\0";
label[0].font = bd.font;
gd.pos.height = bd.fh;
gd.pos.width = bd.vwidth-bd.value_x;
gd.label = &label[0];
gd.box = &small;
gd.flags = gg_enabled | gg_pos_in_pixels | gg_dontcopybox | gg_text_xim;
bd.tf = GTextFieldCreate(bd.v,&gd,&bd);
bd.press_pos = -1;
BdfP_EnableButtons(&bd);
BdfP_RefigureScrollbar(&bd);
GDrawSetVisible(bd.v,true);
GDrawSetVisible(gw,true);
while ( !bd.done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
}
void ScriptDlg(FontView *fv,CharView *cv) {
GRect pos;
static GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[12], boxes[5], *barray[4][8], *hvarray[4][2];
#if !defined(_NO_FFSCRIPT) && !defined(_NO_PYTHON)
GGadgetCreateData *rarray[4];
#endif
GTextInfo label[12];
struct sd_data sd;
FontView *list;
int i,l;
memset(&sd,0,sizeof(sd));
sd.fv = fv;
sd.sc = cv==NULL ? NULL : cv->b.sc;
sd.layer = cv==NULL ? ly_fore : CVLayer((CharViewBase *) cv);
sd.oldh = pos.height = GDrawPointsToPixels(NULL,SD_Height);
if ( gw==NULL ) {
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.undercursor = 1;
wattrs.cursor = ct_pointer;
wattrs.utf8_window_title = _("Execute Script");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GDrawPointsToPixels(NULL,GGadgetScale(SD_Width));
gw = GDrawCreateTopWindow(NULL,&pos,sd_e_h,&sd,&wattrs);
memset(&boxes,0,sizeof(boxes));
memset(&gcd,0,sizeof(gcd));
memset(&label,0,sizeof(label));
i = l = 0;
gcd[i].gd.pos.x = 10; gcd[i].gd.pos.y = 10;
gcd[i].gd.pos.width = SD_Width-20; gcd[i].gd.pos.height = SD_Height-54;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_textarea_wrap;
gcd[i].gd.cid = CID_Script;
gcd[i++].creator = GTextAreaCreate;
hvarray[l][0] = &gcd[i-1]; hvarray[l++][1] = NULL;
#if !defined(_NO_FFSCRIPT) && !defined(_NO_PYTHON)
gcd[i-1].gd.pos.height -= 24;
gcd[i].gd.pos.x = 10; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y+gcd[i-1].gd.pos.height+1;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_cb_on;
gcd[i].gd.cid = CID_Python;
label[i].text = (unichar_t *) _("_Python");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = SD_LangChanged;
gcd[i++].creator = GRadioCreate;
rarray[0] = &gcd[i-1];
gcd[i].gd.pos.x = 70; gcd[i].gd.pos.y = gcd[i-1].gd.pos.y;
gcd[i].gd.flags = gg_visible | gg_enabled; /* disabled if cv!=NULL later */
gcd[i].gd.cid = CID_FF;
label[i].text = (unichar_t *) _("_FF");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = SD_LangChanged;
gcd[i++].creator = GRadioCreate;
rarray[1] = &gcd[i-1]; rarray[2] = GCD_Glue; rarray[3] = NULL;
boxes[2].gd.flags = gg_enabled | gg_visible;
boxes[2].gd.u.boxelements = rarray;
boxes[2].creator = GHBoxCreate;
hvarray[l][0] = &boxes[2]; hvarray[l++][1] = NULL;
#endif
barray[0][0] = barray[1][0] = barray[0][6] = barray[1][6] = GCD_Glue;
barray[0][2] = barray[1][2] = barray[0][4] = barray[1][4] = GCD_Glue;
barray[0][1] = barray[0][5] = GCD_RowSpan;
barray[0][7] = barray[1][7] = barray[2][0] = NULL;
gcd[i].gd.pos.x = 25-3; gcd[i].gd.pos.y = SD_Height-32-3;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[i].text = (unichar_t *) _("_OK");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.mnemonic = 'O';
gcd[i].gd.label = &label[i];
gcd[i].gd.handle_controlevent = SD_OK;
gcd[i].gd.cid = CID_OK;
gcd[i++].creator = GButtonCreate;
barray[1][1] = &gcd[i-1];
gcd[i].gd.pos.x = -25; gcd[i].gd.pos.y = SD_Height-32;
gcd[i].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[i].text = (unichar_t *) _("_Cancel");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.mnemonic = 'C';
gcd[i].gd.handle_controlevent = SD_Cancel;
gcd[i].gd.cid = CID_Cancel;
gcd[i++].creator = GButtonCreate;
barray[1][5] = &gcd[i-1];
gcd[i].gd.pos.x = (SD_Width-GIntGetResource(_NUM_Buttonsize)*100/GIntGetResource(_NUM_ScaleFactor))/2; gcd[i].gd.pos.y = SD_Height-40;
gcd[i].gd.flags = gg_visible | gg_enabled;
label[i].text = (unichar_t *) _("C_all...");
label[i].text_is_1byte = true;
label[i].text_in_resource = true;
gcd[i].gd.label = &label[i];
gcd[i].gd.mnemonic = 'a';
gcd[i].gd.handle_controlevent = SD_Call;
gcd[i].gd.cid = CID_Call;
gcd[i++].creator = GButtonCreate;
barray[0][3] = &gcd[i-1];
#if !defined(_NO_FFSCRIPT)
gcd[i].gd.pos.width = gcd[i].gd.pos.height = 5;
gcd[i].gd.flags = gg_visible | gg_enabled;
gcd[i++].creator = GSpacerCreate;
barray[1][3] = &gcd[i-1];
#else
barray[1][3] = GCD_RowSpan;
#endif
barray[3][0] = NULL;
boxes[3].gd.flags = gg_enabled | gg_visible;
boxes[3].gd.u.boxelements = barray[0];
boxes[3].creator = GHVBoxCreate;
hvarray[l][0] = &boxes[3]; hvarray[l++][1] = NULL;
hvarray[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 = hvarray[0];
boxes[0].creator = GHVGroupCreate;
GGadgetsCreate(gw,boxes);
if ( boxes[2].ret!=NULL )
GHVBoxSetExpandableCol(boxes[2].ret,gb_expandglue);
GHVBoxSetExpandableCol(boxes[3].ret,gb_expandgluesame);
GHVBoxSetExpandableRow(boxes[0].ret,0);
GHVBoxFitWindow(boxes[0].ret);
}
#if !defined(_NO_FFSCRIPT) && !defined(_NO_PYTHON)
GGadgetSetEnabled(GWidgetGetControl(gw,CID_FF),cv==NULL);
#endif
sd.gw = gw;
GDrawSetUserData(gw,&sd);
GWidgetIndicateFocusGadget(GWidgetGetControl(gw,CID_Script));
#if !defined(_NO_FFSCRIPT) && !defined(_NO_PYTHON)
_SD_LangChanged(&sd);
#endif
GDrawSetVisible(gw,true);
while ( !sd.done )
GDrawProcessOneEvent(NULL);
GDrawSetVisible(gw,false);
/* Selection may be out of date, force a refresh */
for ( list = fv_list; list!=NULL; list=(FontView *) list->b.next )
GDrawRequestExpose(list->v,NULL,false);
GDrawSync(NULL);
GDrawProcessPendingEvents(NULL);
GDrawSetUserData(gw,NULL);
}
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 */
}
