static void BdfP_Resize(struct bdf_dlg *bd) {
extern int _GScrollBar_Width;
int sbwidth = GDrawPointsToPixels(bd->gw,_GScrollBar_Width);
GRect size, pos;
static int cids[] = { CID_Delete, CID_DefAll, CID_DefCur, CID_Up,
CID_Down, CID_OK, CID_Cancel, 0 };
int i;
GDrawGetSize(bd->gw,&size);
GDrawGetSize(bd->v,&pos);
if ( size.width!=bd->width || size.height!=bd->height ) {
int yoff = size.height-bd->height;
int xoff = size.width-bd->width;
bd->width = size.width; bd->height = size.height;
bd->vwidth += xoff; bd->vheight += yoff;
GDrawResize(bd->v,bd->vwidth,bd->vheight);
GGadgetMove(bd->vsb,size.width-sbwidth,pos.y-1);
GGadgetResize(bd->vsb,sbwidth,bd->vheight+2);
GGadgetGetSize(bd->tf,&pos);
GGadgetResize(bd->tf,pos.width+xoff,pos.height);
for ( i=0; cids[i]!=0; ++i ) {
GGadgetGetSize(GWidgetGetControl(bd->gw,cids[i]),&pos);
GGadgetMove(GWidgetGetControl(bd->gw,cids[i]),pos.x,pos.y+yoff);
}
}
BdfP_RefigureScrollbar(bd);
GDrawRequestExpose(bd->v,NULL,false);
GDrawRequestExpose(bd->gw,NULL,true);
}
static void SVResize(SearchView *sv, GEvent *event) {
int width, height;
if ( !event->u.resize.sized )
return;
GGadgetMove(GWidgetGetControl(sv->gw,CID_TopBox),4,4);
GGadgetResize(GWidgetGetControl(sv->gw,CID_TopBox),
event->u.resize.size.width-8,
event->u.resize.size.height-12);
width = (event->u.resize.size.width-40)/2;
height = (event->u.resize.size.height-sv->cv_y-sv->button_height-8);
if ( width<70 || height<80 ) {
if ( width<70 ) width = 70;
width = 2*width+40;
if ( height<80 ) height = 80;
height += sv->cv_y+sv->button_height+8;
GDrawResize(sv->gw,width,height);
return;
}
if ( width!=sv->cv_width || height!=sv->cv_height ) {
GDrawResize(sv->cv_srch.gw,width,height);
GDrawResize(sv->cv_rpl.gw,width,height);
sv->cv_width = width; sv->cv_height = height;
sv->rpl_x = 30+width;
GDrawMove(sv->cv_rpl.gw,sv->rpl_x,sv->cv_y);
}
#if 0
GGadgetGetSize(GWidgetGetControl(sv->gw,CID_Allow),&size);
yoff = event->u.resize.size.height-sv->button_height-size.y;
if ( yoff!=0 ) {
for ( i=CID_Allow; i<=CID_Cancel; ++i ) {
GGadgetGetSize(GWidgetGetControl(sv->gw,i),&size);
GGadgetMove(GWidgetGetControl(sv->gw,i),size.x,size.y+yoff);
}
}
xoff = (event->u.resize.size.width - sv->button_width)/2;
GGadgetGetSize(GWidgetGetControl(sv->gw,CID_Find),&size);
xoff -= size.x;
if ( xoff!=0 ) {
for ( i=CID_Find; i<=CID_Cancel; ++i ) {
GGadgetGetSize(GWidgetGetControl(sv->gw,i),&size);
GGadgetMove(GWidgetGetControl(sv->gw,i),size.x+xoff,size.y);
}
}
#endif
GDrawSync(NULL);
GDrawProcessPendingEvents(NULL);
GDrawRequestExpose(sv->gw,NULL,false);
}
static int e_h(GWindow gw, GEvent *event) {
if ( event->type==et_close ) {
struct gfc_data *d = GDrawGetUserData(gw);
d->done = true;
} else if ( event->type == et_map ) {
/* Above palettes */
GDrawRaise(gw);
} else if ( event->type == et_char ) {
return( false );
} else if ( event->type == et_mousemove ||
(event->type==et_mousedown && event->u.mouse.button==3 )) {
struct gfc_data *d = GDrawGetUserData(gw);
if ( !WithinList(d,event) )
GFileChooserPopupCheck(d->gfc,event);
} else if (( event->type==et_mouseup || event->type==et_mousedown ) &&
(event->u.mouse.button>=4 && event->u.mouse.button<=7) ) {
struct gfc_data *d = GDrawGetUserData(gw);
return( GGadgetDispatchEvent((GGadget *) (d->gfc),event));
} else if ( event->type == et_resize ) {
GRect r, size;
struct gfc_data *d = GDrawGetUserData(gw);
if ( d->gfc!=NULL ) {
GDrawGetSize(gw,&size);
GGadgetGetSize(d->gfc,&r);
GGadgetResize(d->gfc,size.width-2*r.x,r.height);
}
}
return( event->type!=et_char );
}
static int kpd_e_h(GWindow gw, GEvent *event) {
if ( event->type==et_close ) {
KPData *kpd = GDrawGetUserData(gw);
kpd->done = true;
} else if ( event->type == et_mousemove ) {
kpdpopup(GDrawGetUserData(gw));
} else if ( event->type == et_expose ) {
KPData *kpd = GDrawGetUserData(gw);
GRect size, sbsize;
GDrawGetSize(kpd->v,&size);
GGadgetGetSize(GWidgetGetControl(kpd->gw,CID_ScrollBar),&sbsize);
GDrawSetLineWidth(gw,0);
GDrawDrawLine(gw,size.x,size.y-1,sbsize.x+sbsize.width-1,size.y-1,0x000000);
GDrawDrawLine(gw,size.x,size.y+size.height,sbsize.x+sbsize.width-1,size.y+size.height,0x000000);
GDrawDrawLine(gw,size.x-1,size.y-1,size.x-1,size.y+size.height,0x000000);
} else if ( event->type == et_char ) {
if ( event->u.chr.keysym == GK_F1 || event->u.chr.keysym == GK_Help ) {
help("kernpairs.html");
return( true );
}
if ( event->u.chr.chars[0]!='\0' && event->u.chr.chars[1]=='\0' ) {
enum sortby sort = GGadgetGetFirstListSelectedItem(GWidgetGetControl(gw,CID_SortBy));
KPData *kpd = GDrawGetUserData(gw);
if ( sort!=sb_kern ) {
KPScrollTo(kpd,event->u.chr.chars[0],sort);
return( true );
} else
GDrawBeep(NULL);
}
return( false );
} else if ( event->type == et_resize && event->u.resize.sized ) {
KP_Resize((KPData *) GDrawGetUserData(gw) );
}
return( true );
}
static int WithinList(struct gfc_data *d,GEvent *event) {
GRect size;
GGadget *list;
int32 pos;
unichar_t *ufile;
char *file, **fontnames;
int cnt, len;
unichar_t *msg;
if ( event->type!=et_mousemove )
return( false );
GFileChooserGetChildren(d->gfc,NULL, &list, NULL);
if ( list==NULL )
return( false );
GGadgetGetSize(list,&size);
if ( event->u.mouse.x < size.x || event->u.mouse.y <size.y ||
event->u.mouse.x >= size.x+size.width ||
event->u.mouse.y >= size.y+size.height )
return( false );
pos = GListIndexFromY(list,event->u.mouse.y);
if ( pos == d->filename_popup_pos )
return( pos!=-1 );
if ( pos==-1 || GFileChooserPosIsDir(d->gfc,pos)) {
d->filename_popup_pos = -1;
return( pos!=-1 );
}
ufile = GFileChooserFileNameOfPos(d->gfc,pos);
if ( ufile==NULL )
return( true );
file = u2def_copy(ufile);
fontnames = GetFontNames(file);
if ( fontnames==NULL || fontnames[0]==NULL )
msg = uc_copy( "???" );
else {
len = 0;
for ( cnt=0; fontnames[cnt]!=NULL; ++cnt )
len += strlen(fontnames[cnt])+1;
msg = galloc((len+2)*sizeof(unichar_t));
len = 0;
for ( cnt=0; fontnames[cnt]!=NULL; ++cnt ) {
uc_strcpy(msg+len,fontnames[cnt]);
len += strlen(fontnames[cnt]);
msg[len++] = '\n';
}
msg[len-1] = '\0';
}
GGadgetPreparePopup(GGadgetGetWindow(d->gfc),msg);
free(file);
free(d->lastpopupfontname);
d->lastpopupfontname = msg;
return( true );
}
static void _BdfP_Up(struct bdf_dlg *bd) {
struct bdf_dlg_font *cur = bd->cur;
BDFFont *bdf = cur->bdf;
GRect r;
BDFProperties prop;
if ( cur->sel_prop<1 || cur->sel_prop>=bdf->prop_cnt )
return;
prop = bdf->props[cur->sel_prop];
bdf->props[cur->sel_prop] = bdf->props[cur->sel_prop-1];
bdf->props[cur->sel_prop-1] = prop;
--cur->sel_prop;
GGadgetGetSize(bd->tf,&r);
GGadgetMove(bd->tf,r.x,r.y-(bd->fh+1));
BdfP_EnableButtons(bd);
GDrawRequestExpose(bd->v,NULL,false);
}
static int warnings_e_h(GWindow gw, GEvent *event) {
if (( event->type==et_mouseup || event->type==et_mousedown ) &&
(event->u.mouse.button>=4 && event->u.mouse.button<=7) ) {
return( GGadgetDispatchEvent(errdata.vsb,event));
}
switch ( event->type ) {
case et_char:
return( ErrChar(event));
break;
case et_expose:
break;
case et_resize: {
GRect size, sbsize;
GDrawGetSize(gw,&size);
GGadgetGetSize(errdata.vsb,&sbsize);
GGadgetMove(errdata.vsb,size.width-sbsize.width,0);
GGadgetResize(errdata.vsb,sbsize.width,size.height);
GDrawResize(errdata.v,size.width-sbsize.width,size.height);
errdata.linecnt = size.height/errdata.fh;
GScrollBarSetBounds(errdata.vsb,0,errdata.cnt,errdata.linecnt);
if ( errdata.offtop + errdata.linecnt > errdata.cnt ) {
errdata.offtop = errdata.cnt-errdata.linecnt;
if ( errdata.offtop < 0 ) errdata.offtop = 0;
GScrollBarSetPos(errdata.vsb,errdata.offtop);
}
GDrawRequestExpose(errdata.v,NULL,false);
}
break;
case et_controlevent:
switch ( event->u.control.subtype ) {
case et_scrollbarchange:
ErrScroll(&event->u.control.u.sb);
break;
}
break;
case et_close:
ErrHide();
break;
case et_create:
break;
case et_destroy:
break;
}
return( true );
}
static void BdfP_VScroll(struct bdf_dlg *bd,struct sbevent *sb) {
int newpos = bd->cur->top_prop;
int page = bd->vheight/(bd->fh+1);
switch( sb->type ) {
case et_sb_top:
newpos = 0;
break;
case et_sb_uppage:
newpos -= 9*page/10;
break;
case et_sb_up:
newpos--;
break;
case et_sb_down:
newpos++;
break;
case et_sb_downpage:
newpos += 9*page/10;
break;
case et_sb_bottom:
newpos = bd->cur->bdf->prop_cnt+1;
break;
case et_sb_thumb:
case et_sb_thumbrelease:
newpos = sb->pos;
break;
}
if ( newpos + page > bd->cur->bdf->prop_cnt+1 )
newpos = bd->cur->bdf->prop_cnt+1 - page;
if ( newpos<0 )
newpos = 0;
if ( newpos!=bd->cur->top_prop ) {
int diff = (newpos-bd->cur->top_prop)*(bd->fh+1);
GRect r;
bd->cur->top_prop = newpos;
GScrollBarSetPos(bd->vsb,newpos);
GGadgetGetSize(bd->tf,&r);
GGadgetMove(bd->tf,r.x,r.y+diff);
r.x = 0; r.y = 0; r.width = bd->vwidth; r.height = (bd->vheight/(bd->fh+1))*(bd->fh+1);
GDrawScroll(bd->v,&r,0,diff);
}
}
static int sd_e_h(GWindow gw, GEvent *event) {
struct sd_data *sd = GDrawGetUserData(gw);
if ( sd==NULL )
return( true );
if ( event->type==et_close ) {
SD_DoCancel( sd );
} else if ( event->type==et_char ) {
if ( event->u.chr.keysym == GK_F1 || event->u.chr.keysym == GK_Help ) {
help("scripting.html");
return( true );
}
return( false );
} else if ( event->type == et_map ) {
/* Above palettes */
GDrawRaise(gw);
} else if ( event->type == et_resize ) {
#if 0
GRect newsize, gpos;
int space;
GDrawGetSize(gw,&newsize);
GGadgetGetSize(GWidgetGetControl(gw,CID_Script),&gpos);
space = sd->oldh - gpos.height;
GGadgetResize(GWidgetGetControl(gw,CID_Box),newsize.width-4,newsize.height-4);
GGadgetResize(GWidgetGetControl(gw,CID_Script),newsize.width-2*gpos.x,newsize.height-space);
#if !defined(_NO_FFSCRIPT) && !defined(_NO_PYTHON)
GGadgetGetSize(GWidgetGetControl(gw,CID_Python),&gpos);
space = sd->oldh - gpos.y;
GGadgetMove(GWidgetGetControl(gw,CID_Python),gpos.x,newsize.height-space);
GGadgetGetSize(GWidgetGetControl(gw,CID_FF),&gpos);
GGadgetMove(GWidgetGetControl(gw,CID_FF),gpos.x,newsize.height-space);
#endif
GGadgetGetSize(GWidgetGetControl(gw,CID_Call),&gpos);
space = sd->oldh - gpos.y;
GGadgetMove(GWidgetGetControl(gw,CID_Call),gpos.x,newsize.height-space);
GGadgetGetSize(GWidgetGetControl(gw,CID_OK),&gpos);
space = sd->oldh - gpos.y;
GGadgetMove(GWidgetGetControl(gw,CID_OK),gpos.x,newsize.height-space);
GGadgetGetSize(GWidgetGetControl(gw,CID_Cancel),&gpos);
space = sd->oldh - gpos.y;
GGadgetMove(GWidgetGetControl(gw,CID_Cancel),gpos.x,newsize.height-space);
sd->oldh = newsize.height;
#endif
GDrawRequestExpose(gw,NULL,false);
}
return( true );
}
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 );
}
static void GroupResize(struct groupdlg *grp,GEvent *event) {
GRect size, wsize;
int lcnt, offy;
int sbsize = GDrawPointsToPixels(grp->gw,_GScrollBar_Width);
GDrawGetSize(grp->gw,&size);
lcnt = (size.height-grp->bmargin)/grp->fh;
GGadgetResize(grp->vsb,sbsize,lcnt*grp->fh);
GGadgetMove(grp->vsb,size.width-sbsize,0);
GGadgetResize(grp->hsb,size.width-sbsize,sbsize);
GGadgetMove(grp->hsb,0,lcnt*grp->fh);
GDrawResize(grp->v,size.width-sbsize,lcnt*grp->fh);
grp->page_width = size.width-sbsize;
grp->lines_page = lcnt;
GScrollBarSetBounds(grp->vsb,0,grp->open_cnt,grp->lines_page);
GScrollBarSetBounds(grp->hsb,0,grp->maxl,grp->page_width);
GGadgetGetSize(grp->cancel,&wsize);
offy = size.height-wsize.height-6 - wsize.y;
GGadgetMove(grp->cancel,size.width-wsize.width-30, wsize.y+offy);
GGadgetMove(grp->ok , 30-3,wsize.y+offy-3);
if ( grp->newsub!=NULL ) {
GGadgetGetSize(grp->newsub,&wsize);
GGadgetMove(grp->newsub,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->delete,&wsize);
GGadgetMove(grp->delete,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->line1,&wsize);
GGadgetMove(grp->line1,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->gpnamelab,&wsize);
GGadgetMove(grp->gpnamelab,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->gpname,&wsize);
GGadgetMove(grp->gpname,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->glyphslab,&wsize);
GGadgetMove(grp->glyphslab,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->glyphs,&wsize);
GGadgetMove(grp->glyphs,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->idlab,&wsize);
GGadgetMove(grp->idlab,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->idname,&wsize);
GGadgetMove(grp->idname,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->iduni,&wsize);
GGadgetMove(grp->iduni,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->set,&wsize);
GGadgetMove(grp->set,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->select,&wsize);
GGadgetMove(grp->select,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->unique,&wsize);
GGadgetMove(grp->unique,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->colour,&wsize);
GGadgetMove(grp->colour,wsize.x,wsize.y+offy);
GGadgetGetSize(grp->line2,&wsize);
GGadgetMove(grp->line2,wsize.x,wsize.y+offy);
} else {
void SFShowKernPairs(SplineFont *sf,SplineChar *sc,AnchorClass *ac,int layer) {
KPData kpd;
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[9], boxes[6], *hvarray[3][3], *harray[3], *barray[10], *varray[5];
GTextInfo label[9];
FontRequest rq;
int as, ds, ld,i;
static int done=false;
static GFont *font=NULL;
memset(&kpd,0,sizeof(kpd));
kpd.sf = sf;
kpd.sc = sc;
kpd.ac = ac;
kpd.layer = layer;
kpd.first = true;
kpd.last_index = kpd.selected = -1;
if ( ac==NULL )
KPBuildKernList(&kpd);
else
KPBuildAnchorList(&kpd);
if ( kpd.kcnt==0 )
return;
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 = ac==NULL?_("Kern Pairs"):_("Anchored Pairs");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(200);
pos.height = GDrawPointsToPixels(NULL,500);
kpd.gw = gw = GDrawCreateTopWindow(NULL,&pos,kpd_e_h,&kpd,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
label[0].text = (unichar_t *) _("_Size:");
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 = 5+6;
gcd[0].gd.flags = gg_enabled|gg_visible;
gcd[0].creator = GLabelCreate;
hvarray[0][0] = &gcd[0];
gcd[1].gd.label = &sizes[1]; gcd[1].gd.label->selected = true;
gcd[1].gd.pos.x = 50; gcd[1].gd.pos.y = 5;
gcd[1].gd.flags = gg_enabled|gg_visible;
gcd[1].gd.cid = CID_Size;
gcd[1].gd.u.list = sizes;
gcd[1].gd.handle_controlevent = KP_ChangeSize;
gcd[1].creator = GListButtonCreate;
hvarray[0][1] = &gcd[1]; hvarray[0][2] = NULL;
label[2].text = (unichar_t *) _("Sort By:");
label[2].text_is_1byte = true;
gcd[2].gd.label = &label[2];
gcd[2].gd.pos.x = gcd[0].gd.pos.x; gcd[2].gd.pos.y = gcd[0].gd.pos.y+25;
gcd[2].gd.flags = gg_enabled|gg_visible;
gcd[2].creator = GLabelCreate;
hvarray[1][0] = &gcd[2];
if ( !done ) {
done = true;
for ( i=0; sortby[i].text!=NULL; ++i )
sortby[i].text = (unichar_t *) _((char *) sortby[i].text);
}
gcd[3].gd.label = &sortby[0]; gcd[3].gd.label->selected = true;
gcd[3].gd.pos.x = 50; gcd[3].gd.pos.y = gcd[1].gd.pos.y+25;
gcd[3].gd.flags = gg_enabled|gg_visible;
gcd[3].gd.cid = CID_SortBy;
gcd[3].gd.u.list = sortby;
gcd[3].gd.handle_controlevent = KP_ChangeSort;
gcd[3].creator = GListButtonCreate;
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] = &boxes[2];
gcd[4].gd.pos.width = 40;
gcd[4].gd.pos.height = 250;
gcd[4].gd.flags = gg_visible | gg_enabled;
gcd[4].gd.u.drawable_e_h = kpdv_e_h;
gcd[4].creator = GDrawableCreate;
gcd[5].gd.flags = gg_enabled|gg_visible|gg_sb_vert;
gcd[5].gd.cid = CID_ScrollBar;
gcd[5].gd.handle_controlevent = KP_Scrolled;
gcd[5].creator = GScrollBarCreate;
harray[0] = &gcd[4]; harray[1] = &gcd[5]; harray[2] = NULL;
boxes[3].gd.flags = gg_enabled|gg_visible;
boxes[3].gd.u.boxelements = harray;
boxes[3].creator = GHBoxCreate;
varray[1] = &boxes[3];
gcd[6].gd.pos.x = 20-3; gcd[6].gd.pos.y = 17+37;
gcd[6].gd.pos.width = -1; gcd[6].gd.pos.height = 0;
gcd[6].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[6].text = (unichar_t *) _("_OK");
label[6].text_is_1byte = true;
label[6].text_in_resource = true;
gcd[6].gd.label = &label[6];
gcd[6].gd.cid = CID_OK;
gcd[6].gd.handle_controlevent = KP_OK;
gcd[6].creator = GButtonCreate;
gcd[7].gd.pos.x = -20; gcd[7].gd.pos.y = gcd[6].gd.pos.y+3;
gcd[7].gd.pos.width = -1; gcd[7].gd.pos.height = 0;
gcd[7].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[7].text = (unichar_t *) _("_Cancel");
label[7].text_is_1byte = true;
label[7].text_in_resource = true;
gcd[7].gd.label = &label[7];
gcd[7].gd.cid = CID_Cancel;
gcd[7].gd.handle_controlevent = KP_Cancel;
gcd[7].creator = GButtonCreate;
barray[0] = GCD_Glue; barray[1] = &gcd[6]; barray[2] = GCD_Glue;
barray[3] = GCD_Glue; barray[4] = &gcd[7]; barray[5] = GCD_Glue; barray[6] = NULL;
boxes[4].gd.flags = gg_enabled|gg_visible;
boxes[4].gd.u.boxelements = barray;
boxes[4].creator = GHBoxCreate;
varray[2] = &boxes[4];
varray[3] = NULL;
boxes[0].gd.flags = gg_enabled|gg_visible;
boxes[0].gd.u.boxelements = varray;
boxes[0].creator = GVBoxCreate;
GGadgetsCreate(gw,boxes);
GHVBoxSetExpandableRow(boxes[0].ret,1);
GHVBoxSetExpandableCol(boxes[3].ret,0);
GHVBoxSetExpandableCol(boxes[4].ret,gb_expandgluesame);
GHVBoxSetPadding(boxes[0].ret,0,2);
GHVBoxSetPadding(boxes[3].ret,0,0);
kpd.v = GDrawableGetWindow(gcd[4].ret);;
GGadgetGetSize(gcd[4].ret,&pos);
kpd.sb_width = pos.width;
GGadgetGetSize(gcd[3].ret,&pos);
kpd.header_height = pos.y+pos.height+4;
kpd.bdf = SplineFontPieceMeal(kpd.sf,kpd.layer,(intpt) (gcd[1].gd.label->userdata),72,true,NULL);
if ( font==NULL ) {
memset(&rq,'\0',sizeof(rq));
rq.utf8_family_name = SANS_UI_FAMILIES;
rq.point_size = -12;
rq.weight = 400;
font = GDrawInstanciateFont(GDrawGetDisplayOfWindow(gw),&rq);
font = GResourceFindFont("Combinations.Font",font);
}
kpd.font = font;
GDrawFontMetrics(kpd.font,&as,&ds,&ld);
kpd.fh = as+ds; kpd.as = as;
kpd.uh = (4*kpd.bdf->pixelsize/3)+kpd.fh+6;
kpd.vpad = kpd.bdf->pixelsize/5 + 3;
GHVBoxFitWindow(boxes[0].ret);
GDrawSetVisible(kpd.v,true);
GDrawSetVisible(kpd.gw,true);
while ( !kpd.done )
GDrawProcessOneEvent(NULL);
free( kpd.kerns );
GDrawDestroyWindow(gw);
}
