void scrnInitX(void)
{
Widget toplevel, control;
Widget mb, fileMenu, viewMenu, confMenu, helpMenu;
Widget procFrame = NULL, bboxFrame = NULL;
#ifdef ICON_DEFINED
Pixmap icon;
#endif
XmString s;
Arg args[10];
unsigned i, n;
int argc = 0;
addRegwRsrcOpts();
addDatwRsrcOpts();
toplevel = XtAppInitialize(&app_context, "XSki",
options, topopts, &argc, NULL,
NULL, NULL, 0);
top_level = toplevel; /* XXX - temporary for Platform only */
XtGetApplicationResources(toplevel, &app_data,
resources, toprsrc, NULL, 0);
XtAppAddActions(app_context, actions, XtNumber(actions));
dpy = XtDisplay(toplevel);
#ifdef ICON_DEFINED
/* set default icon */
icon = XCreateBitmapFromData(dpy, RootWindowOfScreen(XtScreen(toplevel)),
icon_bits, icon_width, icon_height);
XtSetArg(args[0], XmNiconPixmap, icon);
XtSetValues(toplevel, args, 1);
#endif
#if 0
XSynchronize(dpy, True);
#endif
/* create control window manager */
control = XmCreateForm(toplevel, "control", NULL, 0);
XtManageChild(control);
/* Control window menubar */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
mb = XmCreateMenuBar(control, "mb", args, n);
XtManageChild(mb);
fileMenu = createMBitem(mb, "File");
viewMenu = createMBitem(mb, "View");
confMenu = createMBitem(mb, "Configure");
helpMenu = createMBitem(mb, "Help");
#if 0
createSubmenuItem(fileMenu, "load", loadCallback);
#else
createSubmenuItem(fileMenu, "load", 0);
#endif
createSubmenuItem(fileMenu, "save", 0);
createSubmenuItem(fileMenu, "trace", 0);
createSubmenuItem(fileMenu, "traceOn", 0);
createSubmenuItem(fileMenu, "traceOff", 0);
createSubmenuItem(fileMenu, "read", 0);
XtManageChild(XmCreateSeparatorGadget(fileMenu, "", NULL, 0));
createSubmenuItem(fileMenu, "quit", simCmdCallback);
createSubmenuItem(viewMenu, "program", programCallback);
createSubmenuItem(viewMenu, "data", dataCallback);
createSubmenuItem(viewMenu, "registers", regCallback);
createSubmenuItem(viewMenu, "cache", 0);
createSubmenuItem(viewMenu, "tlb", sdtCallback);
XtManageChild(XmCreateSeparatorGadget(viewMenu, "", NULL, 0));
createSubmenuItem(viewMenu, "callstack", cstCallback);
createSubmenuItem(viewMenu, "statistics", 0);
createSubmenuItem(viewMenu, "breakpoints", blistCallback);
createSubmenuItem(viewMenu, "branches", 0);
createSubmenuItem(viewMenu, "symbols", symlistCallback);
createSubmenuItem(viewMenu, "macros", 0);
#if 0
/* No support for window format yet */
createSubmenuItem(confMenu, "program", prgFmtCallback);
#else
createSubmenuItem(confMenu, "program", 0);
#endif
createSubmenuItem(confMenu, "data", 0);
#if 0
/* No support for window format yet */
createSubmenuItem(confMenu, "registers", regFmtCallback);
#else
createSubmenuItem(confMenu, "registers", 0);
#endif
createSubmenuItem(helpMenu, "context", 0);
createSubmenuItem(helpMenu, "overview", 0);
createSubmenuItem(helpMenu, "commands", cmdHelpCallback);
createSubmenuItem(helpMenu, "product", prodInfoCallback);
/* Control window processor option menu */
if (nproc > 1) {
Widget procMenu, proc[NPROC];
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
procFrame = XmCreateFrame(control, "", args, n);
XtManageChild(procFrame);
procMenu = XmCreatePulldownMenu(procFrame, "", NULL, 0);
for (i = 0; i < nproc; i++) {
char name[4];
(void)sprintf(name, "p%d", i);
proc[i] = XmCreatePushButton(procMenu, name, NULL, 0);
XtAddCallback(proc[i], XmNactivateCallback,
changeCprocCallback, (XtPointer)i);
}
XtManageChildren(proc, nproc);
n = 0;
XtSetArg(args[n], XmNsubMenuId, procMenu); n++;
XtManageChild(XmCreateOptionMenu(procFrame, "procOption", args, n));
}
/* Control window button box */
if (app_data.numButtons) {
Widget bbox, btns[20];
/* create button box manager */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, procFrame ? procFrame : mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
bboxFrame = XmCreateFrame(control, "", args, n);
XtManageChild(bboxFrame);
/* create button box window */
bbox = XmCreateRowColumn(bboxFrame, "bbox", NULL, 0);
XtManageChild(bbox);
/* create each button */
for (i = 0; i < app_data.numButtons; i++) {
char name[8];
(void)sprintf(name, "bb%d", i);
btns[i] = XmCreatePushButton(bbox, name, NULL, 0);
}
XtManageChildren(btns, app_data.numButtons);
}
/* Control window command area */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget,
bboxFrame ? bboxFrame : procFrame ? procFrame : mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
cmd = XmCreateCommand(control, "cmd", args, n);
XtManageChild(cmd);
XtAddCallback(cmd, XmNcommandEnteredCallback, simCmdCallback, 0);
/* command history box */
n = 0;
XtSetArg(args[0], XmNinitialFocus, cmd); n++;
XtSetValues(control, args, n);
cmdHist = XmCommandGetChild(cmd, XmDIALOG_HISTORY_LIST);
/* message window */
msgs = XmCreateScrolledText(control, "msgs", NULL, 0);
XtManageChild(msgs);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, cmd); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetValues(XtParent(msgs), args, n);
/* create stop simulation dialog */
/* Consider changing this to a button. This would allow other
functionality to still be active when simulation is going on.
For example, Help, Quit, opening and closing windows, etc. */
stopsim = XmCreateWorkingDialog(control, "stopsim", NULL, 0);
n = 0;
XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
s = XmStringCreateLocalized("Running...");
XtSetArg(args[n], XmNdialogTitle, s); n++;
s = XmStringCreateLocalized(" icnt: 0 ");
XtSetArg(args[n], XmNmessageString, s); n++;
s = XmStringCreateLocalized("Stop");
XtSetArg(args[n], XmNcancelLabelString, s); n++;
XtSetValues(stopsim, args, n);
XtAddCallback(stopsim, XmNcancelCallback, stop_execLoopXCB, NULL);
XtUnmanageChild(XmMessageBoxGetChild(stopsim, XmDIALOG_OK_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(stopsim, XmDIALOG_HELP_BUTTON));
XmStringFree(s);
/* XXX - This should probably be inside regwInit */
for (i = 0; i < topregw; i++)
regwtbl[i].show = app_data.showRs[i];
/* XXX - This should probably be inside datwInit */
for (i = 0; i < topdatw; i++)
datwtbl[i].show = app_data.viewDw[i];
prgwInit();
datwInit();
regwInit();
if (app_data.viewProg)
prgwDrawX();
datwDrawX();
if (app_data.viewRegs)
regwDrawX();
noscreen = NO;
XtRealizeWidget(toplevel);
}
// Create a separate tty window; return its name in TTYNAME, its
// process id in PID, its terminal type in TERM, and its window id in
// WINDOWID.
static void launch_separate_tty(string& ttyname, pid_t& pid, string& term,
Window& windowid, Widget origin)
{
// If we're already running, all is done.
if (pid > 0 && (remote_gdb() || kill(pid, 0) == 0))
return;
string term_command = app_data.term_command;
term_command.gsub("@FONT@", make_font(app_data, FixedWidthDDDFont));
static bool canceled;
canceled = false;
static Widget dialog = 0;
if (dialog == 0)
{
Arg args[10];
Cardinal arg = 0;
XtSetArg(args[arg], XmNdialogStyle,
XmDIALOG_FULL_APPLICATION_MODAL); arg++;
dialog = verify(XmCreateWorkingDialog(find_shell(origin),
XMST("launch_tty_dialog"),
args, arg));
XtUnmanageChild(XmMessageBoxGetChild(dialog,
XmDIALOG_OK_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(dialog,
XmDIALOG_HELP_BUTTON));
XtAddCallback(dialog, XmNcancelCallback, CancelTTYCB,
XtPointer(&canceled));
}
string base = term_command;
if (base.contains(' '))
base = base.before(' ');
MString msg = rm("Starting ") + tt(base) + rm("...");
XtVaSetValues(dialog, XmNmessageString, msg.xmstring(), XtPointer(0));
manage_and_raise(dialog);
wait_until_mapped(dialog);
StatusDelay delay("Starting execution window");
// Fill in defaults
ttyname = "";
pid = -1;
string command =
// Set up a temporary file in TMP.
"tmp=${TMPDIR-/tmp}/ddd$$; export tmp; "
// Be sure to remove it when exiting...
"trap \"rm -f $tmp\" 0; "
// ... or being interrupted.
"trap 'exit 1' 1 2 15; "
// Now execute the xterm command
+ term_command +
// which saves TTY, PID, TERM, and WINDOWID in TMP and goes to
// sleep forever. Signal 2 (SIGINT) is blocked for two
// reasons: first, we don't want ^C to kill the tty window;
// second, later invocations will send us SIGINT to find out
// whether we're still alive.
" '"
"echo `tty` $$ $TERM $WINDOWID >$tmp; "
"trap \"\" 2; "
"while true; do sleep 3600; done"
"' "
// The whole thing is redirected and in the background such
// that rsh won't wait for us.
">/dev/null </dev/null 2>&1 & "
// The main file waits for TMP to be created...
"while test ! -s $tmp; do sleep 1; done; "
// ...and sends TMP's contents to stdout, where DDD is waiting.
"cat $tmp";
if (pid > 0 && remote_gdb())
{
// We're already running. Don't start a new tty
// if the old one is still running.
std::ostringstream os;
os << "kill -2 " << pid << " 2>/dev/null"
<< " || ( " << command << " )";
command = string(os);
}
command = sh_command(command);
{
XtAppContext app_context = XtWidgetToApplicationContext(dialog);
LiterateAgent tty(app_context, command);
string reply = "";
tty.addHandler(Input, GotReplyHP, (void *)&reply);
tty.start();
while (!reply.contains('\n') && !canceled && tty.running())
XtAppProcessEvent(app_context, XtIMAll);
if (reply.length() > 2)
{
std::istringstream is(reply.chars());
is >> ttyname >> pid >> term >> windowid;
}
tty.terminate();
}
Widget XmCreateWorkingDialog_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateWorkingDialog(parent, name, arglist, argcount);}
// Create a new plot window
PlotAgent *new_plotter(const string& name, DispValue *source)
{
static int tics = 1;
string cmd = app_data.plot_command;
cmd.gsub("@FONT@", make_font(app_data, FixedWidthDDDFont));
string window_name = ddd_NAME "plot" + itostring(tics++);
if (cmd.contains("@NAME@"))
cmd.gsub("@NAME@", window_name);
else
cmd += " -name " + window_name;
// Create shell
PlotWindowInfo *plot = new_decoration(name);
if (plot == 0)
return 0;
plot->source = source;
plot->window_name = window_name;
XtVaSetValues(plot->shell, XmNuserData, XtPointer(True), XtPointer(0));
// Pop up a working dialog
static Widget dialog = 0;
if (dialog == 0)
{
Arg args[10];
Cardinal arg = 0;
dialog = verify(XmCreateWorkingDialog(find_shell(),
XMST("launch_plot_dialog"),
args, arg));
XtUnmanageChild(XmMessageBoxGetChild(dialog,
XmDIALOG_OK_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(dialog,
XmDIALOG_HELP_BUTTON));
}
XtRemoveAllCallbacks(dialog, XmNcancelCallback);
XtAddCallback(dialog, XmNcancelCallback, CancelPlotCB, XtPointer(plot));
plot->working_dialog = dialog;
string base = cmd;
if (base.contains(' '))
base = cmd.before(' ');
MString msg = rm("Starting ") + tt(base) + rm("...");
XtVaSetValues(dialog, XmNmessageString, msg.xmstring(), XtPointer(0));
manage_and_raise(dialog);
wait_until_mapped(dialog);
// Invoke plot process
PlotAgent *plotter =
new PlotAgent(XtWidgetToApplicationContext(plot->shell), cmd);
XtAddCallback(plot->shell, XtNpopdownCallback,
CancelPlotCB, XtPointer(plot));
if (plot->area != 0)
{
XtAddCallback(plot->area->widget(), XmNexposeCallback,
ExposePlotAreaCB, XtPointer(plot));
XtAddCallback(plot->area->widget(), XmNresizeCallback,
ResizePlotAreaCB, XtPointer(plot));
}
string init = app_data.plot_init_commands;
init.prepend("set term " + string(app_data.plot_term_type) + "\n");
if (!init.empty() && !init.contains('\n', -1))
init += '\n';
// Add trace handlers
plotter->addHandler(Input, TraceInputHP); // Gnuplot => DDD
plotter->addHandler(Output, TraceOutputHP); // DDD => Gnuplot
plotter->addHandler(Error, TraceErrorHP); // Gnuplot Errors => DDD
// Show Gnuplot Errors in status line
plotter->addHandler(Error, SetStatusHP, (void *)plot);
// Handle death
plotter->addHandler(Died, PlotterNotFoundHP, (void *)plot);
plotter->addHandler(Died, DeletePlotterHP, (void *)plot);
if (plot->area != 0)
plotter->addHandler(Plot, GetPlotHP, (void *)plot);
plotter->start_with(init);
plot->plotter = plotter;
return plotter;
}
extern Boolean
XltWorking(Widget w, String Question, int PercentDone)
{
static Widget Dialog = NULL;
static WorkingData_t Data;
static Boolean abortflag = False;
static Boolean mapped = False;
XmString string;
if (Dialog == NULL)
{
Widget shell = w;
Widget frame;
Widget frame_title;
XGCValues values;
Dialog = XmCreateWorkingDialog(shell, "Working", NULL, 0);
XtVaSetValues(Dialog,
XmNautoUnmanage, False,
NULL);
XtUnmanageChild(XmMessageBoxGetChild(Dialog, XmDIALOG_HELP_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(Dialog, XmDIALOG_CANCEL_BUTTON));
XtAddCallback(Dialog, XmNokCallback, (XtCallbackProc)callback, &abortflag);
XtAddCallback(Dialog, XmNunmapCallback, (XtCallbackProc)callback, &abortflag);
XtAddEventHandler(XtParent(Dialog),
StructureNotifyMask,
False,
(XtEventHandler)StructureNotifyHandler,
(XtPointer)&mapped);
mapped = False;
frame = XmCreateFrame(Dialog,"Frame",NULL,0);
frame_title = XmCreateLabel(frame,"Title", NULL,0);
XtVaSetValues(frame_title,
XmNchildType, XmFRAME_TITLE_CHILD,
NULL);
Data.Da = XmCreateDrawingArea(frame, "Graph", NULL, 0);
XtManageChild(frame_title);
XtManageChild(Data.Da);
XtManageChild(frame);
XtRealizeWidget(Dialog);
Data.Id = (XtIntervalId)NULL;
XtVaGetValues(Data.Da,
XmNforeground, &values.foreground,
XmNbackground, &values.background,
NULL);
Data.gc = XCreateGC(XtDisplay(Data.Da),
XtWindow(Data.Da),
GCForeground | GCBackground, &values);
}
if (Question)
{
string = XmStringCreateSimple(Question);
XtVaSetValues(Dialog,
XmNmessageString, string,
NULL);
XmStringFree(string);
}
if (PercentDone >= 0)
{
Data.percent = PercentDone;
}
switch (PercentDone)
{
case 0:
abortflag = False;
XtManageChild(Dialog);
if (Data.Id == (XtIntervalId)NULL)
{
XClearArea(XtDisplay(Data.Da),
XtWindow(Data.Da),
0, 0, 0, 0, False);
Data.Id = XtAppAddTimeOut(XtWidgetToApplicationContext(Dialog),
0, (XtTimerCallbackProc)UpdateGraph, &Data);
}
break;
case 100:
if (Data.Id != (XtIntervalId)NULL)
{
XtRemoveTimeOut(Data.Id);
Data.Id = (XtIntervalId)NULL;
}
while (XtIsManaged(Dialog) && !mapped)
{
XtAppProcessEvent(XtWidgetToApplicationContext(Dialog), XtIMXEvent);
}
UpdateGraph(&Data);
XtRemoveTimeOut(Data.Id);
Data.Id = (XtIntervalId)NULL;
XtUnmanageChild(Dialog);
while (!XtIsManaged(Dialog) && mapped)
{
XtAppProcessEvent(XtWidgetToApplicationContext(Dialog), XtIMXEvent);
}
abortflag = False;
break;
default:
{
XtInputMask mask;
while ((mask = (XtAppPending(XtWidgetToApplicationContext(Dialog)) & ~XtIMAlternateInput)))
{
XtAppProcessEvent(XtWidgetToApplicationContext(Dialog), mask);
}
if (!XtIsManaged(Dialog))
{
abortflag = True;
}
}
break;
}
return(abortflag);
}
void
InfoPop ( Widget parent, int type,
char *message, Boolean help,
Boolean cancel, void (*HelpCB)(),
void (*CancelCB)() )
{
Widget dialog;
XmString xmstr;
char buf[4096];
if ( message == NULL ) return;
/*
* Create an information dialog of the type requested in function call.
*/
switch ( type ) {
case ERROR:
dialog = XmCreateErrorDialog ( parent, "ERROR", NULL, 0 );
strcpy ( buf, "ERROR:\n" );
break;
case INFORMATION:
dialog = XmCreateInformationDialog ( parent, "INFORMATION", NULL, 0 );
strcpy ( buf, "INFORMATION:\n" );
break;
case QUESTION:
dialog = XmCreateQuestionDialog ( parent, "QUESTION", NULL, 0 );
strcpy ( buf, "QUESTION:\n" );
break;
case WARNING:
dialog = XmCreateWarningDialog ( parent, "WARNING", NULL, 0 );
strcpy ( buf, "WARNING:\n" );
break;
case WORKING:
dialog = XmCreateWorkingDialog ( parent, "WORKING", NULL, 0 );
strcpy ( buf, "WORKING:\n" );
break;
default:
break;
}
/*
* Write message to dialog.
*/
strcat ( buf, message );
xmstr = XmStringCreateLtoR ( buf, XmFONTLIST_DEFAULT_TAG);
XtVaSetValues ( dialog,
XmNmessageString, xmstr,
NULL );
XmStringFree ( xmstr );
/*
* Add callbacks to buttons or, alternatively, delete the buttons.
*/
if ( !help ) XtUnmanageChild (
XmMessageBoxGetChild ( dialog, XmDIALOG_HELP_BUTTON ) );
else
XtAddCallback ( dialog, XmNhelpCallback, HelpCB, NULL );
if ( !cancel ) XtUnmanageChild (
XmMessageBoxGetChild ( dialog, XmDIALOG_CANCEL_BUTTON ) );
else
XtAddCallback ( dialog, XmNcancelCallback, CancelCB, NULL );
/*
* Manage popup.
*/
XtManageChild ( dialog );
XtPopup ( XtParent ( dialog ), XtGrabNone );
}