void
lesstif_insert_style_buttons (Widget menu)
{
StyleButtons *sb;
int s, i;
num_style_buttons++;
s = num_style_buttons * sizeof (StyleButtons);
style_button_list = (StyleButtons *) realloc (style_button_list, s);
sb = style_button_list + num_style_buttons - 1;
for (i = 0; i < NUM_STYLES; i++)
{
Widget btn;
n = 0;
stdarg (XmNindicatorType, XmONE_OF_MANY);
stdarg (XmNlabelString,
XmStringCreatePCB (PCB->RouteStyle[i].Name));
btn = XmCreateToggleButton (menu, "style", args, n);
XtManageChild (btn);
XtAddCallback (btn, XmNvalueChangedCallback,
(XtCallbackProc) style_selected, (XtPointer) (size_t) i);
sb->w[i] = btn;
}
update_style_buttons ();
}
static void
nbcb_std_callback (Widget w, Std_Nbcb_Func v, XmPushButtonCallbackStruct * cbs)
{
int *posl, posc, i;
XmString **items, **selected;
if (XmListGetSelectedPos (netlist_list, &posl, &posc) == False)
return;
if (v == nbcb_find)
hid_actionl ("connection", "reset", NULL);
for (i=0; i<posc; i++)
{
LibraryMenuTypePtr net = & (PCB->NetlistLib.Menu[posl[i] - 1]);
v(net, posl[i]);
}
n = 0;
stdarg (XmNitems, &items);
XtGetValues (netlist_list, args, n);
selected = (XmString **) malloc (posc * sizeof (XmString *));
for (i=0; i<posc; i++)
selected[i] = items[posl[i]-1];
n = 0;
stdarg (XmNselectedItems, selected);
XtSetValues (netlist_list, args, n);
}
// *change 1.2.3a 'do_strict' insists that the signatures match exactly; otherwise
// we allow for looser matches (particularly method signatures)
bool Signature::match(const Signature& sig, bool do_strict) const
{
// Comparing signatures
// *fix 1.2.2b (Eric) Functions w/ no args can be incorrectly matched
if (this == &sig) return true;
if (size() != sig.size() || !class_ptr() != !sig.class_ptr()) return false;
// *fix 1.2.3 Method signatures made tighter in 'exact match' mode
if (class_ptr() != NULL && sig.class_ptr() != NULL) {
if ((do_strict && class_ptr() != sig.class_ptr())
|| !sig.class_ptr()->inherits_from(class_ptr()))
return false; // *fix 1.2.1 Member function signatures are distinct!
}
if (is_const() != sig.is_const())
return false; // *fix 0.9.6 constness makes signatures distinct
if (stdarg() != sig.stdarg())
return false; // *fix 1.2.3 (Eric) And so does whether this is stdarg or not
Signature::iterator ti,tio;
try {
for(ti = begin(), tio = sig.begin(); ti != end(); ++ti,++tio)
if (!(*ti == *tio)) return false;
} catch(...) {
return false;
}
//* return tio == sig.end() && ti == end(); //true;
return true;
}
static int
RouteStylesChanged (int argc, char **argv, Coord x, Coord y)
{
int i, j, h;
if (!PCB || !PCB->RouteStyle[0].Name)
return 0;
update_style_buttons ();
if (!style_dialog)
return 0;
for (j = 0; j < NUM_STYLES; j++)
{
h = hash (PCB->RouteStyle[j].Name);
if (name_hashes[j] == h)
continue;
name_hashes[j] = h;
n = 0;
stdarg (XmNlabelString,
XmStringCreatePCB (PCB->RouteStyle[j].Name));
if (style_dialog)
XtSetValues (style_pb[j], args, n);
for (i = 0; i < num_style_buttons; i++)
XtSetValues (style_button_list[i].w[j], args, n);
}
update_values ();
return 0;
}
static Widget
netlist_button (Widget parent, char *name, char *string,
Widget top, Widget bottom, Widget left, Widget right,
XtCallbackProc callback, void *user_data)
{
Widget rv;
XmString str;
#define NLB_W(w) if (w == NLB_FORM) { stdarg(XmN ## w ## Attachment, XmATTACH_FORM); } \
else if (w) { stdarg(XmN ## w ## Attachment, XmATTACH_WIDGET); \
stdarg (XmN ## w ## Widget, w); }
NLB_W (top);
NLB_W (bottom);
NLB_W (left);
NLB_W (right);
str = XmStringCreatePCB (string);
stdarg(XmNlabelString, str);
rv = XmCreatePushButton (parent, name, args, n);
XtManageChild (rv);
if (callback)
XtAddCallback (rv, XmNactivateCallback, callback, (XtPointer)user_data);
XmStringFree(str);
return rv;
}
static NOINLINE_NOCLONE void
backtracegen (void)
{
stdarg (1);
/* Here should be no instruction after the stdarg call as it is noreturn
function. It must be stdarg so that it is a call and not jump (jump as
a tail-call). */
}
static int
LesstifNetlistShow (int argc, char **argv, Coord x, Coord y)
{
if (build_netlist_dialog ())
return 0;
if (argc == 1)
{
LibraryMenuTypePtr net;
net = netnode_to_netname(argv[0]);
if (net)
{
XmString item;
int vis = 0;
/* Select net first, 'True' causes pick_net() to be invoked */
item = XmStringCreatePCB (net->Name);
XmListSelectItem (netlist_list, item, True);
XmListSetItem (netlist_list, item);
XmStringFree (item);
/* Now the netnode_list has the right contents */
item = XmStringCreatePCB (argv[0]);
XmListSelectItem (netnode_list, item, False);
/*
* Only force the item to the top if there are enough to scroll.
* A bug (?) in lesstif will cause the window to get ever wider
* if an XmList that doesn't require a scrollbar is forced to
* have one (when the top item is not the first item).
*/
n = 0;
stdarg (XmNvisibleItemCount, &vis);
XtGetValues (netnode_list, args, n);
if (n_netnode_strings > vis)
{
XmListSetItem (netnode_list, item);
}
XmStringFree (item);
}
else
{
/* Try the argument as a netname */
net = netname_to_netname(argv[0]);
if (net)
{
XmString item;
item = XmStringCreatePCB (net->Name);
XmListSetItem (netlist_list, item);
XmListSelectItem (netlist_list, item, True);
XmStringFree (item);
}
}
}
return 0;
}
static void
do_color (char *value, char *which)
{
XColor color;
if (XParseColor (display, cmap, value, &color))
if (XAllocColor (display, cmap, &color))
{
stdarg (which, color.pixel);
}
}
bool Function::can_match(int size)
// can this function in principle match an argument list of a particular size?
{
int asz = signature()->size();
if (!m_default_args) {
if (stdarg()) return size >= asz;
else return size == asz;
} else
return size >= m_default_index && size <= asz;
}
static void
pick_net (int pick)
{
LibraryMenuType *menu = Library.Menu + pick;
int i;
if (pick == last_pick)
return;
last_pick = pick;
if (libnode_strings)
free (libnode_strings);
libnode_strings = (XmString *) malloc (menu->EntryN * sizeof (XmString));
for (i = 0; i < menu->EntryN; i++)
libnode_strings[i] = XmStringCreatePCB (menu->Entry[i].ListEntry);
n = 0;
stdarg (XmNitems, libnode_strings);
stdarg (XmNitemCount, menu->EntryN);
XtSetValues (libnode_list, args, n);
}
static void
update_one_value (int i, Coord v)
{
char buf[100];
pcb_sprintf (buf, "%m+%.2mS", unit->allow, v);
XmTextSetString (style_values[i], buf);
n = 0;
stdarg (XmNlabelString, ustr);
XtSetValues (units_pb[i], args, n);
}
static void
pick_net (int pick)
{
LibraryMenuType *menu = PCB->NetlistLib.Menu + pick;
int i;
if (pick == last_pick)
return;
last_pick = pick;
if (netnode_strings)
free (netnode_strings); /* XXX leaked all XmStrings??? */
n_netnode_strings = menu->EntryN;
netnode_strings = (XmString *) malloc (menu->EntryN * sizeof (XmString));
for (i = 0; i < menu->EntryN; i++)
netnode_strings[i] = XmStringCreatePCB (menu->Entry[i].ListEntry);
n = 0;
stdarg (XmNitems, netnode_strings);
stdarg (XmNitemCount, menu->EntryN);
XtSetValues (netnode_list, args, n);
}
static int
LibraryChanged (int argc, char **argv, Coord x, Coord y)
{
int i;
if (!Library.MenuN)
return 0;
if (build_library_dialog ())
return 0;
last_pick = -1;
if (library_strings)
free (library_strings);
library_strings = (XmString *) malloc (Library.MenuN * sizeof (XmString));
for (i = 0; i < Library.MenuN; i++)
library_strings[i] = XmStringCreatePCB (Library.Menu[i].Name);
n = 0;
stdarg (XmNitems, library_strings);
stdarg (XmNitemCount, Library.MenuN);
XtSetValues (library_list, args, n);
pick_net (0);
return 0;
}
static int
LesstifNetlistChanged (int argc, char **argv, Coord x, Coord y)
{
int i;
if (!PCB->NetlistLib.MenuN)
return 0;
if (build_netlist_dialog ())
return 0;
last_pick = -1;
if (netlist_strings)
free (netlist_strings);
netlist_strings =
(XmString *) malloc (PCB->NetlistLib.MenuN * sizeof (XmString));
for (i = 0; i < PCB->NetlistLib.MenuN; i++)
netlist_strings[i] =
XmStringCreatePCB (PCB->NetlistLib.Menu[i].Name);
n = 0;
stdarg (XmNitems, netlist_strings);
stdarg (XmNitemCount, PCB->NetlistLib.MenuN);
XtSetValues (netlist_list, args, n);
pick_net (0);
return 0;
}
static void
callback (Widget w, Resource * node, XmPushButtonCallbackStruct * pbcs)
{
int vi;
have_xy = 0;
lesstif_show_crosshair (0);
if (pbcs->event && pbcs->event->type == KeyPress)
{
Dimension wx, wy;
Widget aw = XtWindowToWidget (display, pbcs->event->xkey.window);
action_x = pbcs->event->xkey.x;
action_y = pbcs->event->xkey.y;
if (aw)
{
Widget p = work_area;
while (p && p != aw)
{
n = 0;
stdarg (XmNx, &wx);
stdarg (XmNy, &wy);
XtGetValues (p, args, n);
action_x -= wx;
action_y -= wy;
p = XtParent (p);
}
if (p == aw)
have_xy = 1;
}
//printf("have xy from %s: %d %d\n", XtName(aw), action_x, action_y);
}
lesstif_need_idle_proc ();
for (vi = 1; vi < node->c; vi++)
if (resource_type (node->v[vi]) == 10)
if (hid_parse_actions (node->v[vi].value))
return;
}
static void
layerpick_button_callback (Widget w, int layer,
XmPushButtonCallbackStruct * pbcs)
{
int l, i;
char *name;
PCB->RatDraw = (layer == LB_RATS);
PCB->SilkActive = (layer == LB_SILK);
if (layer < max_copper_layer)
ChangeGroupVisibility (layer, 1, 1);
for (l = 0; l < num_layer_buttons; l++)
{
LayerButtons *lb = layer_button_list + l;
if (!lb->is_pick)
continue;
for (i = 0; i < LB_NUMPICK; i++)
XmToggleButtonSetState (lb->w[i], layer == i, False);
}
switch (layer)
{
case LB_RATS:
name = "Rats";
break;
case LB_SILK:
name = "Silk";
break;
default:
name = PCB->Data->Layer[layer].Name;
break;
}
n = 0;
stdarg (XmNbackground, fg_colors[layer]);
stdarg (XmNforeground, bg_color);
stdarg (XmNlabelString, XmStringCreateLocalized (name));
XtSetValues (lesstif_m_layer, args, n);
lesstif_invalidate_all ();
}
static void
show_one_layer_button (int layer, int set)
{
int l;
n = 0;
if (set)
{
stdarg (XmNforeground, bg_color);
stdarg (XmNbackground, fg_colors[layer]);
}
else
{
stdarg (XmNforeground, fg_colors[layer]);
stdarg (XmNbackground, bg_color);
}
stdarg (XmNset, set);
for (l = 0; l < num_layer_buttons; l++)
{
LayerButtons *lb = layer_button_list + l;
if (!lb->is_pick)
XtSetValues (lb->w[layer], args, n);
}
}
void
lesstif_get_xy (const char *message)
{
XmString ls = XmStringCreateLocalized ((char *)message);
XtManageChild (m_click);
n = 0;
stdarg (XmNlabelString, ls);
XtSetValues (m_click, args, n);
//printf("need xy: msg `%s'\n", msg);
need_xy = 1;
XBell (display, 100);
while (!have_xy)
{
XEvent e;
XtAppNextEvent (app_context, &e);
XtDispatchEvent (&e);
}
need_xy = 0;
have_xy = 1;
XtUnmanageChild (m_click);
}
static void
insert_layerview_buttons (Widget menu)
{
int i, s;
LayerButtons *lb;
num_layer_buttons++;
s = num_layer_buttons * sizeof (LayerButtons);
if (layer_button_list)
layer_button_list = (LayerButtons *) realloc (layer_button_list, s);
else
layer_button_list = (LayerButtons *) malloc (s);
lb = layer_button_list + num_layer_buttons - 1;
for (i = 0; i < LB_NUM; i++)
{
static char namestr[] = "Label ";
char *name = namestr;
Widget btn;
name[5] = 'A' + i;
switch (i)
{
case LB_SILK:
name = "Silk";
break;
case LB_RATS:
name = "Rat Lines";
break;
case LB_PINS:
name = "Pins/Pads";
break;
case LB_VIAS:
name = "Vias";
break;
case LB_BACK:
name = "Far Side";
break;
case LB_MASK:
name = "Solder Mask";
break;
}
n = 0;
if (i < MAX_LAYER && i < 9)
{
char buf[20], av[30];
Resource *ar;
XmString as;
sprintf (buf, "Ctrl-%d", i + 1);
as = XmStringCreateLocalized (buf);
stdarg (XmNacceleratorText, as);
ar = resource_create (0);
sprintf (av, "ToggleView(%d)", i + 1);
resource_add_val (ar, 0, strdup (av), 0);
resource_add_val (ar, 0, strdup (av), 0);
ar->flags |= FLAG_V;
sprintf (av, "Ctrl<Key>%d", i + 1);
note_accelerator (av, ar);
stdarg (XmNmnemonic, i + '1');
}
btn = XmCreateToggleButton (menu, name, args, n);
XtManageChild (btn);
XtAddCallback (btn, XmNvalueChangedCallback,
(XtCallbackProc) layer_button_callback, (XtPointer) (size_t) i);
lb->w[i] = btn;
if (i == LB_MASK)
note_widget_flag (btn, XmNset, "showmask");
}
lb->is_pick = 0;
LayersChanged (0, 0, 0, 0);
}
static void
insert_layerpick_buttons (Widget menu)
{
int i, s;
LayerButtons *lb;
num_layer_buttons++;
s = num_layer_buttons * sizeof (LayerButtons);
if (layer_button_list)
layer_button_list = (LayerButtons *) realloc (layer_button_list, s);
else
layer_button_list = (LayerButtons *) malloc (s);
lb = layer_button_list + num_layer_buttons - 1;
for (i = 0; i < LB_NUMPICK; i++)
{
static char namestr[] = "Label ";
char *name = namestr;
Widget btn;
name[5] = 'A' + i;
switch (i)
{
case LB_SILK:
name = "Silk";
break;
case LB_RATS:
name = "Rat Lines";
break;
}
n = 0;
if (i < MAX_LAYER && i < 9)
{
char buf[20], av[30];
Resource *ar;
XmString as;
sprintf (buf, "%d", i + 1);
as = XmStringCreateLocalized (buf);
stdarg (XmNacceleratorText, as);
ar = resource_create (0);
switch (i)
{
case LB_SILK:
strcpy (av, "SelectLayer(Silk)");
break;
case LB_RATS:
strcpy (av, "SelectLayer(Rats)");
break;
default:
sprintf (av, "SelectLayer(%d)", i + 1);
break;
}
resource_add_val (ar, 0, strdup (av), 0);
resource_add_val (ar, 0, strdup (av), 0);
ar->flags |= FLAG_V;
sprintf (av, "<Key>%d", i + 1);
note_accelerator (av, ar);
stdarg (XmNmnemonic, i + '1');
}
stdarg (XmNindicatorType, XmONE_OF_MANY);
btn = XmCreateToggleButton (menu, name, args, n);
XtManageChild (btn);
XtAddCallback (btn, XmNvalueChangedCallback,
(XtCallbackProc) layerpick_button_callback,
(XtPointer) (size_t) i);
lb->w[i] = btn;
}
lb->is_pick = 1;
LayersChanged (0, 0, 0, 0);
}
static int
build_library_dialog ()
{
if (!mainwind)
return 1;
if (library_dialog)
return 0;
n = 0;
stdarg (XmNresizePolicy, XmRESIZE_GROW);
stdarg (XmNtitle, "Element Library");
library_dialog = XmCreateFormDialog (mainwind, "library", args, n);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_FORM);
stdarg (XmNbottomAttachment, XmATTACH_FORM);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNvisibleItemCount, 10);
library_list = XmCreateScrolledList (library_dialog, "nets", args, n);
XtManageChild (library_list);
XtAddCallback (library_list, XmNbrowseSelectionCallback,
(XtCallbackProc) library_browse, 0);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_FORM);
stdarg (XmNbottomAttachment, XmATTACH_FORM);
stdarg (XmNrightAttachment, XmATTACH_FORM);
stdarg (XmNleftAttachment, XmATTACH_WIDGET);
stdarg (XmNleftWidget, library_list);
libnode_list = XmCreateScrolledList (library_dialog, "nodes", args, n);
XtManageChild (libnode_list);
XtAddCallback (libnode_list, XmNbrowseSelectionCallback,
(XtCallbackProc) libnode_select, 0);
return 0;
}
static int
AdjustStyle (int argc, char **argv, Coord x, Coord y)
{
if (!mainwind)
return 1;
if (style_dialog == 0)
{
int i;
unit = Settings.grid_unit;
ustr = XmStringCreateLocalized ((char *)unit->suffix);
n = 0;
stdarg (XmNautoUnmanage, False);
stdarg (XmNtitle, "Route Styles");
style_dialog = XmCreateFormDialog (mainwind, "style", args, n);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_FORM);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNrightAttachment, XmATTACH_FORM);
value_form = XmCreateForm (style_dialog, "values", args, n);
XtManageChild (value_form);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_FORM);
stdarg (XmNrightAttachment, XmATTACH_FORM);
stdarg (XmNbottomAttachment, XmATTACH_FORM);
stdarg (XmNfractionBase, 4);
stdarg (XmNresizePolicy, XmRESIZE_GROW);
units_form = XmCreateForm (value_form, "units", args, n);
XtManageChild (units_form);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_FORM);
stdarg (XmNbottomAttachment, XmATTACH_FORM);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNfractionBase, 4);
value_labels = XmCreateForm (value_form, "values", args, n);
XtManageChild (value_labels);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_FORM);
stdarg (XmNbottomAttachment, XmATTACH_FORM);
stdarg (XmNrightAttachment, XmATTACH_WIDGET);
stdarg (XmNrightWidget, units_form);
stdarg (XmNleftAttachment, XmATTACH_WIDGET);
stdarg (XmNleftWidget, value_labels);
stdarg (XmNfractionBase, 4);
value_texts = XmCreateForm (value_form, "values", args, n);
XtManageChild (value_texts);
for (i = 0; i < SSNUM; i++)
{
style_values[i] = style_value (i);
name_hashes[i] = hash (PCB->RouteStyle[i].Name);
}
for (i = 0; i < NUM_STYLES; i++)
style_pb[i] = style_button (i);
update_values ();
update_style_buttons ();
}
XtManageChild (style_dialog);
return 0;
}
static Widget
style_button (int i)
{
Widget pb, set;
n = 0;
stdarg (XmNtopAttachment, XmATTACH_WIDGET);
stdarg (XmNtopWidget, i ? style_pb[i - 1] : value_form);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNlabelString, XmStringCreatePCB ("Name"));
set = XmCreatePushButton (style_dialog, "style", args, n);
XtManageChild (set);
XtAddCallback (set, XmNactivateCallback,
(XtCallbackProc) style_name_cb, (XtPointer) (size_t) i);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_WIDGET);
stdarg (XmNtopWidget, i ? style_pb[i - 1] : value_form);
stdarg (XmNleftAttachment, XmATTACH_WIDGET);
stdarg (XmNleftWidget, set);
stdarg (XmNlabelString, XmStringCreatePCB ("Set"));
set = XmCreatePushButton (style_dialog, "style", args, n);
XtManageChild (set);
XtAddCallback (set, XmNactivateCallback,
(XtCallbackProc) style_set_cb, (XtPointer) (size_t) i);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_WIDGET);
stdarg (XmNtopWidget, i ? style_pb[i - 1] : value_form);
stdarg (XmNrightAttachment, XmATTACH_FORM);
stdarg (XmNleftAttachment, XmATTACH_WIDGET);
stdarg (XmNleftWidget, set);
stdarg (XmNlabelString, XmStringCreatePCB (PCB->RouteStyle[i].Name));
stdarg (XmNindicatorType, XmONE_OF_MANY);
stdarg (XmNalignment, XmALIGNMENT_BEGINNING);
pb = XmCreateToggleButton (style_dialog, "style", args, n);
XtManageChild (pb);
XtAddCallback (pb, XmNvalueChangedCallback,
(XtCallbackProc) style_selected, (XtPointer) (size_t) i);
return pb;
}
static Widget
style_value (int i)
{
Widget w, l;
n = 0;
stdarg (XmNtopAttachment, XmATTACH_POSITION);
stdarg (XmNtopPosition, i);
stdarg (XmNbottomAttachment, XmATTACH_POSITION);
stdarg (XmNbottomPosition, i + 1);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNrightAttachment, XmATTACH_FORM);
stdarg (XmNalignment, XmALIGNMENT_END);
l = XmCreateLabel (value_labels, value_names[i], args, n);
XtManageChild (l);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_POSITION);
stdarg (XmNtopPosition, i);
stdarg (XmNbottomAttachment, XmATTACH_POSITION);
stdarg (XmNbottomPosition, i + 1);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNrightAttachment, XmATTACH_FORM);
stdarg (XmNcolumns, 8);
w = XmCreateTextField (value_texts, value_names[i], args, n);
XtAddCallback (w, XmNvalueChangedCallback,
(XtCallbackProc) style_value_cb, (XtPointer) (size_t) i);
XtManageChild (w);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_POSITION);
stdarg (XmNtopPosition, i);
stdarg (XmNbottomAttachment, XmATTACH_POSITION);
stdarg (XmNbottomPosition, i + 1);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNrightAttachment, XmATTACH_FORM);
stdarg (XmNlabelString, ustr);
units_pb[i] = XmCreatePushButton (units_form, value_names[i], args, n);
XtAddCallback (units_pb[i], XmNactivateCallback,
(XtCallbackProc) units_cb, (XtPointer) (size_t) i);
XtManageChild (units_pb[i]);
return w;
}
static void
add_resource_to_menu (Widget menu, Resource * node, XtCallbackProc callback)
{
int i, j;
char *v;
Widget sub, btn;
Resource *r;
for (i = 0; i < node->c; i++)
switch (resource_type (node->v[i]))
{
case 101: /* named subnode */
n = 0;
stdarg (XmNtearOffModel, XmTEAR_OFF_ENABLED);
sub = XmCreatePulldownMenu (menu, node->v[i].name, args, n);
XtSetValues (sub, args, n);
n = 0;
stdarg (XmNsubMenuId, sub);
btn = XmCreateCascadeButton (menu, node->v[i].name, args, n);
XtManageChild (btn);
add_resource_to_menu (sub, node->v[i].subres, callback);
break;
case 1: /* unnamed subres */
n = 0;
#if 0
if ((v = resource_value (node->v[i].subres, "fg")))
{
do_color (v, XmNforeground);
}
if ((v = resource_value (node->v[i].subres, "bg")))
{
do_color (v, XmNbackground);
}
if ((v = resource_value (node->v[i].subres, "font")))
{
XFontStruct *fs = XLoadQueryFont (display, v);
if (fs)
{
XmFontList fl =
XmFontListCreate (fs, XmSTRING_DEFAULT_CHARSET);
stdarg (XmNfontList, fl);
}
}
#endif
if ((v = resource_value (node->v[i].subres, "m")))
{
stdarg (XmNmnemonic, v);
}
if ((r = resource_subres (node->v[i].subres, "a")))
{
XmString as = XmStringCreateLocalized (r->v[0].value);
stdarg (XmNacceleratorText, as);
//stdarg(XmNaccelerator, r->v[1].value);
note_accelerator (r->v[1].value, node->v[i].subres);
}
v = "button";
for (j = 0; j < node->v[i].subres->c; j++)
if (resource_type (node->v[i].subres->v[j]) == 10)
{
v = node->v[i].subres->v[j].value;
break;
}
stdarg (XmNlabelString, XmStringCreateLocalized (v));
if (node->v[i].subres->flags & FLAG_S)
{
int nn = n;
stdarg (XmNtearOffModel, XmTEAR_OFF_ENABLED);
sub = XmCreatePulldownMenu (menu, v, args + nn, n - nn);
n = nn;
stdarg (XmNsubMenuId, sub);
btn = XmCreateCascadeButton (menu, "menubutton", args, n);
XtManageChild (btn);
add_resource_to_menu (sub, node->v[i].subres, callback);
}
else
{
Resource *radio = resource_subres (node->v[i].subres, "radio");
char *checked = resource_value (node->v[i].subres, "checked");
char *label = resource_value (node->v[i].subres, "sensitive");
if (radio)
{
ToggleItem *ti = (ToggleItem *) malloc (sizeof (ToggleItem));
ti->next = toggle_items;
ti->group = radio->v[0].value;
ti->item = radio->v[1].value;
ti->callback = callback;
ti->node = node->v[i].subres;
toggle_items = ti;
if (resource_value (node->v[i].subres, "set"))
{
stdarg (XmNset, True);
}
stdarg (XmNindicatorType, XmONE_OF_MANY);
btn = XmCreateToggleButton (menu, "menubutton", args, n);
ti->w = btn;
XtAddCallback (btn, XmNvalueChangedCallback,
(XtCallbackProc) radio_callback,
(XtPointer) ti);
}
else if (checked)
{
if (strchr (checked, ','))
stdarg (XmNindicatorType, XmONE_OF_MANY);
else
stdarg (XmNindicatorType, XmN_OF_MANY);
btn = XmCreateToggleButton (menu, "menubutton", args, n);
XtAddCallback (btn, XmNvalueChangedCallback,
callback, (XtPointer) node->v[i].subres);
}
else if (label && strcmp (label, "false") == 0)
{
stdarg (XmNalignment, XmALIGNMENT_BEGINNING);
btn = XmCreateLabel (menu, "menulabel", args, n);
}
else
{
btn = XmCreatePushButton (menu, "menubutton", args, n);
XtAddCallback (btn, XmNactivateCallback,
callback, (XtPointer) node->v[i].subres);
}
for (j = 0; j < node->v[i].subres->c; j++)
switch (resource_type (node->v[i].subres->v[j]))
{
case 110: /* named value = X resource */
{
char *n = node->v[i].subres->v[j].name;
if (strcmp (n, "fg") == 0)
n = "foreground";
if (strcmp (n, "bg") == 0)
n = "background";
if (strcmp (n, "m") == 0
|| strcmp (n, "a") == 0
|| strcmp (n, "sensitive") == 0)
break;
if (strcmp (n, "checked") == 0)
{
note_widget_flag (btn, XmNset,
node->v[i].subres->v[j].value);
break;
}
if (strcmp (n, "active") == 0)
{
note_widget_flag (btn, XmNsensitive,
node->v[i].subres->v[j].value);
break;
}
XtVaSetValues (btn, XtVaTypedArg,
n,
XtRString,
node->v[i].subres->v[j].value,
strlen (node->v[i].subres->v[j].value) + 1,
NULL);
}
break;
}
XtManageChild (btn);
}
break;
case 10: /* unnamed value */
n = 0;
if (node->v[i].value[0] == '@')
{
if (strcmp (node->v[i].value, "@layerview") == 0)
insert_layerview_buttons (menu);
if (strcmp (node->v[i].value, "@layerpick") == 0)
insert_layerpick_buttons (menu);
if (strcmp (node->v[i].value, "@routestyles") == 0)
lesstif_insert_style_buttons (menu);
}
else if (strcmp (node->v[i].value, "-") == 0)
{
btn = XmCreateSeparator (menu, "sep", args, n);
XtManageChild (btn);
}
else if (i > 0)
{
btn = XmCreatePushButton (menu, node->v[i].value, args, n);
XtManageChild (btn);
}
break;
}
}
static int
build_netlist_dialog ()
{
Widget b_sel, b_unsel, b_find, b_ripup, b_rat_on, b_rat_off, l_ops;
XmString ops_str;
if (!mainwind)
return 1;
if (netlist_dialog)
return 0;
n = 0;
stdarg (XmNresizePolicy, XmRESIZE_GROW);
stdarg (XmNtitle, "Netlists");
stdarg (XmNautoUnmanage, False);
netlist_dialog = XmCreateFormDialog (mainwind, "netlist", args, n);
n = 0;
b_rat_on = netlist_button (netlist_dialog, "rat_on", "Enable for rats",
0, NLB_FORM, NLB_FORM, 0,
(XtCallbackProc)nbcb_std_callback, (void *)nbcb_rat_on);
n = 0;
b_rat_off = netlist_button (netlist_dialog, "rat_off", "Disable for rats",
0, NLB_FORM, b_rat_on, 0,
(XtCallbackProc)nbcb_std_callback, (void *)nbcb_rat_off);
n = 0;
b_sel = netlist_button (netlist_dialog, "select", "Select",
0, b_rat_on, NLB_FORM, 0,
(XtCallbackProc)nbcb_std_callback, (void *)nbcb_select);
n = 0;
b_unsel = netlist_button (netlist_dialog, "deselect", "Deselect",
0, b_rat_on, b_sel, 0,
(XtCallbackProc)nbcb_std_callback, (void *)nbcb_deselect);
n = 0;
b_find = netlist_button (netlist_dialog, "find", "Find",
0, b_rat_on, b_unsel, 0,
(XtCallbackProc)nbcb_std_callback, (void *)nbcb_find);
n = 0;
b_ripup = netlist_button (netlist_dialog, "ripup", "Rip Up",
0, b_rat_on, b_find, 0,
(XtCallbackProc)nbcb_ripup, 0);
n = 0;
stdarg (XmNbottomAttachment, XmATTACH_WIDGET);
stdarg (XmNbottomWidget, b_sel);
stdarg (XmNleftAttachment, XmATTACH_FORM);
ops_str = XmStringCreatePCB ("Operations on selected net names:");
stdarg (XmNlabelString, ops_str);
l_ops = XmCreateLabel (netlist_dialog, "ops", args, n);
XtManageChild (l_ops);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_FORM);
stdarg (XmNbottomAttachment, XmATTACH_WIDGET);
stdarg (XmNbottomWidget, l_ops);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNrightAttachment, XmATTACH_POSITION);
stdarg (XmNrightPosition, 50);
stdarg (XmNvisibleItemCount, 10);
stdarg (XmNselectionPolicy, XmEXTENDED_SELECT);
netlist_list = XmCreateScrolledList (netlist_dialog, "nets", args, n);
XtManageChild (netlist_list);
XtAddCallback (netlist_list, XmNdefaultActionCallback, (XtCallbackProc)netlist_select, 0);
XtAddCallback (netlist_list, XmNextendedSelectionCallback, (XtCallbackProc)netlist_extend, 0);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_FORM);
stdarg (XmNbottomAttachment, XmATTACH_WIDGET);
stdarg (XmNbottomWidget, l_ops);
stdarg (XmNrightAttachment, XmATTACH_FORM);
stdarg (XmNleftAttachment, XmATTACH_POSITION);
stdarg (XmNleftPosition, 50);
netnode_list = XmCreateScrolledList (netlist_dialog, "nodes", args, n);
XtManageChild (netnode_list);
XtAddCallback (netnode_list, XmNbrowseSelectionCallback, (XtCallbackProc)netnode_browse, 0);
return 0;
}
static int
LayersChanged (int argc, char **argv, int x, int y)
{
int l, i, set;
char *name;
int current_layer;
if (!layer_button_list)
return 0;
if (PCB && PCB->Data)
{
DataType *d = PCB->Data;
for (i = 0; i < MAX_LAYER; i++)
fg_colors[i] = lesstif_parse_color (d->Layer[i].Color);
fg_colors[LB_SILK] = lesstif_parse_color (PCB->ElementColor);
fg_colors[LB_RATS] = lesstif_parse_color (PCB->RatColor);
fg_colors[LB_PINS] = lesstif_parse_color (PCB->PinColor);
fg_colors[LB_VIAS] = lesstif_parse_color (PCB->ViaColor);
fg_colors[LB_BACK] =
lesstif_parse_color (PCB->InvisibleObjectsColor);
fg_colors[LB_MASK] = lesstif_parse_color (PCB->MaskColor);
bg_color = lesstif_parse_color (Settings.BackgroundColor);
}
else
{
for (i = 0; i < MAX_LAYER; i++)
fg_colors[i] = lesstif_parse_color (Settings.LayerColor[i]);
fg_colors[LB_SILK] = lesstif_parse_color (Settings.ElementColor);
fg_colors[LB_RATS] = lesstif_parse_color (Settings.RatColor);
fg_colors[LB_PINS] = lesstif_parse_color (Settings.PinColor);
fg_colors[LB_VIAS] = lesstif_parse_color (Settings.ViaColor);
fg_colors[LB_BACK] =
lesstif_parse_color (Settings.InvisibleObjectsColor);
fg_colors[LB_MASK] = lesstif_parse_color (Settings.MaskColor);
bg_color = lesstif_parse_color (Settings.BackgroundColor);
}
if (PCB->RatDraw)
current_layer = LB_RATS;
else if (PCB->SilkActive)
current_layer = LB_SILK;
else
current_layer = LayerStack[0];
for (l = 0; l < num_layer_buttons; l++)
{
LayerButtons *lb = layer_button_list + l;
for (i = 0; i < (lb->is_pick ? LB_NUMPICK : LB_NUM); i++)
{
switch (i)
{
case LB_SILK:
set = PCB->ElementOn;
break;
case LB_RATS:
set = PCB->RatOn;
break;
case LB_PINS:
set = PCB->PinOn;
break;
case LB_VIAS:
set = PCB->ViaOn;
break;
case LB_BACK:
set = PCB->InvisibleObjectsOn;
break;
case LB_MASK:
set = TEST_FLAG (SHOWMASKFLAG, PCB);
break;
default: /* layers */
set = PCB->Data->Layer[i].On;
break;
}
n = 0;
if (i < MAX_LAYER && PCB->Data->Layer[i].Name)
{
XmString s = XmStringCreateLocalized (PCB->Data->Layer[i].Name);
stdarg (XmNlabelString, s);
}
if (!lb->is_pick)
{
if (set)
{
stdarg (XmNforeground, bg_color);
stdarg (XmNbackground, fg_colors[i]);
}
else
{
stdarg (XmNforeground, fg_colors[i]);
stdarg (XmNbackground, bg_color);
}
stdarg (XmNset, set);
}
else
{
stdarg (XmNforeground, bg_color);
stdarg (XmNbackground, fg_colors[i]);
stdarg (XmNset, current_layer == i ? True : False);
}
XtSetValues (lb->w[i], args, n);
if (i >= max_copper_layer && i < MAX_LAYER)
XtUnmanageChild(lb->w[i]);
else
XtManageChild(lb->w[i]);
}
}
if (lesstif_m_layer)
{
switch (current_layer)
{
case LB_RATS:
name = "Rats";
break;
case LB_SILK:
name = "Silk";
break;
default:
name = PCB->Data->Layer[current_layer].Name;
break;
}
n = 0;
stdarg (XmNbackground, fg_colors[current_layer]);
stdarg (XmNforeground, bg_color);
stdarg (XmNlabelString, XmStringCreateLocalized (name));
XtSetValues (lesstif_m_layer, args, n);
}
lesstif_update_layer_groups ();
return 0;
}
