void eqnsys<nr_type_t>::chop_svd (void) {
int c;
nr_double_t Max, Min;
Max = 0.0;
for (c = 0; c < N; c++) if (fabs (S_(c)) > Max) Max = fabs (S_(c));
Min = Max * std::numeric_limits<nr_double_t>::max();
for (c = 0; c < N; c++) if (fabs (S_(c)) < Min) S_(c) = 0.0;
}
void eqnsys<nr_type_t>::chop_svd (void) {
int c;
nr_double_t Max, Min;
Max = 0.0;
for (c = 0; c < N; c++) if (fabs (S_(c)) > Max) Max = fabs (S_(c));
Min = Max * NR_EPSI;
for (c = 0; c < N; c++) if (fabs (S_(c)) < Min) S_(c) = 0.0;
}
void
ui_print_database()
{
FILE *handle;
char *command = opt_get_str(STR_PRINT_COMMAND);
int mode;
if(list_is_empty())
return;
switch(statusline_askchoice(_("Print <a>ll, print <s>elected, or <c>ancel?"), S_("keybindings:all/selected/cancel|asc"), 3)) {
case 1:
mode = ENUM_ALL;
break;
case 2:
if( !selected_items() ) {
statusline_msg(_("No selected items"));
return;
}
mode = ENUM_SELECTED;
break;
default:
refresh_screen();
return;
}
clear_statusline();
if( ! *command || (handle = popen(command, "w")) == NULL)
return;
fexport("text", handle, mode);
pclose(handle);
}
static void BdfP_Expose(struct bdf_dlg *bd, GWindow pixmap) {
struct bdf_dlg_font *cur = bd->cur;
BDFFont *bdf = cur->bdf;
int i;
int page = bd->vheight/(bd->fh+1);
GRect clip, old, r;
char buffer[40];
extern GBox _ggadget_Default_Box;
GDrawSetFont(pixmap,bd->font);
clip.x = 4; clip.width = bd->value_x-4-2; clip.height = bd->fh;
for ( i=0; i<page && i+cur->top_prop<bdf->prop_cnt; ++i ) {
int sel = i+cur->top_prop==cur->sel_prop;
clip.y = i*(bd->fh+1);
if ( sel ) {
r.x = 0; r.width = bd->width;
r.y = clip.y; r.height = clip.height;
GDrawFillRect(pixmap,&r,ACTIVE_BORDER);
}
GDrawPushClip(pixmap,&clip,&old);
GDrawDrawBiText8(pixmap,4,i*(bd->fh+1)+bd->as,bdf->props[i+cur->top_prop].name,-1,NULL,MAIN_FOREGROUND);
GDrawPopClip(pixmap,&old);
switch ( bdf->props[i+cur->top_prop].type&~prt_property ) {
case prt_string: case prt_atom:
GDrawDrawBiText8(pixmap,bd->value_x+2,i*(bd->fh+1)+bd->as,bdf->props[i+cur->top_prop].u.str,-1,NULL,MAIN_FOREGROUND);
break;
case prt_int:
sprintf( buffer, "%d", bdf->props[i+cur->top_prop].u.val );
GDrawDrawBiText8(pixmap,bd->value_x+2,i*(bd->fh+1)+bd->as,buffer,-1,NULL,MAIN_FOREGROUND);
break;
case prt_uint:
sprintf( buffer, "%u", (unsigned) bdf->props[i+cur->top_prop].u.val );
GDrawDrawBiText8(pixmap,bd->value_x+2,i*(bd->fh+1)+bd->as,buffer,-1,NULL,MAIN_FOREGROUND);
break;
}
GDrawDrawLine(pixmap,0,i*(bd->fh+1)+bd->fh,bd->vwidth,i*(bd->fh+1)+bd->fh,0x808080);
}
if ( i<page ) {
/* GT: I am told that the use of "|" to provide contextual information in a */
/* GT: gettext string is non-standard. However it is documented in section */
/* GT: 10.2.6 of http://www.gnu.org/software/gettext/manual/html_mono/gettext.html */
/* GT: */
/* GT: Anyway here the word "Property" is used to provide context for "New..." and */
/* GT: the translator should only translate "New...". This is necessary because in */
/* GT: French (or any language where adjectives agree in gender/number with their */
/* GT: nouns) there are several different forms of "New" and the one chose depends */
/* GT: on the noun in question. */
/* GT: A french translation might be either msgstr "Nouveau..." or msgstr "Nouvelle..." */
/* GT: */
/* GT: I expect there are more cases where one english word needs to be translated */
/* GT: by several different words in different languages (in Japanese a different */
/* GT: word is used for the latin script and the latin language) and that you, as */
/* GT: a translator may need to ask me to disambiguate more strings. Please do so: */
/* GT: <*****@*****.**> */
GDrawDrawBiText8(pixmap,4,i*(bd->fh+1)+bd->as,S_("Property|New..."),-1,NULL,0xff0000);
GDrawDrawLine(pixmap,0,i*(bd->fh+1)+bd->fh,bd->vwidth,i*(bd->fh+1)+bd->fh, _ggadget_Default_Box.border_darker);
}
GDrawDrawLine(pixmap,bd->value_x,0,bd->value_x,bd->vheight, _ggadget_Default_Box.border_darker);
}
void eqnsys<nr_type_t>::substitute_svd (void) {
int c, r;
nr_type_t f;
// calculate U'B
for (c = 0; c < N; c++) {
f = 0.0;
// non-zero result only if S is non-zero
if (S_(c) != 0.0) {
for (r = 0; r < N; r++) f += cond_conj (U_(r, c)) * B_(r);
// this is the divide by S
f /= S_(c);
}
R_(c) = f;
}
// matrix multiply by V to get the final solution
for (r = 0; r < N; r++) {
for (f = 0.0, c = 0; c < N; c++) f += cond_conj (V_(c, r)) * R_(c);
X_(r) = f;
}
}
static void EncodingInit(void) {
int i;
static int done = false;
if ( done )
return;
done = true;
for ( i=0; i<sizeof(encodingtypes)/sizeof(encodingtypes[0])-1; ++i ) {
if ( !encodingtypes[i].line )
encodingtypes[i].text = (unichar_t *) S_((char *) encodingtypes[i].text);
}
}
void eqnsys<nr_type_t>::factorize_svd (void) {
int i, j, l;
nr_type_t t;
// allocate space for vectors and matrices
delete R; R = new tvector<nr_type_t> (N);
delete T; T = new tvector<nr_type_t> (N);
delete V; V = new tmatrix<nr_type_t> (N);
delete S; S = new tvector<nr_double_t> (N);
delete E; E = new tvector<nr_double_t> (N);
// bidiagonalization through householder transformations
for (i = 0; i < N; i++) {
T_(i) = householder_left (i);
if (i < N - 1) R_(i) = householder_right (i);
}
// copy over the real valued bidiagonal values
for (i = 0; i < N; i++) S_(i) = real (A_(i, i));
for (E_(0) = 0, i = 1; i < N; i++) E_(i) = real (A_(i - 1, i));
// backward accumulation of right-hand householder transformations
// yields the V' matrix
for (l = N, i = N - 1; i >= 0; l = i--) {
if (i < N - 1) {
if ((t = R_(i)) != 0.0) {
householder_apply_right_extern (i, cond_conj (t));
}
else for (j = l; j < N; j++) // cleanup this row
V_(i, j) = V_(j, i) = 0.0;
}
V_(i, i) = 1.0;
}
// backward accumulation of left-hand householder transformations
// yields the U matrix in place of the A matrix
for (l = N, i = N - 1; i >= 0; l = i--) {
for (j = l; j < N; j++) // cleanup upper row
A_(i, j) = 0.0;
if ((t = T_(i)) != 0.0) {
householder_apply_left (i, cond_conj (t));
for (j = l; j < N; j++) A_(j, i) *= -t;
}
else for (j = l; j < N; j++) // cleanup this column
A_(j, i) = 0.0;
A_(i, i) = 1.0 - t;
}
// S and E contain diagonal and super-diagonal, A contains U, V'
// calculated; now diagonalization can begin
diagonalize_svd ();
}
int
statusline_ask_boolean(const char *msg, int def)
{
int ret;
char *msg2 = strconcat(msg, def ? _(" (Y/n)?") : _(" (y/N)?"), NULL);
char ch;
statusline_addstr(msg2);
free(msg2);
ch = tolower(getch());
if(ch == *(S_("keybinding for no|n")))
ret = FALSE;
else if(ch == *(S_("keybinding for yes|y")))
ret = TRUE;
else
ret = def;
clear_statusline();
return ret;
}
static void JustUIInit(void) {
static int done = false;
int i, j;
static struct col_init *needswork[] = {
justify_ci, jstf_lang_ci, lookup_ci, glyph_ci,
NULL
};
if ( done )
return;
done = true;
for ( j=0; needswork[j]!=NULL; ++j ) {
for ( i=0; needswork[j][i].title!=NULL; ++i )
if ( needswork[j][i].title!=NULL )
needswork[j][i].title = S_(needswork[j][i].title);
}
}
void mb2DoGetText(GMenuItem2 *mb) {
/* perform gettext substitutions on this menu and all sub menus */
int i;
if ( mb==NULL )
return;
for ( i=0; mb[i].ti.text!=NULL || mb[i].ti.line || mb[i].ti.image!=NULL; ++i ) {
if( mb[i].shortcut )
mb[i].ti.text_untranslated = copy(mb[i].shortcut);
else
mb[i].ti.text_untranslated = cu_copy(mb[i].ti.text);
if ( mb[i].ti.text!=NULL ) {
mb[i].ti.text = (unichar_t *) S_((char *) mb[i].ti.text);
if ( mb[i].sub!=NULL )
mb2DoGetText(mb[i].sub);
}
}
}
void
ui_read_database()
{
char *msg;
if(!list_is_empty()) {
msg = strdup_printf(_("Your current data will be lost - "
"Press '%c' to continue"),
*(S_("keybinding for yes|y")));
if(!statusline_ask_boolean(msg, FALSE)) {
free(msg);
return;
}
free(msg);
}
load_database(datafile);
refresh_list();
}
void eqnsys<nr_type_t>::diagonalize_svd (void) {
bool split;
int i, l, j, its, k, n, MaxIters = 30;
nr_double_t an, f, g, h, d, c, s, b, a;
// find largest bidiagonal value
for (an = 0, i = 0; i < N; i++)
an = MAX (an, fabs (S_(i)) + fabs (E_(i)));
// diagonalize the bidiagonal matrix (stored as super-diagonal
// vector E and diagonal vector S)
for (k = N - 1; k >= 0; k--) {
// loop over singular values
for (its = 0; its <= MaxIters; its++) {
split = true;
// check for a zero entry along the super-diagonal E, if there
// is one, it is possible to QR iterate on two separate matrices
// above and below it
for (n = 0, l = k; l >= 1; l--) {
// note that E_(0) is always zero
n = l - 1;
if (fabs (E_(l)) + an == an) { split = false; break; }
if (fabs (S_(n)) + an == an) break;
}
// if there is a zero on the diagonal S, it is possible to zero
// out the corresponding super-diagonal E entry to its right
if (split) {
// cancellation of E_(l), if l > 0
c = 0.0;
s = 1.0;
for (i = l; i <= k; i++) {
f = -s * E_(i);
E_(i) *= c;
if (fabs (f) + an == an) break;
g = S_(i);
S_(i) = givens (f, g, c, s);
// apply inverse rotation to U
givens_apply_u (n, i, c, s);
}
}
d = S_(k);
// convergence
if (l == k) {
// singular value is made non-negative
if (d < 0.0) {
S_(k) = -d;
for (j = 0; j < N; j++) V_(k, j) = -V_(k, j);
}
break;
}
if (its == MaxIters) {
logprint (LOG_ERROR, "WARNING: no convergence in %d SVD iterations\n",
MaxIters);
}
// shift from bottom 2-by-2 minor
a = S_(l);
n = k - 1;
b = S_(n);
g = E_(n);
h = E_(k);
// compute QR shift value (as close as possible to the largest
// eigenvalue of the 2-by-2 minor matrix)
f = (b - d) * (b + d) + (g - h) * (g + h);
f /= 2.0 * h * b;
f += sign_(f) * xhypot (f, 1.0);
f = ((a - d) * (a + d) + h * (b / f - h)) / a;
// f => (B_{ll}^2 - u) / B_{ll}
// u => eigenvalue of T = B' * B nearer T_{22} (Wilkinson shift)
// next QR transformation
c = s = 1.0;
for (j = l; j <= n; j++) {
i = j + 1;
g = E_(i);
b = S_(i);
h = s * g; // h => right-hand non-zero to annihilate
g *= c;
E_(j) = givens (f, h, c, s);
// perform the rotation
f = a * c + g * s;
g = g * c - a * s;
h = b * s;
b *= c;
// here: +- -+
// | f g | = B * V'_j (also first V'_1)
// | h b |
// +- -+
// accumulate the rotation in V'
givens_apply_v (j, i, c, s);
d = S_(j) = xhypot (f, h);
// rotation can be arbitrary if d = 0
if (d != 0.0) {
// d => non-zero result on diagonal
d = 1.0 / d;
// rotation coefficients to annihilate the lower non-zero
c = f * d;
s = h * d;
}
f = c * g + s * b;
a = c * b - s * g;
// here: +- -+
// | d f | => U_j * B
// | 0 a |
// +- -+
// accumulate rotation into U
givens_apply_u (j, i, c, s);
}
E_(l) = 0;
E_(k) = f;
S_(k) = a;
}
}
}
static void FVCreateWidth( void *_fv,SplineChar* _sc,void (*doit)(CreateWidthData *),
enum widthtype wtype, char *def) {
GRect pos;
GWindowAttrs wattrs;
GGadgetCreateData gcd[11], boxes[2], topbox[2], *hvs[17], *varray[8], *buttons[6];
GTextInfo label[11];
static CreateWidthDlg cwd;
static GWindow winds[5];
static char *title[] = { N_("Set Width..."), N_("Set LBearing..."), N_("Set RBearing..."), N_("Set Both Side Bearings..."), N_("Set Vertical Advance...") };
cwd.wd.done = false;
cwd.wd._fv = _fv;
cwd.wd._sc = _sc;
cwd.wd.wtype = wtype;
cwd.wd.doit = doit;
cwd.gw = winds[wtype];
if ( cwd.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 = _(title[wtype]);
wattrs.is_dlg = true;
pos.x = pos.y = 0;
pos.width = GGadgetScale(GDrawPointsToPixels(NULL,180));
pos.height = GDrawPointsToPixels(NULL,100);
cwd.gw = winds[wtype] = GDrawCreateTopWindow(NULL,&pos,cwd_e_h,&cwd,&wattrs);
memset(&label,0,sizeof(label));
memset(&gcd,0,sizeof(gcd));
label[0].text = (unichar_t *) _(rb1[wtype]);
label[0].text_is_1byte = true;
gcd[0].gd.label = &label[0];
gcd[0].gd.flags = gg_enabled|gg_visible|gg_cb_on;
gcd[0].gd.cid = CID_Set;
gcd[0].gd.handle_controlevent = CW_RadioChange;
gcd[0].data = (void *) CID_SetVal;
gcd[0].creator = GRadioCreate;
label[1].text = (unichar_t *) _(rb2[wtype]);
label[1].text_is_1byte = true;
gcd[1].gd.label = &label[1];
gcd[1].gd.flags = gg_enabled|gg_visible|gg_rad_continueold ;
gcd[1].gd.cid = CID_Incr;
gcd[1].gd.handle_controlevent = CW_RadioChange;
gcd[1].data = (void *) CID_IncrVal;
gcd[1].creator = GRadioCreate;
label[2].text = (unichar_t *) _(rb3[wtype]);
label[2].text_is_1byte = true;
gcd[2].gd.label = &label[2];
gcd[2].gd.flags = gg_enabled|gg_visible|gg_rad_continueold ;
gcd[2].gd.cid = CID_Scale;
gcd[2].gd.handle_controlevent = CW_RadioChange;
gcd[2].data = (void *) CID_ScaleVal;
gcd[2].creator = GRadioCreate;
label[3].text = (unichar_t *) def;
label[3].text_is_1byte = true;
gcd[3].gd.label = &label[3];
gcd[3].gd.pos.width = 60;
gcd[3].gd.flags = gg_enabled|gg_visible;
gcd[3].gd.cid = CID_SetVal;
gcd[3].gd.handle_controlevent = CW_FocusChange;
gcd[3].data = (void *) CID_Set;
gcd[3].creator = GTextFieldCreate;
label[4].text = (unichar_t *) "0";
label[4].text_is_1byte = true;
gcd[4].gd.label = &label[4];
gcd[4].gd.pos.width = 60;
gcd[4].gd.flags = gg_enabled|gg_visible;
gcd[4].gd.cid = CID_IncrVal;
gcd[4].gd.handle_controlevent = CW_FocusChange;
gcd[4].data = (void *) CID_Incr;
gcd[4].creator = GTextFieldCreate;
label[5].text = (unichar_t *) "100";
label[5].text_is_1byte = true;
gcd[5].gd.label = &label[5];
gcd[5].gd.pos.width = 60;
gcd[5].gd.flags = gg_enabled|gg_visible;
gcd[5].gd.cid = CID_ScaleVal;
gcd[5].gd.handle_controlevent = CW_FocusChange;
gcd[5].data = (void *) CID_Scale;
gcd[5].creator = GTextFieldCreate;
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.mnemonic = 'O';
gcd[6].gd.label = &label[6];
gcd[6].gd.handle_controlevent = CW_OK;
gcd[6].creator = GButtonCreate;
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.mnemonic = 'C';
gcd[7].gd.handle_controlevent = CW_Cancel;
gcd[7].creator = GButtonCreate;
label[8].text = (unichar_t *) S_(info[wtype]);
label[8].text_is_1byte = true;
gcd[8].gd.label = &label[8];
gcd[8].gd.pos.x = 5; gcd[8].gd.pos.y = 59;
gcd[8].gd.flags = gg_enabled|gg_visible ;
gcd[8].creator = GLabelCreate;
label[9].text = (unichar_t *) "%";
label[9].text_is_1byte = true;
gcd[9].gd.label = &label[9];
gcd[9].gd.flags = gg_enabled|gg_visible;
gcd[9].creator = GLabelCreate;
hvs[0] = &gcd[0]; hvs[1] = &gcd[3]; hvs[2] = GCD_Glue; hvs[3] = NULL;
hvs[4] = &gcd[1]; hvs[5] = &gcd[4]; hvs[6] = GCD_Glue; hvs[7] = NULL;
hvs[8] = &gcd[2]; hvs[9] = &gcd[5]; hvs[10] = &gcd[9]; hvs[11] = NULL;
hvs[12] = &gcd[8]; hvs[13] = GCD_ColSpan; hvs[14] = GCD_Glue; hvs[15] = NULL;
hvs[16] = NULL;
buttons[0] = buttons[2] = buttons[4] = GCD_Glue; buttons[5] = NULL;
buttons[1] = &gcd[6]; buttons[3] = &gcd[7];
varray[0] = &boxes[1]; varray[1] = NULL;
varray[2] = GCD_Glue; varray[3] = NULL;
varray[4] = &boxes[0]; varray[5] = NULL;
varray[6] = NULL;
memset(boxes,0,sizeof(boxes));
boxes[0].gd.flags = gg_enabled|gg_visible;
boxes[0].gd.u.boxelements = buttons;
boxes[0].creator = GHBoxCreate;
boxes[1].gd.flags = gg_enabled|gg_visible;
boxes[1].gd.u.boxelements = hvs;
boxes[1].creator = GHVBoxCreate;
memset(topbox,0,sizeof(topbox));
topbox[0].gd.pos.x = topbox[0].gd.pos.y = 2;
topbox[0].gd.pos.width = pos.width-4; topbox[0].gd.pos.height = pos.height-4;
topbox[0].gd.flags = gg_enabled|gg_visible;
topbox[0].gd.u.boxelements = varray;
topbox[0].creator = GHVGroupCreate;
GGadgetsCreate(cwd.gw,topbox);
GHVBoxSetExpandableRow(topbox[0].ret,1);
GHVBoxSetExpandableCol(boxes[0].ret,gb_expandgluesame);
GHVBoxSetExpandableCol(boxes[1].ret,1);
GWidgetIndicateFocusGadget(GWidgetGetControl(cwd.gw,CID_SetVal));
GTextFieldSelect(GWidgetGetControl(cwd.gw,CID_SetVal),0,-1);
GHVBoxFitWindow(topbox[0].ret);
} else {
unichar_t *temp = uc_copy(def);
GGadgetSetTitle(GWidgetGetControl(cwd.gw,CID_SetVal),temp);
}
GWidgetHidePalettes();
GDrawSetVisible(cwd.gw,true);
while ( !cwd.wd.done )
GDrawProcessOneEvent(NULL);
GDrawSetVisible(cwd.gw,false);
}
void perform_front_propagation_2d(T_callback_intert_node callback_insert_node)
{
// create the Fibonacci heap
struct fibheap* open_heap = fh_makeheap();
fh_setcmp(open_heap, compare_points);
double h = 1.0/n;
// initialize points
for( int i=0; i<n; ++i )
for( int j=0; j<p; ++j )
{
D_(i,j) = GW_INFINITE;
S_(i,j) = kFar;
Q_(i,j) = -1;
}
// record all the points
heap_pool = new fibheap_el*[n*p];
memset( heap_pool, NULL, n*p*sizeof(fibheap_el*) );
// inialize open list
point_list existing_points;
for( int k=0; k<nb_start_points; ++k )
{
int i = (int) start_points_(0,k);
int j = (int) start_points_(1,k);
if( D_( i,j )==0 )
ERROR_MSG("start_points should not contain duplicates.");
point* pt = new point( i,j );
existing_points.push_back( pt ); // for deleting at the end
heap_pool_(i,j) = fh_insert( open_heap, pt ); // add to heap
if( values==NULL )
D_( i,j ) = 0;
else
D_( i,j ) = values[k];
S_( i,j ) = kOpen;
Q_(i,j) = k;
}
// perform the front propagation
int num_iter = 0;
bool stop_iteration = GW_False;
while( !fh_isempty(open_heap) && num_iter<nb_iter_max && !stop_iteration )
{
num_iter++;
// current point
point& cur_point = * ((point*) fh_extractmin( open_heap ));
int i = cur_point.i;
int j = cur_point.j;
heap_pool_(i,j) = NULL;
S_(i,j) = kDead;
stop_iteration = end_points_reached(i,j);
/*
char msg[200];
sprintf(msg, "Cool %f", Q_(i,j) );
WARN_MSG( msg );
*/
CHECK_HEAP;
// recurse on each neighbor
int nei_i[4] = {i+1,i,i-1,i};
int nei_j[4] = {j,j+1,j,j-1};
for( int k=0; k<4; ++k )
{
int ii = nei_i[k];
int jj = nei_j[k];
bool bInsert = true;
if( callback_insert_node!=NULL )
bInsert = callback_insert_node(i,j,ii,jj);
// check that the contraint distance map is ok
if( ii>=0 && jj>=0 && ii<n && jj<p && bInsert )
{
double P = h/W_(ii,jj);
// compute its neighboring values
double a1 = GW_INFINITE;
int k1 = -1;
if( ii<n-1 )
{
bool bParticipate = true;
if( callback_insert_node!=NULL )
bParticipate = callback_insert_node(ii,jj,ii+1,jj);
if( bParticipate )
{
a1 = D_(ii+1,jj);
k1 = Q_(ii+1,jj);
}
}
if( ii>0 )
{
bool bParticipate = true;
if( callback_insert_node!=NULL )
bParticipate = callback_insert_node(ii,jj,ii-1,jj);
if( bParticipate )
{
if( D_(ii-1,jj)<a1 )
k1 = Q_(ii-1,jj);
a1 = GW_MIN( a1, D_(ii-1,jj) );
}
}
double a2 = GW_INFINITE;
int k2 = -1;
if( jj<p-1 )
{
bool bParticipate = true;
if( callback_insert_node!=NULL )
bParticipate = callback_insert_node(ii,jj,ii,jj+1);
if( bParticipate )
{
a2 = D_(ii,jj+1);
k2 = Q_(ii,jj+1);
}
}
if( jj>0 )
{
bool bParticipate = true;
if( callback_insert_node!=NULL )
bParticipate = callback_insert_node(ii,jj,ii,jj-1);
if( bParticipate )
{
if( D_(ii,jj-1)<a2 )
k2 = Q_(ii,jj-1);
a2 = GW_MIN( a2, D_(ii,jj-1) );
}
}
if( a1>a2 ) // swap so that a1<a2
{
double tmp = a1; a1 = a2; a2 = tmp;
int tmpi = k1; k1 = k2; k2 = tmpi;
}
// update its distance
// now the equation is (a-a1)^2+(a-a2)^2 = P, with a >= a2 >= a1.
double A1 = 0;
if( P*P > (a2-a1)*(a2-a1) )
{
double delta = 2*P*P-(a2-a1)*(a2-a1);
A1 = (a1+a2+sqrt(delta))/2.0;
}
else
A1 = a1 + P;
if( ((int) S_(ii,jj)) == kDead )
{
// check if action has change. Should not happen for FM
// if( A1<D_(ii,jj) )
// WARN_MSG("The update is not monotone");
#if 1
if( A1<D_(ii,jj) ) // should not happen for FM
{
D_(ii,jj) = A1;
// update the value of the closest starting point
//if( GW_ABS(a1-A1)<GW_ABS(a2-A1) && k1>=0 )
Q_(ii,jj) = k1;
//else
// Q_(ii,jj) = k2;
//Q_(ii,jj) = Q_(i,j);
}
#endif
}
else if( ((int) S_(ii,jj)) == kOpen )
{
// check if action has change.
if( A1<D_(ii,jj) )
{
D_(ii,jj) = A1;
// update the value of the closest starting point
//if( GW_ABS(a1-A1)<GW_ABS(a2-A1) && k1>=0 )
Q_(ii,jj) = k1;
//else
// Q_(ii,jj) = k2;
//Q_(ii,jj) = Q_(i,j);
// Modify the value in the heap
fibheap_el* cur_el = heap_pool_(ii,jj);
if( cur_el!=NULL )
fh_replacedata( open_heap, cur_el, cur_el->fhe_data ); // use same data for update
else
ERROR_MSG("Error in heap pool allocation.");
}
}
else if( ((int) S_(ii,jj)) == kFar )
{
if( D_(ii,jj)!=GW_INFINITE )
ERROR_MSG("Distance must be initialized to Inf");
if( L==NULL || A1<=L_(ii,jj) )
{
S_(ii,jj) = kOpen;
// distance must have change.
D_(ii,jj) = A1;
// update the value of the closest starting point
//if( GW_ABS(a1-A1)<GW_ABS(a2-A1) && k1>=0 )
Q_(ii,jj) = k1;
//else
// Q_(ii,jj) = k2;
//Q_(ii,jj) = Q_(i,j);
// add to open list
point* pt = new point(ii,jj);
existing_points.push_back( pt );
heap_pool_(ii,jj) = fh_insert( open_heap, pt ); // add to heap
}
}
else
ERROR_MSG("Unkwnown state.");
} // end switch
} // end for
} // end while
// char msg[200];
// sprintf(msg, "Cool %f", Q_(100,100) );
// WARN_MSG( msg );
// free heap
fh_deleteheap(open_heap);
// free point pool
for( point_list::iterator it = existing_points.begin(); it!=existing_points.end(); ++it )
GW_DELETE( *it );
// free fibheap pool
GW_DELETEARRAY(heap_pool);
}
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);
}
matrix<std::complex<T>> const
make_scattering_matrix( matrix<std::size_t> const& ar, matrix<std::complex<T>> const& ug, Itor diag_begin, Itor diag_end, std::complex<T> const& thickness, std::size_t column_index )
{
//std::cout << "debugging in make_scattering_matrix:\n";
//std::cout << "Ar=\n" << ar << "\n";
//std::cout << "column_index=\n" << column_index << "\n";
assert( column_index < ar.row() );
#if 1
matrix<std::complex<T>> const& S = make_scattering_matrix( ar, ug, diag_begin, diag_end, thickness );
matrix<std::complex<T>> S_{ S.row(), 1 };
std::copy( S.col_begin(column_index), S.col_end(column_index), S_.begin() );
#endif
#if 0
typedef std::complex<T> complex_type;
typedef matrix<std::complex<T>> complex_matrix_type;
auto const& A = make_structure_matrix( ar, ug, diag_begin, diag_end ) * thickness;
complex_matrix_type S_( A.row(), 1, complex_type{0.0, 0.0} );
S_[column_index][0] = complex_type{1.0, 0.0};
complex_matrix_type A_( A.row(), 1 );
std::copy( A.col_begin(column_index), A.col_end(column_index), A_.begin() );
S_ += A_; // I + A
complex_matrix_type a_n_1 = A_;
complex_matrix_type a_n = A_;
// S_ = I + A + A^2/2 + ... + A^10/10!
for ( std::size_t idx = 2; idx != 11; ++idx )
{
compute_an( A, a_n_1, a_n, idx );
S_ += a_n;
a_n.swap( a_n_1 );
}
T const eps( 1.0e-20 );
for ( std::size_t idx = 11; true; ++idx )
{
compute_an( A, a_n_1, a_n, idx );
S_ += a_n;
T const ws = square_norm( S_ );
T const wn = square_norm( a_n );
if ( wn < ws * eps ) break;
a_n.swap( a_n_1 );
}
#endif
#if 0
auto const& A = make_structure_matrix( ar, ug, diag_begin, diag_end ) * thickness;
complex_matrix_type S( A.row(), A.col(), complex_type{0.0, 0.0} );
std::fill( S.begin(), S.end(), complex_type{1.0, 0.0} );
S += A;
complex_matrix_type Ax = A;
for ( std::size_t idx = 2; idx != 20; ++idx )
{
Ax *= A;
Ax /= complex_type{ static_cast<T>(idx), 0 };
S += Ax;
}
matrix<std::complex<T>> S_{ S.row(), 1 };
std::copy( S.col_begin(column_index), S.col_end(column_index), S_.begin() );
#endif
#if 0
complex_matrix_type A( ar.row(), ar.col() );
for ( std::size_t r = 0; r != A.row(); ++r )
for ( std::size_t c = 0; c != A.col(); ++c )
A[r][c] = ug[ar[r][c]][0];
std::copy( diag_begin, diag_end, A.diag_begin() );
A *= thickness;
//I
complex_matrix_type S_{ A.row(), 1, std::complex<T>{0.0, 0.0} };
std::fill( S_.begin(), S_.end(), complex_type{0.0, 0.0} );
S_[column_index][0] = std::complex<T>{ 1.0, 0.0 };
//A
complex_matrix_type En{ A.row(), 1 };
std::copy( A.col_begin( column_index ), A.col_end( column_index ), En.begin() );
//S2
complex_matrix_type S2{ A.row(), 1 };
complex_produce( A, En, S2 );
//S3
complex_matrix_type S3{ A.row(), 1 };
complex_produce( A, S2, S3 );
//S4
complex_matrix_type S4{ A.row(), 1 };
complex_produce( A, S3, S4 );
//S5
complex_matrix_type S5{ A.row(), 1 };
complex_produce( A, S4, S5 );
//S6
complex_matrix_type S6{ A.row(), 1 };
complex_produce( A, S5, S6 );
//S7
complex_matrix_type S7{ A.row(), 1 };
complex_produce( A, S6, S7 );
//S8
complex_matrix_type S8{ A.row(), 1 };
complex_produce( A, S7, S8 );
//S9
complex_matrix_type S9{ A.row(), 1 };
complex_produce( A, S8, S9 );
//S10
complex_matrix_type S10{ A.row(), 1 };
complex_produce( A, S9, S10 );
for ( std::size_t r = 0; r != S_.row(); ++r )
{
S_[r][0] += En[r][0] + S2[r][0] / complex_type{ 2.0, 0.0 } +
S3[r][0] / complex_type{ 6.0, 0.0 } +
S4[r][0] / complex_type{ 24.0, 0.0 } +
S5[r][0] / complex_type{ 120.0, 0.0 } +
S6[r][0] / complex_type{ 720.0, 0.0 } +
S7[r][0] / complex_type{ 5040.0, 0.0 } +
S8[r][0] / complex_type{ 40320.0, 0.0 } +
S9[r][0] / complex_type{ 362880.0, 0.0 } +
S10[r][0] / complex_type{ 3628800.0, 0.0 };
}
#endif
return S_;
}
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
SessionImpl::RegisterFileType (/*[in]*/ FileType fileType)
{
if (fileType.Get() >= fileTypes.size())
{
fileTypes.resize (FileType::E_N_D);
}
if (fileTypes[fileType.Get()].fileType == fileType.Get())
{
// already registered
return;
}
switch (fileType.Get())
{
case FileType::AFM:
RegisterFileType (
FileType::AFM,
"afm",
0,
".afm",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_AFM_DIR)),
P2_("AFMFONTS", "TEXFONTS"));
break;
case FileType::BASE:
RegisterFileType (
FileType::BASE,
"base",
"METAFONT",
".base",
P2_(CURRENT_DIRECTORY, s_(MIKTEX_PATH_BASE_DIR)),
"");
break;
case FileType::BIB:
RegisterFileType (
FileType::BIB,
"bib",
"BibTeX",
".bib",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/bib")),
P2_("BIBINPUTS", "TEXBIB"));
break;
case FileType::BST:
RegisterFileType (
FileType::BST,
"bst",
"BibTeX",
".bst",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/{bst,csf}")),
"BSTINPUTS");
break;
case FileType::CID:
RegisterFileType (
FileType::CID,
"cid maps",
0,
P2_(".cid", ".cidmap"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CIDMAP_DIR)),
"FONTCIDMAPS");
break;
case FileType::CLUA:
RegisterFileType (
FileType::CLUA,
"clua",
0,
P2_(".dll", ".so"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}/lua")),
"CLUAINPUTS");
break;
case FileType::CNF:
RegisterFileType (
FileType::CNF,
"cnf",
0,
".cnf",
S_(MIKTEX_PATH_WEB2C_DIR),
"TEXMFCNF");
break;
case FileType::CMAP:
RegisterFileType (
FileType::CMAP,
"cmap files",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CMAP_DIR)),
P2_("CMAPFONTS", "TEXFONTS"));
break;
case FileType::CWEB:
RegisterFileType (
FileType::CWEB,
"cweb",
"CWeb",
".w",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CWEB_DIR)),
"CWEBINPUTS");
break;
case FileType::DB:
RegisterFileType (
FileType::DB,
"ls-R",
0,
"",
"",
"TEXMFDBS");
break;
case FileType::DVI:
RegisterFileType (
FileType::DVI,
"dvi",
0,
".dvi",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_DOC_DIR)),
"");
break;
case FileType::DVIPSCONFIG:
RegisterFileType (
FileType::DVIPSCONFIG,
"dvips config",
"Dvips",
"",
R_(MIKTEX_PATH_DVIPS_DIR),
"TEXCONFIG");
break;
case FileType::ENC:
RegisterFileType (
FileType::ENC,
"enc",
0,
".enc",
P6_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_ENC_DIR),
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR)),
P2_("ENCFONTS", "TEXFONTS"));
break;
case FileType::EXE:
#if defined(MIKTEX_WINDOWS)
case FileType::WindowsCommandScriptFile:
#endif
{
string extensions;
#if defined(MIKTEX_WINDOWS)
if (! Utils::GetEnvironmentString("PATHEXT", extensions)
|| extensions.empty())
{
extensions = P3_(".com",".exe", ".bat");
}
#elif defined(MIKTEX_EXE_FILE_SUFFIX)
extensions = MIKTEX_EXE_FILE_SUFFIX;
#endif
string exePath;
PathName userBinDir = GetSpecialPath(SpecialPath::UserInstallRoot);
userBinDir += MIKTEX_PATH_BIN_DIR;
userBinDir.Canonicalize ();
if (! IsAdminMode()
&& ! Utils::Contains(exePath.c_str(),
userBinDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += userBinDir.Get();
}
PathName commonBinDir = GetSpecialPath(SpecialPath::CommonInstallRoot);
commonBinDir += MIKTEX_PATH_BIN_DIR;
commonBinDir.Canonicalize ();
if (! Utils::Contains(exePath.c_str(),
commonBinDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += commonBinDir.Get();
}
string str;
if (Utils::GetEnvironmentString(MIKTEX_ENV_BIN_DIR, str))
{
PathName binDir = str;
binDir.Canonicalize ();
if (! Utils::Contains(exePath.c_str(),
binDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += binDir.Get();
}
}
PathName myLocation = GetMyLocation(true);
if (! Utils::Contains(exePath.c_str(),
myLocation.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += myLocation.Get();
}
if (fileType.Get() == FileType::EXE)
{
RegisterFileType (
FileType::EXE,
"exe",
0,
extensions.c_str(),
exePath.c_str(),
"");
}
#if defined(MIKTEX_WINDOWS)
else if (fileType.Get() == FileType::WindowsCommandScriptFile)
{
RegisterFileType (
FileType::WindowsCommandScriptFile,
"Windows command script file",
0,
P2_(".bat", ".cmd"),
P_(R_(MIKTEX_PATH_SCRIPT_DIR), exePath.c_str()),
"");
}
#endif
break;
}
case FileType::FEA:
RegisterFileType (
FileType::FEA,
"font feature files",
0,
".fea",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_FEATURE_DIR)),
"FONTFEATURES");
break;
case FileType::FMT:
RegisterFileType (
FileType::FMT,
"fmt",
"TeX",
".fmt",
P2_(CURRENT_DIRECTORY, s_(MIKTEX_PATH_FMT_DIR "/{$engine,}")),
"");
break;
case FileType::GF:
RegisterFileType (
FileType::GF,
"gf",
0,
".gf",
// <todo>
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
// <todo/>
P3_("GFFONTS", "GLYPHFONTS", "TEXFONTS"));
break;
case FileType::GLYPHFONT:
RegisterFileType (
FileType::GLYPHFONT,
"bitmap font",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
P2_("GLYPHFONTS", "TEXFONTS"));
break;
case FileType::GRAPHICS:
RegisterFileType (
FileType::GRAPHICS,
"graphic/figure",
0,
P3_(".eps", ".epsi",".png"),
P4_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_TEX_DIR)),
P2_("TEXPICTS", "TEXINPUTS"));
break;
case FileType::HBF:
RegisterFileType (
FileType::HBF,
"hbf",
0,
".hbf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_HBF_DIR),
R_(MIKTEX_PATH_TYPE1_DIR)),
"");
break;
case FileType::IST:
RegisterFileType (
FileType::IST,
"ist",
"MakeIndex",
".ist",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MAKEINDEX_DIR)),
P2_("TEXINDEXSTYLE", "INDEXSTYLE"));
break;
case FileType::LIG:
RegisterFileType (
FileType::LIG,
"lig files",
0,
".lig",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_LIG_DIR)),
"TEXFONTS");
break;
case FileType::LUA:
RegisterFileType (
FileType::LUA,
"lua",
0,
P7_(".lua", ".luatex", ".luc", ".luctex", ".texlua", ".texluc", ".tlu"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}/{lua,}"),
GetFileTypeInfo(FileType::TEX).searchPath.c_str()),
"LUAINPUTS");
break;
case FileType::MAP:
RegisterFileType (
FileType::MAP,
"map",
0,
".map",
P6_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_MAP_DIR "/{$progname,pdftex,dvips,}"),
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR)),
P2_("TEXFONTMAPS", "TEXFONTS"));
break;
case FileType::MEM:
RegisterFileType (
FileType::MEM,
"mem",
"MetaPost",
".mem",
CURRENT_DIRECTORY,
"");
break;
case FileType::MF:
RegisterFileType (
FileType::MF,
"mf",
"METAFONT",
".mf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_METAFONT_DIR),
R_(MIKTEX_PATH_FONT_SOURCE_DIR)),
"MFINPUTS");
break;
case FileType::MFPOOL:
RegisterFileType (
FileType::MFPOOL,
"mfpool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("MFPOOL", "TEXMFINI"));
break;
case FileType::MFT:
RegisterFileType (
FileType::MFT,
"mft",
0,
".mft",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MFT_DIR)),
"MFTINPUTS");
break;
case FileType::MISCFONT:
RegisterFileType (
FileType::MISCFONT,
"misc fonts",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MISCFONTS_DIR)),
P2_("MISCFONTS","TEXFONTS"));
break;
case FileType::MLBIB:
RegisterFileType (
FileType::MLBIB,
"mlbib",
0,
P2_(".mlbib", ".bib"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/bib/{mlbib,}")),
P3_("MLBIBINPUTS", "BIBINPUTS", "TEXBIB"));
break;
case FileType::MLBST:
RegisterFileType (
FileType::MLBST,
"mlbst",
0,
".bst",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/{mlbst,bst}")),
P2_( "MLBSTINPUTS", "BSTINPUTS"));
break;
case FileType::MP:
RegisterFileType (
FileType::MP,
"mp",
"MetaPost",
".mp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_METAPOST_DIR)),
"MPINPUTS");
break;
case FileType::MPPOOL:
RegisterFileType (
FileType::MPPOOL,
"mppool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("MPPOOL", "TEXMFINI"));
break;
case FileType::MPSUPPORT:
RegisterFileType (
FileType::MPSUPPORT,
"MetaPost support",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MPSUPPORT_DIR)),
"MPSUPPORT");
break;
case FileType::OCP:
RegisterFileType (
FileType::OCP,
"ocp",
"Omega",
".ocp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OCP_DIR)),
"OCPINPUTS");
break;
case FileType::OFM:
RegisterFileType (
FileType::OFM,
"ofm",
"Omega",
P2_(".ofm", ".tfm"),
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OFM_DIR),
R_(MIKTEX_PATH_TFM_DIR)),
P2_("OFMFONTS", "TEXFONTS"));
break;
case FileType::OPL:
RegisterFileType (
FileType::OPL,
"opl",
0,
".opl",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OPL_DIR)),
P2_("OPLFONTS", "TEXFONTS"));
break;
case FileType::OTP:
RegisterFileType (
FileType::OTP,
"otp",
"otp2ocp",
".otp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OTP_DIR)),
"OTPINPUTS");
break;
case FileType::OTF:
RegisterFileType (
FileType::OTF,
"opentype fonts",
0,
".otf",
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OPENTYPE_DIR),
GetLocalFontDirectories().c_str()),
P2_("OPENTYPEFONTS", "TEXFONTS"));
break;
case FileType::OVF:
RegisterFileType (
FileType::OVF,
"ovf",
0,
".ovf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OVF_DIR),
R_(MIKTEX_PATH_VF_DIR)),
P2_("OVFFONTS", "TEXFONTS"));
break;
case FileType::OVP:
RegisterFileType (
FileType::OVP,
"ovp",
0,
".ovp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OVP_DIR)),
P2_("OVPFONTS", "TEXFONTS"));
break;
case FileType::PDFTEXCONFIG:
RegisterFileType (
FileType::PDFTEXCONFIG,
"pdftex config",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_PDFTEX_DIR "/{$progname,}")),
"PDFTEXCONFIG");
break;
case FileType::PERLSCRIPT:
RegisterFileType (
FileType::PERLSCRIPT,
"perlscript",
0,
".pl",
P8_(R_(MIKTEX_PATH_SCRIPT_DIR),
R_(MIKTEX_PATH_CONTEXT_DIR),
R_(MIKTEX_PATH_MIKTEX_DIR),
R_(MIKTEX_PATH_NTS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_PSUTILS_DIR),
R_(MIKTEX_PATH_SOURCE_DIR),
R_(MIKTEX_PATH_TEX_DIR)),
"");
break;
case FileType::PK:
RegisterFileType (
FileType::PK,
"pk",
0,
".pk",
// <todo>
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
// </todo>
"");
break;
case FileType::PROGRAMBINFILE:
RegisterFileType (
FileType::PROGRAMBINFILE,
"other binary files",
0,
"",
P2_(CURRENT_DIRECTORY, R_("/$progname")),
"");
break;
case FileType::PROGRAMTEXTFILE:
RegisterFileType (
FileType::PROGRAMTEXTFILE,
"other text files",
0,
"",
P2_(CURRENT_DIRECTORY, R_("/$progname")),
"");
break;
case FileType::PSHEADER:
RegisterFileType (
FileType::PSHEADER,
"PostScript header",
0,
P2_(".pro", ".enc"),
P10_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR),
R_(MIKTEX_PATH_ENC_DIR),
R_(MIKTEX_PATH_TYPE1_DIR),
R_(MIKTEX_PATH_TYPE42_DIR),
R_(MIKTEX_PATH_TYPE3_DIR),
"$psfontdirs"),
P2_("TEXPSHEADERS", "PSHEADERS"));
break;
case FileType::SCRIPT:
RegisterFileType (
FileType::SCRIPT,
"texmfscripts",
0,
"",
R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}"),
"TEXMFSCRIPTS");
break;
case FileType::SFD:
RegisterFileType (
FileType::SFD,
"subfont definition files",
0,
".sfd",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SFD_DIR)),
P2_("SFDFONTS", "TEXFONTS"));
break;
case FileType::TCX:
RegisterFileType (
FileType::TCX,
"tcx",
0,
".tcx",
P3_(CURRENT_DIRECTORY,
S_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
S_(MIKTEX_PATH_WEB2C_DIR)),
"");
break;
case FileType::TEX:
RegisterFileType (
FileType::TEX,
"tex",
"TeX",
".tex",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TEX_DIR "/{$progname,generic,}")),
"TEXINPUTS");
break;
case FileType::TEXPOOL:
RegisterFileType (
FileType::TEXPOOL,
"texpool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("TEXPOOL", "TEXMFINI"));
break;
case FileType::TEXSOURCE:
RegisterFileType (
FileType::TEXSOURCE,
"TeX system sources",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SOURCE_DIR)),
"TEXSOURCES");
break;
case FileType::TEXSYSDOC:
RegisterFileType (
FileType::TEXSYSDOC,
"TeX system documentation",
0,
#if defined(MIKTEX_WINDOWS)
P6_(".chm", ".dvi", ".html", ".txt", ".pdf", ".ps"),
#else
P5_(".dvi", ".html", ".txt", ".pdf", ".ps"),
#endif
P2_(R_(MIKTEX_PATH_MIKTEX_DOC_DIR),
R_(MIKTEX_PATH_DOC_DIR)),
"TEXDOCS");
break;
case FileType::TFM:
RegisterFileType (
FileType::TFM,
"tfm",
0,
".tfm",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TFM_DIR)),
P2_("TFMFONTS", "TEXFONTS"));
break;
case FileType::TROFF:
RegisterFileType (
FileType::TROFF,
"troff fonts",
0,
"",
"",
"TRFONTS");
break;
case FileType::TTF:
RegisterFileType (
FileType::TTF,
"truetype fonts",
0,
P2_(".ttf", ".ttc"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_TRUETYPE_DIR),
GetLocalFontDirectories().c_str()),
P2_("TTFONTS", "TEXFONTS"));
break;
case FileType::TYPE1:
RegisterFileType (
FileType::TYPE1,
"type1 fonts",
0,
P2_(".pfb", ".pfa"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_TYPE1_DIR),
GetLocalFontDirectories().c_str()),
P5_("T1FONTS", "T1INPUTS", "TEXFONTS", "TEXPSHEADERS", "PSHEADERS"));
break;
case FileType::TYPE42:
RegisterFileType (
FileType::TYPE42,
"type42 fonts",
0,
#if defined(MIKTEX_WINDOWS)
".t42",
#else
P2_(".t42", ".T42"),
#endif
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TYPE42_DIR)),
P2_("T42FONTS", "TEXFONTS"));
break;
case FileType::VF:
RegisterFileType (
FileType::VF,
"vf",
0,
".vf",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_VF_DIR)),
P2_("VFFONTS", "TEXFONTS"));
break;
case FileType::WEB:
RegisterFileType (
FileType::WEB,
"web",
0,
".web",
R_(MIKTEX_PATH_WEB_DIR),
"WEBINPUTS");
break;
case FileType::WEB2C:
RegisterFileType (
FileType::WEB2C,
"web2c files",
0,
"",
R_(MIKTEX_PATH_WEB2C_DIR),
"");
break;
default:
UNEXPECTED_CONDITION ("SessionImpl::RegisterFileType");
}
}
char *GlyphListDlg(SplineFont *sf, char *glyphstr) {
int i, k, j;
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[4], boxes[3];
GGadgetCreateData *varray[6], *harray3[8];
GTextInfo label[4];
struct matrixinit mi;
struct glyph_list_dlg gld;
memset(&gld,0,sizeof(gld));
gld.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 = _("Extender Glyphs (kashidas, etc.)");
pos.x = pos.y = 0;
pos.width =GDrawPointsToPixels(NULL,GGadgetScale(268));
pos.height = GDrawPointsToPixels(NULL,375);
gld.gw = gw = GDrawCreateTopWindow(NULL,&pos,glyph_e_h,&gld,&wattrs);
GlyphMatrixInit(&mi,glyphstr,sf);
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_Glyphs;
gcd[k].gd.u.matrix = &mi;
gcd[k].gd.popup_msg = (unichar_t *) _( "A list of glyph names");
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_Glyph_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 = JSTF_Glyph_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_("GlyphName|New"));
GMatrixEditSetColumnCompletion(gcd[0].ret, 0, JSTF_Glyph_Completion );
GHVBoxSetExpandableCol(boxes[0].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[1].ret);
GDrawSetVisible(gw,true);
while ( !gld.done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
return( gld.ret );
}
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);
}
static char *JSTF_LookupListDlg(GGadget *g, int r, int c) {
int rows, k, j;
struct matrix_data *strings = GMatrixEditGet(g, &rows);
int cols = GMatrixEditGetColCnt(g);
char *lookupstr = strings[cols*r+c].u.md_str;
Jstf_Dlg *jd = GDrawGetUserData(GGadgetGetWindow(g));
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[4], boxes[3];
GGadgetCreateData *varray[6], *harray3[8];
GTextInfo label[4];
struct matrixinit mi;
struct glyph_list_dlg gld;
memset(&gld,0,sizeof(gld));
gld.sf = jd->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 =
c==1 ? _("Lookups turned ON to extend a line") :
c==2 ? _("Lookups turned OFF to extend a line") :
c==3 ? _("Lookups which specify the maximum size by which a glyph may grow") :
c==4 ? _("Lookups turned ON to shrink a line") :
c==5 ? _("Lookups turned OFF to shrink a line") :
_("Lookups which specify the maximum size by which a glyph may shrink");
pos.x = pos.y = 0;
pos.width =GDrawPointsToPixels(NULL,GGadgetScale(268));
pos.height = GDrawPointsToPixels(NULL,375);
gld.gw = gw = GDrawCreateTopWindow(NULL,&pos,lookup_e_h,&gld,&wattrs);
LookupMatrixInit(&mi,lookupstr,gld.sf,c);
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_Lookups;
gcd[k].gd.u.matrix = &mi;
gcd[k].gd.popup_msg = (unichar_t *) _( "A list of lookup names");
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_Lookup_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 = JSTF_Glyph_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);
free( mi.matrix_data );
GMatrixEditSetNewText(gcd[0].ret,S_("LookupName|New"));
GHVBoxSetExpandableCol(boxes[0].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[1].ret);
GDrawSetVisible(gw,true);
while ( !gld.done )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
GTextInfoListFree(lookup_ci[0].enum_vals);
lookup_ci[0].enum_vals = NULL;
return( gld.ret );
}
static char *JSTF_Langs(GGadget *g, int r, int c) {
int rows, i, k, j;
struct matrix_data *strings = GMatrixEditGet(g, &rows);
int cols = GMatrixEditGetColCnt(g);
Jstf_Dlg *jd = GDrawGetUserData(GGadgetGetWindow(g));
GRect pos;
GWindow gw;
GWindowAttrs wattrs;
GGadgetCreateData gcd[4], boxes[3];
GGadgetCreateData *varray[6], *harray3[8];
GTextInfo label[4];
struct matrixinit mi;
jd->ldone = false;
jd->here = (struct jstf_lang **) &strings[cols*r+3].u.md_addr;
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 Languages");
pos.x = pos.y = 0;
pos.width =GDrawPointsToPixels(NULL,GGadgetScale(268));
pos.height = GDrawPointsToPixels(NULL,375);
jd->lgw = gw = GDrawCreateTopWindow(NULL,&pos,langs_e_h,jd,&wattrs);
memset(&gcd,0,sizeof(gcd));
memset(&boxes,0,sizeof(boxes));
memset(&label,0,sizeof(label));
k=j=0;
JLanguageMatrixInit(&mi,*jd->here);
gcd[k].gd.pos.x = 10; gcd[k].gd.pos.y = gcd[1].gd.pos.y+14;
gcd[k].gd.pos.width = 900;
gcd[k].gd.flags = gg_enabled | gg_visible | gg_utf8_popup;
gcd[k].gd.cid = CID_Languages;
gcd[k].gd.u.matrix = &mi;
gcd[k].gd.popup_msg = (unichar_t *) _(
"A list of languages and the lookups turned on and off\n"
"for each to accomplish justification. A language may\n"
"appear more than once, in which case second (or third,\n"
"etc.) will be tried if the first fails.");
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_Language_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 = JSTF_Language_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_("Language|New"));
GMatrixEditSetUpDownVisible(gcd[0].ret,true);
GHVBoxSetExpandableCol(boxes[0].ret,gb_expandgluesame);
GHVBoxFitWindow(boxes[1].ret);
GDrawSetVisible(gw,true);
while ( !jd->ldone )
GDrawProcessOneEvent(NULL);
GDrawDestroyWindow(gw);
return( NULL );
}
static void
gsane_option_handler_handle_source(GSaneOptionHandler* handler, const SANE_Option_Descriptor* desc, SANE_Int n, const gchar*group)
{
GSaneOptionSource* self = GSANE_OPTION_SOURCE(handler);
GSList *iter, *values = gsane_option_handler_enum_list_string_values(handler, desc, n);
GnomeScanEnumValue *value, *default_value;
const gchar* src;
gchar *sources, *old;
/* override label to make source consistent accross backends,
this also allow to know whether ADF is selected. */
sources = NULL;
for(iter = values; iter; iter = iter->next) {
value = iter->data;
src = g_value_get_string(&value->value);
if (gsane_string_in_array(src, flatbed_src))
value->label = GSANE_SOURCE_FLATBED;
else if (gsane_string_in_array(src, adf_src))
value->label = GSANE_SOURCE_ADF;
else if (gsane_string_in_array(src, tma_src))
value->label = GSANE_SOURCE_TMA;
else if (gsane_string_in_array(src, negative_src))
value->label = GSANE_SOURCE_NEGATIVE;
if (sources) {
old = sources;
sources = g_strdup_printf("%s, \"%s\"", sources, value->label);
g_free(old);
}
else
sources = g_strdup_printf("\"%s\"", value->label);
}
default_value = gsane_option_handler_get_enum(handler, desc, n, values, NULL);
self->priv->option = GNOME_SCAN_OPTION(gnome_scan_option_enum_new(desc->name, _("Source"), S_(desc->desc), GNOME_SCAN_OPTION_GROUP_SCANNER, SANE_GETTEXT_PACKAGE,
default_value, values, GNOME_SCAN_OPTION_HINT_PRIMARY));
g_signal_connect_swapped(self->priv->option, "notify::value", G_CALLBACK(gsane_option_source_option_changed), self);
gnome_scan_node_install_option(GNOME_SCAN_NODE(handler->scanner), self->priv->option);
g_debug("\toption %02d : source = \"%s\", enum = {%s}", n, default_value->label, sources);
g_free(sources);
}
