static void Do_OKRegen(ReviewHintData *hd) {
SplineChar *sc = hd->cv->b.sc;
StemInfo *curh = sc->hstem, *curv = sc->vstem;
int do_regen = GGadgetIsChecked(GWidgetGetControl(hd->gw,CID_RegenHM));
/* We go backwards here, but not for long. The point is to go back to */
/* the original hint state so we can preserve it, now that we know we*/
/* are going to modify it */
sc->hstem = hd->oldh; sc->vstem = hd->oldv;
SCPreserveHints(sc,CVLayer((CharViewBase *) hd->cv));
sc->hstem = curh; sc->vstem = curv;
StemInfosFree(hd->oldh);
StemInfosFree(hd->oldv);
if ( hd->lastactive!=NULL )
hd->lastactive->active = false;
if ( hd->changed ) {
SCClearHintMasks(hd->cv->b.sc,CVLayer((CharViewBase *) (hd->cv)),true);
if ( do_regen )
SCFigureHintMasks(hd->cv->b.sc,CVLayer((CharViewBase *) (hd->cv)));
}
/* Everything else got done as we went along... */
SCOutOfDateBackground(hd->cv->b.sc);
SCUpdateAll(hd->cv->b.sc);
SCHintsChanged(hd->cv->b.sc);
hd->done = true;
}
void CVGridFitChar(CharView *cv) {
void *single_glyph_context;
SplineFont *sf = cv->b.sc->parent;
int layer = CVLayer((CharViewBase *) cv);
SplinePointListsFree(cv->b.gridfit); cv->b.gridfit = NULL;
FreeType_FreeRaster(cv->raster); cv->raster = NULL;
single_glyph_context = _FreeTypeFontContext(sf,cv->b.sc,NULL,layer,
sf->layers[layer].order2?ff_ttf:ff_otf,0,NULL);
if ( single_glyph_context==NULL ) {
LogError(_("Freetype rasterization failed.\n") );
return;
}
if ( cv->b.sc->layers[layer].refs!=NULL )
SCNumberPoints(cv->b.sc,layer);
cv->raster = FreeType_GetRaster(single_glyph_context,cv->b.sc->orig_pos,
cv->ft_pointsizey, cv->ft_pointsizex, cv->ft_dpi, cv->ft_depth );
cv->b.gridfit = FreeType_GridFitChar(single_glyph_context,cv->b.sc->orig_pos,
cv->ft_pointsizey, cv->ft_pointsizex, cv->ft_dpi, &cv->b.ft_gridfitwidth,
cv->b.sc, cv->ft_depth, true );
FreeTypeFreeContext(single_glyph_context);
GDrawRequestExpose(cv->v,NULL,false);
if ( cv->b.sc->instructions_out_of_date && cv->b.sc->ttf_instrs_len!=0 )
ff_post_notice(_("Instructions out of date"),
_("The points have been changed. This may mean that the truetype instructions now refer to the wrong points and they may cause unexpected results."));
}
void SCReGridFit(SplineChar *sc,int layer) {
CharView *cv;
for ( cv=(CharView *) (sc->views); cv!=NULL; cv=(CharView *) (cv->b.next) ) if ( cv->show_ft_results ) {
if ( cv->show_ft_results && CVLayer((CharViewBase *) cv)==layer ) {
SplinePointListsFree(cv->b.gridfit); cv->b.gridfit = NULL;
FreeType_FreeRaster(cv->raster); cv->raster = NULL;
CVGridFitChar(cv);
}
}
}
static void cvpy_menuactivate(GWindow gw,struct gmenuitem *mi,GEvent *e) {
CharView *cv = (CharView *) GDrawGetUserData(gw);
PyObject *pysc = PySC_From_SC(cv->b.sc);
if ( cvpy_menu_data==NULL )
return;
sc_active_in_ui = cv->b.sc;
layer_active_in_ui = CVLayer((CharViewBase *) cv);
PyFF_Glyph_Set_Layer(sc_active_in_ui,layer_active_in_ui);
py_menuactivate(mi,pysc,cvpy_menu_data,cvpy_menu_cnt);
sc_active_in_ui = NULL;
layer_active_in_ui = ly_fore;
}
static int CH_OK(GGadget *g, GEvent *e) {
if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
CreateHintData *hd = GDrawGetUserData(GGadgetGetWindow(g));
real base, width;
int err = 0;
StemInfo *h;
int layer = CVLayer((CharViewBase *) hd->cv);
base = GetReal8(hd->gw,CID_Base,_("Base:"),&err);
width = GetReal8(hd->gw,CID_Width,_("Size:"),&err);
if ( err )
return(true);
if ( hd->preservehints ) {
SCPreserveHints(hd->cv->b.sc,layer);
SCHintsChanged(hd->cv->b.sc);
}
h = chunkalloc(sizeof(StemInfo));
if ( width==-21 || width==-20 ) {
base += width;
width = -width;
h->ghost = true;
}
h->start = base;
h->width = width;
if ( hd->ishstem ) {
SCGuessHHintInstancesAndAdd(hd->cv->b.sc,layer,h,0x80000000,0x80000000);
hd->cv->b.sc->hconflicts = StemListAnyConflicts(hd->cv->b.sc->hstem);
} else {
SCGuessVHintInstancesAndAdd(hd->cv->b.sc,layer,h,0x80000000,0x80000000);
hd->cv->b.sc->vconflicts = StemListAnyConflicts(hd->cv->b.sc->vstem);
}
hd->cv->b.sc->manualhints = true;
if ( h!=NULL && hd->cv->b.sc->parent->mm==NULL )
SCModifyHintMasksAdd(hd->cv->b.sc,layer,h);
else
SCClearHintMasks(hd->cv->b.sc,layer,true);
SCOutOfDateBackground(hd->cv->b.sc);
SCUpdateAll(hd->cv->b.sc);
hd->done = true;
}
return( true );
}
void collabclient_sendRedo( CharViewBase *cv )
{
#ifdef BUILD_COLLAB
collabclient_sendRedo_SC( cv->sc, CVLayer(cv) );
/* cloneclient_t* cc = cv->fv->collabClient; */
/* if( !cc ) */
/* return; */
/* printf("collabclient_sendRedo() cv:%p\n", cv ); */
/* printf("collabclient_sendRedo() dm:%d\n", cv->drawmode ); */
/* printf("collabclient_sendRedo() preserveUndo:%p\n", cc->preserveUndo ); */
/* if( !cc->preserveUndo ) */
/* return; */
/* dumpUndoChain( "start of collabclient_sendRedo()", cv->sc, cv->layerheads[cv->drawmode]->undoes ); */
/* { */
/* Undoes* undo = cv->layerheads[cv->drawmode]->undoes; */
/* if( undo && undo->undotype == ut_statehint ) */
/* { */
/* cv->layerheads[cv->drawmode]->undoes = undo->next; */
/* // FIXME */
/* } */
/* } */
/* CVDoUndo( cv ); */
/* Undoes *undo = cv->layerheads[cv->drawmode]->redoes; */
/* printf("collabclient_sendRedo() undo:%p\n", undo ); */
/* if( undo ) */
/* { */
/* cv->layerheads[cv->drawmode]->redoes = undo->next; */
/* collabclient_sendRedo_Internal_CV( cv, undo, 0 ); */
/* undo->next = 0; */
/* UndoesFree( undo ); */
/* } */
/* cc->preserveUndo = 0; */
#endif
}
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);
}
void CVCompareLayerToLayer(CharView *cv) {
Layer2Layer(cv,NULL,l2l_compare,CVLayer((CharViewBase *) cv));
}
void CVCopyLayerToLayer(CharView *cv) {
Layer2Layer(cv,NULL,l2l_copy,CVLayer((CharViewBase *) cv));
}
void DeltaSuggestionDlg(FontView *fv,CharView *cv) {
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[13], boxes[4];
GTextInfo label[13];
GGadgetCreateData *varray[7][5], *barray[9];
char dpi_buffer[40], within_buffer[40];
QGData *data;
int failed = false;
int k, r;
FontView *savefv;
if ( !hasFreeType() ) {
ff_post_error(_("No FreeType"),_("You must install the freetype library before using this command."));
return;
}
if ( !hasFreeTypeByteCode() ) {
ff_post_error(_("No FreeType"),_("Your version of the freetype library does not contain the bytecode interpreter."));
return;
}
if ( delta_sizes==NULL )
delta_sizes = copy("7-40,72,80,88,96");
data = calloc(1,sizeof(QGData));
data->fv = (FontViewBase *) fv;
data->cv = cv;
if ( cv!=NULL ) {
data->sc = cv->b.sc;
savefv = (FontView *) cv->b.fv;
data->layer = CVLayer((CharViewBase *) cv);
if ( !data->sc->parent->layers[data->layer].order2 )
failed = true;
if ( !failed && data->sc->ttf_instrs_len==0 )
ff_post_notice(_("No Instructions"),_("This glyph has no instructions. Adding instructions (a DELTA) may change its rasterization significantly."));
cv->qg = data;
cv->note_x = cv->note_y = 32766;
} else {
savefv = fv;
data->layer = fv->b.active_layer;
if ( !fv->b.sf->layers[data->layer].order2 )
failed = true;
}
if ( failed ) {
ff_post_error(_("Not quadratic"),_("This must be a truetype layer."));
free(data);
if ( cv!=NULL )
cv->qg = NULL;
return;
}
savefv->qg = data;
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 = _("DELTA suggestions");
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,190));
pos.height = GDrawPointsToPixels(NULL,106);
data->gw = gw = GDrawCreateTopWindow(NULL,&pos,delta_e_h,data,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
k=r=0;
label[k].text = (unichar_t *) _(
"When a curve passes very close to the center of a\n"
"pixel you might want to check that the curve is on\n"
"the intended side of that pixel.\n"
"If it's on the wrong side, consider using a DELTA\n"
"instruction to adjust the closest point at the\n"
"current pixelsize."
);
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
label[k].text = (unichar_t *) _("Rasterize at sizes:");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
label[k].text = (unichar_t *) delta_sizes;
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.cid = CID_Sizes;
gcd[k++].creator = GTextFieldCreate;
varray[r][0] = &gcd[k-2]; varray[r][1] = &gcd[k-1]; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
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.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
sprintf( dpi_buffer, "%d", delta_dpi );
label[k].text = (unichar_t *) dpi_buffer;
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.pos.width = 40;
gcd[k].gd.cid = CID_DPI;
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GTextFieldCreate;
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.flags = delta_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.flags = delta_depth!=1 ? (gg_enabled|gg_visible|gg_cb_on) : (gg_enabled|gg_visible);
gcd[k++].creator = GRadioCreate;
varray[r][0] = &gcd[k-4]; varray[r][1] = &gcd[k-3]; varray[r][2] = &gcd[k-2]; varray[r][3] = &gcd[k-1]; varray[r++][4] = NULL;
label[k].text = (unichar_t *) _("Proximity:");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
sprintf( within_buffer, "%g", delta_within );
label[k].text = (unichar_t *) within_buffer;
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k].gd.pos.width = 40;
gcd[k].gd.cid = CID_Within;
gcd[k++].creator = GTextFieldCreate;
label[k].text = (unichar_t *) _("pixels");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled|gg_visible;
gcd[k++].creator = GLabelCreate;
varray[r][0] = &gcd[k-3]; varray[r][1] = &gcd[k-2]; varray[r][2] = &gcd[k-1]; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
label[k].text = (unichar_t *) _( "This may take a while. Please be patient..." );
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.flags = gg_enabled;
gcd[k].gd.cid = CID_Msg;
gcd[k++].creator = GLabelCreate;
varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
gcd[k].gd.flags = gg_visible | gg_enabled | gg_but_default;
label[k].text = (unichar_t *) _("_OK");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.handle_controlevent = Delta_OK;
gcd[k].gd.cid = CID_Ok;
gcd[k++].creator = GButtonCreate;
barray[0] = GCD_Glue; barray[1] = &gcd[k-1]; barray[2] = GCD_Glue;
gcd[k].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
label[k].text = (unichar_t *) _("_Cancel");
label[k].text_is_1byte = true;
label[k].text_in_resource = true;
gcd[k].gd.label = &label[k];
gcd[k].gd.handle_controlevent = Delta_Cancel;
gcd[k].gd.cid = CID_Cancel;
gcd[k++].creator = GButtonCreate;
barray[3] = GCD_Glue; barray[4] = &gcd[k-1]; barray[5] = GCD_Glue; barray[6] = NULL;
boxes[2].gd.flags = gg_enabled|gg_visible;
boxes[2].gd.u.boxelements = barray;
boxes[2].creator = GHBoxCreate;
varray[r][0] = &boxes[2]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = 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].gd.cid = CID_Top;
boxes[0].creator = GHVGroupCreate;
GGadgetsCreate(gw,boxes);
GHVBoxFitWindow(boxes[0].ret);
GDrawSetVisible(gw,true);
while ( !data->done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
if ( data->cv!=NULL )
data->cv->qg = NULL;
if ( savefv->qg == data )
savefv->qg = NULL;
}
/**
* Process the given kvmsg from the server. If create is set and we do
* not have any charview for a changed glyph then we first create a
* charview for it. This allows the updates from a server to be
* processed at startup time, getting us up to speed with any glyphs
* that have changed.
*
* This function is mainly called in response to an update which is
* published from the server. However, in sessionJoin() we also call
* here to handle the incremental updates to glyphs that have occurred
* after the SFD was sent to the server.
*/
static void zeromq_subscriber_process_update( cloneclient_t* cc, kvmsg_t *kvmsg, int create )
{
cc->sequence = kvmsg_sequence (kvmsg);
if( cc->sequence >= cc->roundTripTimerWaitingSeq )
cc->roundTripTimerWaitingSeq = 0;
char* uuid = kvmsg_get_prop (kvmsg, "uuid" );
byte* data = kvmsg_body (kvmsg);
size_t data_size = kvmsg_size (kvmsg);
byte* msgtype = kvmsg_get_prop (kvmsg, "type" );
printf("cc process_update() uuid:%s\n", uuid );
FontView* fv = FontViewFindUI( FontViewFind_byXUIDConnected, uuid );
printf("fv:%p\n", fv );
if( fv )
{
if( !data_size )
{
printf("WARNING: zero length message!\n" );
return;
}
SplineFont *sf = fv->b.sf;
if( !sf )
{
printf("ERROR: font view does not have the splinefont set!\n" );
return;
}
if( !strcmp( msgtype, MSG_TYPE_UNDO_FONTLEVEL ))
{
SFUndoes* u = SFUndoFromString( (char*)data );
SFUndoPerform( u, sf );
printf ("I: processed update=%d\n", (int) cc->sequence);
return;
}
char* pos = kvmsg_get_prop (kvmsg, "pos" );
char* name = kvmsg_get_prop (kvmsg, "name" );
printf("pos:%s\n", pos );
SplineChar* sc = SFGetOrMakeChar( sf, -1, name );
printf("sc:%p\n", sc );
if( !sc )
{
printf("WARNING: font view does not have a glyph for pos:%s\n", pos );
printf("WARNING: font view does not have a glyph for name:%s\n", name );
return;
}
printf("sc.name:%s\n", sc->name );
printf("data.size:%ld\n", data_size );
if( DEBUG_SHOW_SFD_CHUNKS )
printf("data:%s\n", data );
int current_layer = 0;
if( !sc->views && create )
{
int show = 0;
CharView* cv = CharViewCreateExtended( sc, fv, -1, show );
printf("created charview:%p\n", cv );
}
for( CharViewBase* cv = sc->views; cv; cv = cv->next )
{
printf("have charview:%p\n", cv );
char filename[PATH_MAX];
snprintf(filename, PATH_MAX, "%s/fontforge-collab-inx-%d.sfd", getTempDir(), getpid() );
GFileWriteAll( filename, (char*)data);
FILE* file = fopen( filename, "rb" );
Undoes* undo = SFDGetUndo( file, sc,
"UndoOperation",
current_layer );
fclose(file);
if( !undo )
{
printf("***** ERROR ****** reading back undo instance!\n");
printf("data: %s\n\n", data );
}
if( undo )
{
// NOT HANDLED!
if( undo->undotype == ut_statehint )
{
printf("*** warning ut_statehint not handled\n");
break;
}
printf("________________________ READ undo.layer: %d dm:%d layer_sz:%d\n",
undo->layer, cv->drawmode, cv->sc->layer_cnt );
int selectedlayer = cv->drawmode;
if( undo->layer != UNDO_LAYER_UNKNOWN )
selectedlayer = undo->layer;
// use oldlayer to store current setting and switch to the
// selected layer for this block.
int oldlayer = cv->drawmode;
cv->drawmode = selectedlayer;
undo->next = 0;
undo->next = cv->layerheads[selectedlayer]->redoes;
cv->layerheads[selectedlayer]->redoes = undo;
printf("________________________ READ ... 2\n");
printf("________________________ READ ... 2... ly_fore:%d cv.layer:%d\n", ly_fore, CVLayer(cv));
// cv->layerheads[cv->drawmode]-cv->sc->layers;
printf("________________________ READ ... 2... dm:%d\n", cv->drawmode );
printf("________________________ READ ... 2... sc->layers:%p\n", cv->sc->layers );
printf("________________________ READ ... 2... lh.dm :%p\n", cv->layerheads[cv->drawmode] );
CVDoRedo( cv );
printf("________________________ READ ... 3\n");
char* isLocalUndo = kvmsg_get_prop (kvmsg, "isLocalUndo" );
if( isLocalUndo )
{
if( isLocalUndo[0] == '1' )
{
printf("________________________ READ ... isLocal. \n");
Undoes* undo = cv->layerheads[selectedlayer]->undoes;
if( undo )
{
cv->layerheads[selectedlayer]->undoes = undo->next;
undo->next = cv->layerheads[selectedlayer]->redoes;
cv->layerheads[selectedlayer]->redoes = undo;
}
}
}
printf("________________________ READ ... 4\n");
if( cv->drawmode != oldlayer )
{
cv->drawmode = oldlayer;
CVCharChangedUpdate( cv );
}
printf("________________________ READ ... 5\n");
}
break;
}
}
printf ("I: processed update=%d\n", (int) cc->sequence);
}
static void RH_MovePoints(ReviewHintData *hd,StemInfo *active,int start,int width) {
SplineChar *sc = hd->cv->b.sc;
SplineSet *spl;
SplinePoint *sp;
int which;
int layer = CVLayer( (CharViewBase *) (hd->cv));
if ( !hd->undocreated ) {
SCPreserveLayer(sc,layer,true);
hd->undocreated = true;
}
for ( spl=sc->layers[layer].splines; spl!=NULL; spl=spl->next ) {
for ( sp = spl->first ; ; ) {
if ( hd->ishstem ) {
switch ((which = OnHint(active,sp->me.y,sp->me.x)) ) {
case 1:
sp->nextcp.y += start-sp->me.y;
sp->prevcp.y += start-sp->me.y;
sp->me.y = start;
break;
case 2:
sp->nextcp.y += start+width-sp->me.y;
sp->prevcp.y += start+width-sp->me.y;
sp->me.y = start+width;
break;
case 0:
/* Not on hint */;
break;
}
} else {
switch ( (which = OnHint(active,sp->me.x,sp->me.y)) ) {
case 1:
sp->nextcp.x += start-sp->me.x;
sp->prevcp.x += start-sp->me.x;
sp->me.x = start;
break;
case 2:
sp->nextcp.x += start+width-sp->me.x;
sp->prevcp.x += start+width-sp->me.x;
sp->me.x = start+width;
break;
case 0:
/* Not on hint */;
break;
}
}
if ( which ) {
if ( sp->prev )
SplineRefigure(sp->prev);
if ( sp->next )
SplineRefigure(sp->next);
}
if ( sp->next==NULL )
break;
sp = sp->next->to;
if ( sp== spl->first )
break;
}
}
}
