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);
}
/* Palettes go invisible when the owner loses focus, and become visible when it gains focus */
GWindow GWidgetCreatePalette(GWindow w, GRect *pos, int (*eh)(GWindow,GEvent *), void *user_data, GWindowAttrs *wattrs) {
GWindow gw;
GPoint pt, base;
GRect newpos, ownerpos, screensize;
struct gtopleveldata *gd, *od;
GWindow root;
if ( !w->is_toplevel )
return( false );
pt.x = pos->x; pt.y = pos->y;
root = GDrawGetRoot(w->display);
GDrawGetSize(w,&ownerpos);
GDrawGetSize(root,&screensize);
GDrawTranslateCoordinates(w,root,&pt);
base.x = base.y = 0;
GDrawTranslateCoordinates(w,root,&base);
if ( pt.x<0 ) {
if ( base.x+ownerpos.width+20+pos->width+20 > screensize.width )
pt.x=0;
else
pt.x = base.x+ownerpos.width+20;
}
if ( pt.y<0 ) pt.y=0;
if ( pt.x+pos->width>root->pos.width )
pt.x = root->pos.width-pos->width;
if ( pt.y+pos->height>root->pos.height )
pt.y = root->pos.height-pos->height;
newpos.x = pt.x; newpos.y = pt.y; newpos.width = pos->width; newpos.height = pos->height;
wattrs->event_masks |= (1<<et_visibility);
if ( !(wattrs->mask&wam_transient)) {
wattrs->mask |= wam_transient;
wattrs->transient = GWidgetGetTopWidget(w);
}
if ( broken_palettes ) {
wattrs->mask |= wam_positioned;
wattrs->positioned = true;
}
gw = GDrawCreateTopWindow(w->display,&newpos,eh,user_data,wattrs);
MakeContainerWidget(gw);
if ( w->widget_data==NULL )
MakeContainerWidget(w);
od = (struct gtopleveldata *) (w->widget_data);
gd = (struct gtopleveldata *) (gw->widget_data);
gd->nextp = od->palettes;
gd->owner = od;
od->palettes = gd;
gd->ispalette = true;
gd->owner_off_x = pos->x; gd->owner_off_y = pos->y;
return( gw );
}
void GWidgetFlowGadgets(GWindow gw) {
GGadget *gadget;
GContainerD *gd = (GContainerD *) (gw->widget_data);
if ( gd==NULL )
return;
gadget = gd->gadgets;
if ( gadget!=NULL ) {
while ( gadget->prev!=NULL )
gadget=gadget->prev;
}
if ( gadget != NULL && GGadgetFillsWindow(gadget)) {
GRect wsize;
GDrawGetSize(gw, &wsize);
/* Make any offset simmetrical */
if (wsize.width >= 2*gadget->r.x) wsize.width -= 2*gadget->r.x;
else wsize.width = 0;
if (wsize.height >= 2*gadget->r.y) wsize.height -= 2*gadget->r.y;
else wsize.height = 0;
GGadgetResize(gadget,wsize.width,wsize.height);
GDrawRequestExpose(gw,NULL,false);
}
}
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 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 void QG_Remetric(QGData *qg) {
GRect size;
GDrawGetSize(qg->v,&size);
qg->vlcnt = size.height/qg->fh;
qg->lcnt = QG_Count(&qg->list);
QG_SetSb(qg);
}
static void RulerPlace(CharView *cv, GEvent *event) {
unichar_t ubuf[80];
int width, x, y;
GRect size;
GPoint pt;
int i,h,w;
GWindowAttrs wattrs;
GRect pos;
FontRequest rq;
int as, ds, ld;
if ( cv->ruler_w==NULL ) {
memset(&wattrs,0,sizeof(wattrs));
wattrs.mask = wam_events|wam_cursor|wam_positioned|wam_nodecor|wam_backcol|wam_bordwidth;
wattrs.event_masks = (1<<et_expose)|(1<<et_resize)|(1<<et_mousedown);
wattrs.cursor = ct_mypointer;
wattrs.background_color = 0xe0e0c0;
wattrs.nodecoration = 1;
wattrs.border_width = 1;
pos.x = pos.y = 0; pos.width=pos.height = 20;
cv->ruler_w = GWidgetCreateTopWindow(NULL,&pos,ruler_e_h,cv,&wattrs);
if ( rvfont==NULL ) {
memset(&rq,0,sizeof(rq));
rq.utf8_family_name = FIXED_UI_FAMILIES;
rq.point_size = -12;
rq.weight = 400;
rvfont = GDrawInstanciateFont(GDrawGetDisplayOfWindow(cv->ruler_w),&rq);
rvfont = GResourceFindFont("CharView.Measure.Font",rvfont);
}
cv->rfont = rvfont;
GDrawFontMetrics(cv->rfont,&as,&ds,&ld);
cv->rfh = as+ds; cv->ras = as;
} else
GDrawRaise(cv->ruler_w);
GDrawSetFont(cv->ruler_w,cv->rfont);
width = h = 0;
for ( i=0; RulerText(cv,ubuf,i); ++i ) {
w = GDrawGetBiTextWidth(cv->ruler_w,ubuf,-1,-1,NULL);
if ( w>width ) width = w;
h += cv->rfh;
}
GDrawGetSize(GDrawGetRoot(NULL),&size);
pt.x = event->u.mouse.x; pt.y = event->u.mouse.y;
GDrawTranslateCoordinates(cv->v,GDrawGetRoot(NULL),&pt);
x = pt.x + infowindowdistance;
if ( x+width > size.width )
x = pt.x - width-infowindowdistance;
y = pt.y -cv->ras-2;
if ( y+h > size.height )
y = pt.y - h - cv->ras -10;
GDrawMoveResize(cv->ruler_w,x,y,width+4,h+4);
}
static int wheel_e_h(GWindow gw, GEvent *event) {
struct gcol_data *d = GDrawGetUserData(gw);
GRect size;
if ( event->type==et_expose ) {
GRect circle;
GDrawGetSize(d->wheelw,&size);
if ( d->wheel==NULL ||
GImageGetHeight(d->wheel)!=size.height ||
GImageGetWidth(d->wheel)!=size.width ) {
if ( d->wheel!=NULL )
GImageDestroy(d->wheel);
d->wheel = ColorWheel(size.width,size.height);
}
GDrawDrawImage(gw,d->wheel,NULL,0,0);
if ( d->col.hsv ) {
double s = sin(d->col.h*3.1415926535897932/180.);
double c = cos(d->col.h*3.1415926535897932/180.);
int y = (int) rint(d->col.s*(size.height-1)*s/2.0) + size.height/2;
int x = (int) rint(d->col.s*(size.width-1)*c/2.0) + size.width/2;
circle.x = x-3; circle.y = y-3;
circle.width = circle.height = 7;
GDrawDrawElipse(gw,&circle,0x000000);
}
} else if ( event->type == et_mousedown ||
(event->type==et_mousemove && d->pressed) ||
event->type==et_mouseup ) {
Color rgb;
struct hslrgba temp;
GDrawGetSize(d->wheelw,&size);
if ( event->u.mouse.y>=0 && event->u.mouse.y<size.height &&
event->u.mouse.x>=0 && event->u.mouse.x<size.width ) {
rgb = GImageGetPixelRGBA(d->wheel,event->u.mouse.x,event->u.mouse.y);
temp.r = ((rgb>>16)&0xff)/255.;
temp.g = ((rgb>>8)&0xff)/255.;
temp.b = ((rgb )&0xff)/255.;
gRGB2HSV((struct hslrgb *) &temp);
d->col.h = temp.h; d->col.s = temp.s;
GCol_ShowTexts(d);
GDrawRequestExpose(d->colw,NULL,false);
GDrawRequestExpose(d->wheelw,NULL,false);
}
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 {
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 SVMakeActive(SearchView *sv,CharView *cv) {
GRect r;
if ( sv==NULL )
return;
sv->cv_srch.inactive = sv->cv_rpl.inactive = true;
cv->inactive = false;
GDrawSetUserData(sv->gw,cv);
GDrawRequestExpose(sv->cv_srch.v,NULL,false);
GDrawRequestExpose(sv->cv_rpl.v,NULL,false);
GDrawGetSize(sv->gw,&r);
r.x = 0;
r.y = sv->mbh;
r.height = sv->fh+10;
GDrawRequestExpose(sv->gw,&r,false);
}
static void GLineFit(GGadget *g) {
int bp = GBoxBorderWidth(g->base,g->box);
if ( g->r.width==0 && !g->vert ) {
GRect size;
GDrawGetSize(g->base,&size);
g->r.width = size.width - g->r.x - GDrawPointsToPixels(g->base,_GGadget_Skip);
}
if ( g->r.height==0 && !g->vert )
g->r.height = bp;
if ( g->r.width==0 && g->vert )
g->r.width = bp;
g->inner = g->r;
g->inner.width = g->inner.height = 0;
}
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 bdfp_e_h(GWindow gw, GEvent *event) {
struct bdf_dlg *bd = GDrawGetUserData(gw);
if ( event->type==et_close ) {
BdfP_DoCancel(bd);
} else if ( event->type == et_expose ) {
GRect r;
GDrawGetSize(bd->v,&r);
GDrawDrawLine(gw,0,r.y-1,bd->width,r.y-1,0x808080);
GDrawDrawLine(gw,0,r.y+r.height,bd->width,r.y+r.height,0x808080);
} else if ( event->type == et_char ) {
return( BdfP_Char(bd,event));
} else if ( event->type == et_resize ) {
BdfP_Resize(bd);
}
return( true );
}
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 KPV_Resize(KPData *kpd) {
GRect size;
GGadget *sb;
GDrawGetSize(kpd->v,&size);
kpd->wh = size.height/kpd->uh;
sb = GWidgetGetControl(kpd->gw,CID_ScrollBar);
GScrollBarSetBounds(sb,0,kpd->kcnt,kpd->wh);
if ( kpd->off_top>kpd->kcnt-kpd->wh )
kpd->off_top = kpd->kcnt-kpd->wh;
if ( kpd->off_top<0 )
kpd->off_top = 0;
GScrollBarSetPos(sb,kpd->off_top);
kpd->vwidth = size.width;
GDrawRequestExpose(kpd->v,NULL,false);
GDrawRequestExpose(kpd->gw,NULL,false);
}
static void AnchorD_Resize(AnchorDlg *a) {
GRect size;
int i, extra;
int factor = a->magfactor;
GDrawGetSize(a->gw,&size);
a->full_width = size.width;
a->full_height = size.height;
a->sb_base = a->full_height - a->sb_height;
if ( a->ctl_len+a->magfactor*a->char_size + 20 < a->full_width ) {
a->sb_width = a->full_width - (a->ctl_len+a->magfactor*a->char_size);
GGadgetResize(a->hsb,a->sb_width, a->sb_height);
GGadgetMove(a->hsb,a->ctl_len+a->magfactor*a->char_size,a->sb_base);
}
AnchorD_SetSB(a);
for ( i=0; i<a->cnt; ++i ) {
if ( i==0 )
a->apmatch[i].xstart = a->ctl_len+a->char_size*factor;
else
a->apmatch[i].xstart = a->apmatch[i-1].xstart +
a->apmatch[i-1].size*factor;
}
if ( i==0 )
a->xlen = 0;
else
a->xlen = a->apmatch[i-1].xstart - a->apmatch[0].xstart +
a->apmatch[i-1].size*factor;
if ( a->ymin>0 && a->sb_base- a->ymax*factor >=0 )
extra = (a->sb_base - a->ymax*factor)/2;
else
extra = (a->sb_base - (a->ymax-a->ymin)*factor)/2;
a->baseline = a->ymax*factor + extra;
GDrawRequestExpose(a->gw,NULL,false);
}
static void CpInfoPlace(CharView *cv, GEvent *event) {
char buf[100];
int line, which;
int width, x, y;
GRect size;
GPoint pt, pt2;
int h,w;
GWindowAttrs wattrs;
GRect pos;
FontRequest rq;
int as, ds, ld;
SplinePoint *sp;
if ( cv->ruler_w==NULL ) {
memset(&wattrs,0,sizeof(wattrs));
wattrs.mask = wam_events|wam_cursor|wam_positioned|wam_nodecor|wam_backcol|wam_bordwidth;
wattrs.event_masks = (1<<et_expose)|(1<<et_resize)|(1<<et_mousedown);
wattrs.cursor = ct_mypointer;
wattrs.background_color = 0xe0e0c0;
wattrs.nodecoration = 1;
wattrs.border_width = 1;
pos.x = pos.y = 0; pos.width=pos.height = 20;
cv->ruler_w = GWidgetCreateTopWindow(NULL,&pos,cpinfo_e_h,cv,&wattrs);
if ( rvfont==NULL ) {
memset(&rq,0,sizeof(rq));
rq.utf8_family_name = FIXED_UI_FAMILIES;
rq.point_size = -12;
rq.weight = 400;
rvfont = GDrawInstanciateFont(GDrawGetDisplayOfWindow(cv->ruler_w),&rq);
rvfont = GResourceFindFont("CharView.Measure.Font",rvfont);
}
cv->rfont = rvfont;
GDrawFontMetrics(cv->rfont,&as,&ds,&ld);
cv->rfh = as+ds; cv->ras = as;
} else
GDrawRaise(cv->ruler_w);
GDrawSetFont(cv->ruler_w,cv->rfont);
h = 0; width = 0;
for ( which = 0; which<2; ++which ) {
for ( line=0; PtInfoText(cv,line,which,buf,sizeof(buf))!=NULL; ++line ) {
w = GDrawGetBiText8Width(cv->ruler_w,buf,-1,-1,NULL);
if ( w>width ) width = w;
h += cv->rfh+1;
}
h += 4;
}
if ( PtInfoText(cv,0,-1,buf,sizeof(buf))!=NULL ) {
w = GDrawGetBiText8Width(cv->ruler_w,buf,-1,-1,NULL);
if ( w>width ) width = w;
h += cv->rfh+1;
}
GDrawGetSize(GDrawGetRoot(NULL),&size);
pt.x = event->u.mouse.x; pt.y = event->u.mouse.y; /* Address of cp */
GDrawTranslateCoordinates(cv->v,GDrawGetRoot(NULL),&pt);
sp = cv->p.sp;
if ( !cv->p.prevcp && !cv->p.nextcp )
sp = cv->active_sp;
if ( sp!=NULL ) {
x = cv->xoff + rint(sp->me.x*cv->scale);
y = -cv->yoff + cv->height - rint(sp->me.y*cv->scale);
if ( x>=0 && y>=0 && x<cv->width && y<cv->height ) {
pt2.x = x; pt2.y = y;
GDrawTranslateCoordinates(cv->v,GDrawGetRoot(NULL),&pt2);
} else
sp = NULL;
}
x = pt.x + infowindowdistance;
y = pt.y - cv->ras-2;
if ( sp!=NULL && x<=pt2.x-4 && x+width>=pt2.x+4 && y<=pt2.y-4 && y+h>=pt2.y+4 )
x = pt2.x + 4;
if ( x+width > size.width ) {
x = pt.x - width-30;
if ( sp!=NULL && x<=pt2.x-4 && x+width>=pt2.x+4 && y<=pt2.y-4 && y+h>=pt2.y+4 )
x = pt2.x - width - 4;
if ( x<0 ) {
x = pt.x + 10;
y = pt.y - h - infowindowdistance;
if ( sp!=NULL && x<=pt2.x-4 && x+width>=pt2.x+4 && y<=pt2.y-4 && y+h>=pt2.y+4 )
y = pt2.y - h - 4;
if ( y<0 )
y = pt.y+infowindowdistance; /* If this doesn't work we have nowhere else to */
/* try so don't check */
}
}
if ( y+h > size.height )
y = pt.y - h - cv->ras - 10;
GDrawMoveResize(cv->ruler_w,x,y,width+4,h+4);
}
void AnchorControl(SplineChar *sc,AnchorPoint *ap,int layer) {
GRect pos;
GWindowAttrs wattrs;
AnchorDlg a;
GWindow gw;
GGadgetCreateData gcd[15], buttonbox, maingcd[3], *hvarray[60], *buttonarray[8];
GGadgetCreateData glyphbox, *glypharray[5];
GTextInfo label[16];
int k, hv;
extern int _GScrollBar_Width;
char buffer[20], xbuf[20], ybuf[20];
GRect boxsize;
memset(&a,0,sizeof(a));
a.sc = sc;
a.ap = ap;
a.apos = ap->me;
a.pixelsize = aa_pixelsize;
a.magfactor = 1;
a.layer = layer;
if ( ap->xadjust.corrections!=NULL ) {
int len = ap->xadjust.last_pixel_size-ap->xadjust.first_pixel_size+1;
a.xadjust = ap->xadjust;
a.xadjust.corrections = malloc(len);
memcpy(a.xadjust.corrections,ap->xadjust.corrections,len);
}
if ( ap->yadjust.corrections!=NULL ) {
int len = ap->yadjust.last_pixel_size-ap->yadjust.first_pixel_size+1;
a.yadjust = ap->yadjust;
a.yadjust.corrections = malloc(len);
memcpy(a.yadjust.corrections,ap->yadjust.corrections,len);
}
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 = true;
wattrs.undercursor = 1;
wattrs.cursor = ct_pointer;
wattrs.utf8_window_title = _("Anchor Control...");
wattrs.is_dlg = true;
GDrawGetSize(GDrawGetRoot(NULL),&pos);
pos.x = pos.y = 0;
pos.height = GDrawPointsToPixels(NULL,210);
if ( pos.height<aa_pixelsize+40+25 )
pos.height = aa_pixelsize+40+25;
pos.width -= 50;
a.gw = gw = GDrawCreateTopWindow(NULL,&pos,anchord_e_h,&a,&wattrs);
a.ctl_len = GDrawPointsToPixels(gw,140);
a.sb_height = GDrawPointsToPixels(gw,_GScrollBar_Width);
a.sb_base = pos.height - a.sb_height;
memset(maingcd,0,sizeof(maingcd));
memset(&buttonbox,0,sizeof(buttonbox));
memset(&glyphbox,0,sizeof(glyphbox));
memset(gcd,0,sizeof(gcd));
memset(label,0,sizeof(label));
k = hv = 0;
gcd[k].gd.flags = gg_visible|gg_enabled ;
gcd[k].gd.cid = CID_Glyph;
gcd[k].gd.handle_controlevent = AnchorD_GlyphChanged;
gcd[k++].creator = GListButtonCreate;
glypharray[0] = GCD_Glue; glypharray[1] = &gcd[k-1]; glypharray[2] = GCD_Glue; glypharray[3] = NULL;
glyphbox.gd.flags = gg_enabled|gg_visible;
glyphbox.gd.u.boxelements = glypharray;
glyphbox.creator = GHBoxCreate;
hvarray[hv++] = &glyphbox; hvarray[hv++] = GCD_ColSpan; hvarray[hv++] = GCD_ColSpan;
hvarray[hv++] = GCD_ColSpan; hvarray[hv++] = GCD_Glue; hvarray[hv++] = NULL;
label[k].text = (unichar_t *) _("_Size:");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 5; gcd[k].gd.pos.y = 9;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup;
gcd[k++].creator = GLabelCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan;
sprintf( buffer, "%d", a.pixelsize );
label[k].text = (unichar_t *) buffer;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 40; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4;
gcd[k].gd.pos.width = 60;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k].gd.cid = CID_DisplaySize;
gcd[k].gd.handle_controlevent = AnchorD_DisplaySizeChanged;
gcd[k].gd.popup_msg = gcd[k-1].gd.popup_msg = (unichar_t *)
_("The size at which the current glyph is rasterized.\nFor small pixelsize you may want to use the magnification\nfactor below to get a clearer view.\n\nThe pulldown list contains the pixelsizes at which there\nare device table corrections.");
gcd[k++].creator = GListFieldCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan; hvarray[hv++] = GCD_Glue; hvarray[hv++] = NULL;
/* GT: Short for: Magnification */
label[k].text = (unichar_t *) _("Mag:");
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-2].gd.pos.y+26;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k++].creator = GLabelCreate;
hvarray[hv++] = GCD_HPad10; hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan;
gcd[k].gd.pos.x = 45; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k].gd.cid = CID_Mag;
gcd[k].gd.u.list = magnifications;
gcd[k].gd.handle_controlevent = AnchorD_MagnificationChanged;
gcd[k].gd.popup_msg = gcd[k-1].gd.popup_msg = (unichar_t *)
_("The glyph is rasterized at the size above, but it\nmay be difficult to see the alignment errors\nthat can happen at small pixelsizes. This allows\nyou to expand each pixel to show potential problems\nbetter.");
gcd[k++].creator = GListButtonCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_Glue; hvarray[hv++] = 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 = 5; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y+30;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k++].creator = GLabelCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan;
sprintf( xbuf, "%d", (int) rint(ap->me.x) );
label[k].text = (unichar_t *) xbuf;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 40; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4;
gcd[k].gd.pos.width = 60;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k].gd.cid = CID_X;
gcd[k].gd.handle_controlevent = AnchorD_PositionChanged;
gcd[k].gd.popup_msg = gcd[k-1].gd.popup_msg = (unichar_t *)
_("The X coordinate of the anchor point in this glyph");
gcd[k++].creator = GNumericFieldCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan; hvarray[hv++] = GCD_Glue; hvarray[hv++] = NULL;
/* GT: Short for Correction */
label[k].text = (unichar_t *) _("Cor:");
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+30;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k].gd.popup_msg = (unichar_t *) _("Correction in pixels to the horizontal positioning of this anchor point\nwhen rasterizing at the given pixelsize.\n(Lives in a Device Table)");
gcd[k++].creator = GLabelCreate;
hvarray[hv++] = GCD_HPad10; hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan;
label[k].text = (unichar_t *) "0";
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 45; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4;
gcd[k].gd.pos.width = 60;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k].gd.cid = CID_XCor;
gcd[k].gd.handle_controlevent = AnchorD_CorrectionChanged;
gcd[k].gd.popup_msg = gcd[k-1].gd.popup_msg = (unichar_t *)
_("This is the number of pixels by which the anchor\nshould be moved horizontally when the glyph is\nrasterized at the above size. This information\nis part of the device table for this anchor.\nDevice tables are particularly important at small\npixelsizes where rounding errors will have a\nproportionally greater effect.");
gcd[k++].creator = GNumericFieldCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_Glue; hvarray[hv++] = 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 = 5; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y+30;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k++].creator = GLabelCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan;
sprintf( ybuf, "%d", (int) rint(ap->me.y) );
label[k].text = (unichar_t *) ybuf;
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 40; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4;
gcd[k].gd.pos.width = 60;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k].gd.cid = CID_Y;
gcd[k].gd.handle_controlevent = AnchorD_PositionChanged;
gcd[k].gd.popup_msg = gcd[k-1].gd.popup_msg = (unichar_t *)
_("The Y coordinate of the anchor point in this glyph");
gcd[k++].creator = GNumericFieldCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan; hvarray[hv++] = GCD_Glue; hvarray[hv++] = NULL;
/* GT: Short for Correction */
label[k].text = (unichar_t *) _("Cor:");
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+30;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k].gd.popup_msg = (unichar_t *) _("Correction in pixels to the horizontal positioning of this anchor point\nwhen rasterizing at the given pixelsize.\n(Lives in a Device Table)");
gcd[k++].creator = GLabelCreate;
hvarray[hv++] = GCD_HPad10; hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_ColSpan;
label[k].text = (unichar_t *) "0";
label[k].text_is_1byte = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.x = 45; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y-4;
gcd[k].gd.pos.width = 60;
gcd[k].gd.flags = gg_visible|gg_enabled | gg_utf8_popup ;
gcd[k].gd.cid = CID_YCor;
gcd[k].gd.handle_controlevent = AnchorD_CorrectionChanged;
gcd[k].gd.popup_msg = gcd[k-1].gd.popup_msg = (unichar_t *)
_("This is the number of pixels by which the anchor\nshould be moved vertically when the glyph is\nrasterized at the above size. This information\nis part of the device table for this anchor.\nDevice tables are particularly important at small\npixelsizes where rounding errors will have a\nproportionally greater effect.");
gcd[k++].creator = GNumericFieldCreate;
hvarray[hv++] = &gcd[k-1]; hvarray[hv++] = GCD_Glue; hvarray[hv++] = NULL;
hvarray[hv++] = GCD_Glue; hvarray[hv++] = GCD_Glue; hvarray[hv++] = GCD_Glue;
hvarray[hv++] = GCD_Glue; hvarray[hv++] = GCD_Glue; hvarray[hv++] = NULL;
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.pos.x = 5; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y+40;
gcd[k].gd.pos.width = -1;
gcd[k].gd.flags = gg_visible|gg_enabled|gg_but_default;
gcd[k].gd.handle_controlevent = AnchorD_OK;
gcd[k++].creator = GButtonCreate;
buttonarray[0] = GCD_Glue; buttonarray[1] = &gcd[k-1]; buttonarray[2] = GCD_Glue;
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.pos.x = 80; gcd[k].gd.pos.y = gcd[k-1].gd.pos.y+3;
gcd[k].gd.pos.width = -1;
gcd[k].gd.flags = gg_visible|gg_enabled|gg_but_cancel;
gcd[k].gd.handle_controlevent = AnchorD_Cancel;
gcd[k++].creator = GButtonCreate;
buttonarray[3] = GCD_Glue; buttonarray[4] = &gcd[k-1]; buttonarray[5] = GCD_Glue;
buttonarray[6] = NULL;
buttonbox.gd.flags = gg_enabled|gg_visible;
buttonbox.gd.u.boxelements = buttonarray;
buttonbox.creator = GHBoxCreate;
hvarray[hv++] = &buttonbox; hvarray[hv++] = GCD_ColSpan; hvarray[hv++] = GCD_ColSpan;
hvarray[hv++] = GCD_ColSpan; hvarray[hv++] = GCD_Glue; hvarray[hv++] = NULL;
hvarray[hv++] = NULL;
maingcd[0].gd.pos.x = maingcd[0].gd.pos.y = 5;
maingcd[0].gd.pos.height = pos.height - 10;
/* maingcd[0].gd.pos.width = a.ctl_len - 10; */
maingcd[0].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels;
maingcd[0].gd.u.boxelements = hvarray;
maingcd[0].creator = GHVBoxCreate;
maingcd[1].gd.pos.x = 300;
maingcd[1].gd.pos.y = pos.height-a.sb_height;
maingcd[1].gd.pos.height = a.sb_height;
maingcd[1].gd.pos.width = pos.width-300;
maingcd[1].gd.flags = gg_visible|gg_enabled|gg_pos_in_pixels;
maingcd[1].creator = GScrollBarCreate;
GGadgetsCreate(a.gw,maingcd);
GGadgetSetList(gcd[0].ret,AnchorD_GlyphsInClass(&a),false);
GTextInfoListFree(gcd[0].gd.u.list);
GHVBoxSetExpandableRow(maingcd[0].ret,gb_expandglue);
GHVBoxSetExpandableCol(maingcd[0].ret,4);
GHVBoxSetExpandableCol(buttonbox.ret,gb_expandgluesame);
GHVBoxSetExpandableCol(glyphbox.ret,gb_expandglue);
GGadgetGetDesiredSize(maingcd[0].ret,&boxsize,NULL);
a.ctl_len = boxsize.width + 10;
a.hsb = maingcd[1].ret;
AnchorD_FindComplements(&a);
AnchorD_SetDevTabs(&a);
AnchorD_ChangeSize(&a);
AnchorD_SetTitle(&a);
GDrawSetVisible(a.gw,true);
while ( !a.done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(a.gw);
AnchorD_FreeAll(&a);
}
