static void ExportPlotCB(Widget w, XtPointer client_data, XtPointer call_data)
{
SelectPlotCB(w, client_data, call_data);
PlotWindowInfo *plot = (PlotWindowInfo *)client_data;
if (plot->export_dialog == 0)
{
Arg args[10];
Cardinal arg = 0;
Widget dialog =
verify(XmCreateFileSelectionDialog(plot->shell,
XMST("export_data"),
args, arg));
plot->export_dialog = dialog;
Delay::register_shell(dialog);
XtAddCallback(dialog, XmNokCallback, DoExportCB, client_data);
XtAddCallback(dialog, XmNcancelCallback, UnmanageThisCB,
XtPointer(dialog));
XtAddCallback(dialog, XmNhelpCallback, ImmediateHelpCB, XtPointer(0));
}
manage_and_raise(plot->export_dialog);
}
static void PlotterNotFoundHP(Agent *plotter, void *client_data, void *)
{
#if !NDEBUG
PlotWindowInfo *plot = (PlotWindowInfo *)client_data;
assert(plot->plotter == 0 || plot->plotter == plotter);
#endif
plotter->removeHandler(Died, PlotterNotFoundHP, client_data);
string base = app_data.plot_command;
if (base.contains(' '))
base = base.before(' ');
Arg args[10];
Cardinal arg = 0;
MString msg = rm( capitalize(base) + " could not be started.");
XtSetArg(args[arg], XmNmessageString, msg.xmstring()); arg++;
Widget dialog =
verify(XmCreateErrorDialog(find_shell(),
XMST("no_plotter_dialog"), args, arg));
XtUnmanageChild(XmMessageBoxGetChild
(dialog, XmDIALOG_CANCEL_BUTTON));
XtAddCallback(dialog, XmNhelpCallback, ImmediateHelpCB, XtPointer(0));
Delay::register_shell(dialog);
manage_and_raise(dialog);
}
// Create `Run' dialog
void gdbRunCB(Widget w, XtPointer, XtPointer)
{
if (run_dialog == 0)
{
Arg args[10];
int arg = 0;
run_dialog =
verify(XmCreateSelectionDialog(find_shell(w),
XMST("run_dialog"),
args, arg));
XtUnmanageChild(XmSelectionBoxGetChild(run_dialog,
XmDIALOG_APPLY_BUTTON));
Delay::register_shell(run_dialog);
XtAddCallback(run_dialog, XmNokCallback, gdbRunDCB, 0);
XtAddCallback(run_dialog, XmNapplyCallback, gdbRunDCB, 0);
XtAddCallback(run_dialog, XmNhelpCallback, ImmediateHelpCB, 0);
run_arguments_w = XmSelectionBoxGetChild(run_dialog, XmDIALOG_LIST);
XtAddCallback(run_arguments_w, XmNsingleSelectionCallback,
SelectRunArgsCB, 0);
XtAddCallback(run_arguments_w, XmNmultipleSelectionCallback,
SelectRunArgsCB, 0);
XtAddCallback(run_arguments_w, XmNextendedSelectionCallback,
SelectRunArgsCB, 0);
XtAddCallback(run_arguments_w, XmNbrowseSelectionCallback,
SelectRunArgsCB, 0);
}
update_run_arguments();
manage_and_raise(run_dialog);
}
void gdbOpenFileCB(Widget w, XtPointer, XtPointer)
{
static Widget dialog =
create_file_dialog(w, "exec_files",
searchRemoteExecFiles,
searchRemoteDirectories,
searchLocalExecFiles, 0,
openFileDone);
manage_and_raise(dialog);
}
void gdbOpenCoreCB(Widget w, XtPointer, XtPointer)
{
static Widget dialog =
create_file_dialog(w, "core_files",
searchRemoteCoreFiles, searchRemoteDirectories,
searchLocalCoreFiles, 0,
openCoreDone);
manage_and_raise(dialog);
warn_if_no_program(dialog);
}
void gdbOpenProcessCB(Widget w, XtPointer, XtPointer)
{
static Widget dialog = 0;
static Widget processes = 0;
if (dialog == 0)
{
Arg args[10];
int arg = 0;
XtSetArg(args[arg], XmNautoUnmanage, False); arg++;
dialog = verify(XmCreateSelectionDialog(find_shell(w),
XMST("processes"),
args, arg));
Delay::register_shell(dialog);
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_SELECTION_LABEL));
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_TEXT));
processes = XmSelectionBoxGetChild(dialog, XmDIALOG_LIST);
XtAddCallback(processes, XmNsingleSelectionCallback,
SelectProcessCB, XtPointer(processes));
XtAddCallback(processes, XmNmultipleSelectionCallback,
SelectProcessCB, XtPointer(processes));
XtAddCallback(processes, XmNextendedSelectionCallback,
SelectProcessCB, XtPointer(processes));
XtAddCallback(processes, XmNbrowseSelectionCallback,
SelectProcessCB, XtPointer(processes));
XtAddCallback(dialog, XmNokCallback,
openProcessDone, XtPointer(processes));
XtAddCallback(dialog, XmNapplyCallback,
gdbUpdateProcessesCB, XtPointer(processes));
XtAddCallback(dialog, XmNcancelCallback,
UnmanageThisCB, XtPointer(dialog));
XtAddCallback(dialog, XmNhelpCallback, ImmediateHelpCB, 0);
}
update_processes(processes, false);
manage_and_raise(dialog);
warn_if_no_program(dialog);
}
static void PlotCommandCB(Widget, XtPointer client_data, XtPointer)
{
PlotWindowInfo *plot = (PlotWindowInfo *)client_data;
if (plot->command_dialog == 0)
{
Arg args[10];
Cardinal arg = 0;
Widget dialog =
verify(XmCreatePromptDialog(plot->shell,
XMST("plot_command_dialog"),
args, arg));
Delay::register_shell(dialog);
plot->command_dialog = dialog;
Widget apply = XmSelectionBoxGetChild(dialog, XmDIALOG_APPLY_BUTTON);
XtManageChild(apply);
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_OK_BUTTON));
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_SELECTION_LABEL));
XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_TEXT));
XtAddCallback(dialog, XmNapplyCallback,
ApplyPlotCommandCB, XtPointer(client_data));
XtAddCallback(dialog, XmNhelpCallback,
ImmediateHelpCB, XtPointer(client_data));
arg = 0;
Widget command =
verify(XmCreateCommand(dialog, XMST("plot_command"), args, arg));
plot->command = command;
XtManageChild(command);
XtAddCallback(command, XmNcommandEnteredCallback,
DoPlotCommandCB, XtPointer(client_data));
XtAddCallback(command, XmNcommandChangedCallback,
EnableApplyCB, XtPointer(apply));
set_sensitive(apply, false);
}
manage_and_raise(plot->command_dialog);
}
void gdbOpenSourceCB(Widget w, XtPointer, XtPointer)
{
static Widget dialog =
create_file_dialog(w, "source_files",
searchRemoteSourceFiles, searchRemoteDirectories,
searchLocalSourceFiles, 0,
openSourceDone);
manage_and_raise(dialog);
open_source_msg();
if ((gdb->type() != JDB) && (gdb->type() != PYDB))
{
warn_if_no_program(dialog);
}
else
{
// JDB works well without executable
// PYDB doesn't use an executable
}
}
void TipOfTheDayCB(Widget w, XtPointer, XtPointer)
{
static Widget tip_dialog = 0;
if (tip_dialog == 0)
{
Arg args[10];
Cardinal arg = 0;
XtSetArg(args[arg], XmNautoUnmanage, False); arg++;
tip_dialog =
verify(XmCreateInformationDialog(find_shell(w),
XMST("tip_dialog"),
args, arg));
#if XmVersion >= 1002
arg = 0;
XtSetArg(args[arg], XmNset, app_data.startup_tips); arg++;
set_startup_tips_w =
verify(XmCreateToggleButton(tip_dialog,
XMST("set_startup_tips"),
args, arg));
XtAddCallback(set_startup_tips_w, XmNvalueChangedCallback,
SetStartupTipsCB, 0);
XtManageChild(set_startup_tips_w);
#endif
XtAddCallback(tip_dialog, XmNokCallback, UnmanageThisCB,
XtPointer(tip_dialog));
XtAddCallback(tip_dialog, XmNcancelCallback, PrevTipCB, 0);
XtAddCallback(tip_dialog, XmNhelpCallback, NextTipCB, 0);
XtAddCallback(tip_dialog, XmNunmapCallback, SaveTipCountCB, 0);
}
bool ok = refresh_tip_dialog(tip_dialog);
if (!ok)
return;
manage_and_raise(tip_dialog);
}
// Create `Make' dialog
void gdbMakeCB(Widget w, XtPointer, XtPointer)
{
if (!gdb->has_make_command())
return;
if (make_dialog == 0)
{
Arg args[10];
int arg = 0;
make_dialog =
verify(XmCreateSelectionDialog(find_shell(w),
XMST("make_dialog"),
args, arg));
XtUnmanageChild(XmSelectionBoxGetChild(make_dialog,
XmDIALOG_APPLY_BUTTON));
Delay::register_shell(make_dialog);
XtAddCallback(make_dialog, XmNokCallback, gdbMakeDCB, 0);
XtAddCallback(make_dialog, XmNapplyCallback, gdbMakeDCB, 0);
XtAddCallback(make_dialog, XmNhelpCallback, ImmediateHelpCB, 0);
make_arguments_w = XmSelectionBoxGetChild(make_dialog, XmDIALOG_LIST);
XtAddCallback(make_arguments_w, XmNsingleSelectionCallback,
SelectMakeArgsCB, 0);
XtAddCallback(make_arguments_w, XmNmultipleSelectionCallback,
SelectMakeArgsCB, 0);
XtAddCallback(make_arguments_w, XmNextendedSelectionCallback,
SelectMakeArgsCB, 0);
XtAddCallback(make_arguments_w, XmNbrowseSelectionCallback,
SelectMakeArgsCB, 0);
}
update_make_arguments();
manage_and_raise(make_dialog);
}
// Create `ChangeDirectory' dialog
void gdbChangeDirectoryCB(Widget w, XtPointer, XtPointer)
{
if (cd_dialog == 0)
{
Arg args[10];
int arg = 0;
cd_dialog =
verify(XmCreateSelectionDialog(find_shell(w),
XMST("cd_dialog"),
args, arg));
XtUnmanageChild(XmSelectionBoxGetChild(cd_dialog,
XmDIALOG_APPLY_BUTTON));
Delay::register_shell(cd_dialog);
XtAddCallback(cd_dialog, XmNokCallback, gdbChangeDirectoryDCB, 0);
XtAddCallback(cd_dialog, XmNapplyCallback, gdbChangeDirectoryDCB, 0);
XtAddCallback(cd_dialog, XmNhelpCallback, ImmediateHelpCB, 0);
cd_arguments_w = XmSelectionBoxGetChild(cd_dialog, XmDIALOG_LIST);
XtAddCallback(cd_arguments_w, XmNsingleSelectionCallback,
SelectChangeDirectoryArgsCB, 0);
XtAddCallback(cd_arguments_w, XmNmultipleSelectionCallback,
SelectChangeDirectoryArgsCB, 0);
XtAddCallback(cd_arguments_w, XmNextendedSelectionCallback,
SelectChangeDirectoryArgsCB, 0);
XtAddCallback(cd_arguments_w, XmNbrowseSelectionCallback,
SelectChangeDirectoryArgsCB, 0);
add_argument("..", cd_arguments, last_cd_argument,
cd_arguments_updated);
}
update_cd_arguments();
manage_and_raise(cd_dialog);
}
void TicTacToeCB(Widget, XtPointer, XtPointer)
{
static Widget dialog = 0;
if (dialog == 0)
{
Arg args[10];
int arg = 0;
XtSetArg(args[arg], XmNautoUnmanage, False); arg++;
dialog = verify(XmCreatePromptDialog(find_shell(),
XMST("tictactoe"), args, arg));
Delay::register_shell(dialog);
if (lesstif_version <= 79)
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_APPLY_BUTTON));
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_HELP_BUTTON));
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_TEXT));
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_SELECTION_LABEL));
XtAddCallback(dialog, XmNhelpCallback, ImmediateHelpCB, XtPointer(0));
XtAddCallback(dialog, XmNokCallback, ResetTicTacToeCB, XtPointer(0));
XtAddCallback(dialog, XmNcancelCallback, UnmanageThisCB,
XtPointer(dialog));
create_tictactoe(dialog);
}
ResetTicTacToeCB(0, 0, 0);
manage_and_raise(dialog);
}
void gdbLookupSourceCB(Widget w, XtPointer client_data, XtPointer call_data)
{
if (gdb->type() != GDB)
{
gdbOpenSourceCB(w, client_data, call_data);
return;
}
static Widget dialog = 0;
if (dialog == 0)
{
Arg args[10];
int arg = 0;
XtSetArg(args[arg], XmNautoUnmanage, False); arg++;
#if XmVersion >= 1002
XtSetArg(args[arg], XmNchildPlacement, XmPLACE_TOP); arg++;
#endif
dialog = verify(XmCreateSelectionDialog(find_shell(w),
XMST("sources"), args, arg));
Delay::register_shell(dialog);
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_SELECTION_LABEL));
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_TEXT));
arg = 0;
XtSetArg(args[arg], XmNmarginWidth, 0); arg++;
XtSetArg(args[arg], XmNmarginHeight, 0); arg++;
XtSetArg(args[arg], XmNborderWidth, 0); arg++;
XtSetArg(args[arg], XmNadjustMargin, False); arg++;
XtSetArg(args[arg], XmNshadowThickness, 0); arg++;
XtSetArg(args[arg], XmNspacing, 0); arg++;
Widget bigbox = XmCreateRowColumn(dialog, XMST("bigbox"), args, arg);
XtManageChild(bigbox);
arg = 0;
XtSetArg(args[arg], XmNmarginWidth, 0); arg++;
XtSetArg(args[arg], XmNmarginHeight, 0); arg++;
XtSetArg(args[arg], XmNborderWidth, 0); arg++;
XtSetArg(args[arg], XmNadjustMargin, False); arg++;
XtSetArg(args[arg], XmNshadowThickness, 0); arg++;
XtSetArg(args[arg], XmNspacing, 0); arg++;
Widget box = XmCreateRowColumn(bigbox, XMST("box"), args, arg);
XtManageChild(box);
arg = 0;
Widget label = XmCreateLabel(box, XMST("label"), args, arg);
XtManageChild(label);
arg = 0;
source_filter = XmCreateTextField(box, XMST("filter"), args, arg);
XtManageChild(source_filter);
arg = 0;
Widget sharedlibrary =
XmCreatePushButton(bigbox, XMST("sharedlibrary"), args, arg);
XtManageChild(sharedlibrary);
#if XmVersion >= 1002
arg = 0;
Widget lookup = XmCreatePushButton(dialog,
XMST("lookup"), args, arg);
XtManageChild(lookup);
#endif
source_list = XmSelectionBoxGetChild(dialog, XmDIALOG_LIST);
XtAddCallback(source_list, XmNsingleSelectionCallback,
SelectSourceCB, XtPointer(source_list));
XtAddCallback(source_list, XmNmultipleSelectionCallback,
SelectSourceCB, XtPointer(source_list));
XtAddCallback(source_list, XmNextendedSelectionCallback,
SelectSourceCB, XtPointer(source_list));
XtAddCallback(source_list, XmNbrowseSelectionCallback,
SelectSourceCB, XtPointer(source_list));
XtAddCallback(dialog, XmNokCallback,
lookupSourceDone, XtPointer(source_list));
XtAddCallback(dialog, XmNapplyCallback, FilterSourcesCB, 0);
XtAddCallback(dialog, XmNcancelCallback,
UnmanageThisCB, XtPointer(dialog));
XtAddCallback(dialog, XmNunmapCallback, ClearStatusCB, 0);
XtAddCallback(dialog, XmNhelpCallback, ImmediateHelpCB, 0);
XtAddCallback(source_filter, XmNactivateCallback,
FilterSourcesCB, 0);
XtAddCallback(sharedlibrary, XmNactivateCallback,
LoadSharedLibrariesCB, 0);
#if XmVersion >= 1002
XtAddCallback(lookup, XmNactivateCallback,
lookupSourceDone, XtPointer(source_list));
#endif
}
update_sources(source_list, source_filter);
open_source_msg();
manage_and_raise(dialog);
warn_if_no_program(dialog);
}
void gdbExamineCB(Widget w, XtPointer, XtPointer)
{
static Widget dialog = 0;
if (dialog == 0)
{
Arg args[10];
Cardinal arg = 0;
XtSetArg(args[arg], XmNautoUnmanage, False); arg++;
dialog = verify(XmCreatePromptDialog(find_shell(w),
XMST("examine_dialog"),
args, arg));
Delay::register_shell(dialog);
XtManageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_APPLY_BUTTON));
XtUnmanageChild(XmSelectionBoxGetChild(dialog,
XmDIALOG_SELECTION_LABEL));
XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_TEXT));
arg = 0;
XtSetArg(args[arg], XmNorientation, XmHORIZONTAL); arg++;
XtSetArg(args[arg], XmNborderWidth, 0); arg++;
XtSetArg(args[arg], XmNentryBorder, 0); arg++;
XtSetArg(args[arg], XmNspacing, 0); arg++;
XtSetArg(args[arg], XmNmarginWidth, 0); arg++;
XtSetArg(args[arg], XmNmarginHeight, 0); arg++;
Widget panel = MMcreateButtonPanel(dialog, "panel", examine_menu,
args, arg);
(void) panel;
MMaddCallbacks(examine_menu);
MMaddHelpCallback(examine_menu, ImmediateHelpCB);
manage_child(unsigned_char_w, gdb->type() == GDB);
manage_child(binary_w, gdb->type() == GDB);
manage_child(address_format_w, gdb->type() == GDB);
manage_child(wide_char_w, gdb->type() == DBX);
manage_child(wide_string_w, gdb->type() == DBX);
manage_child(long_w, gdb->type() == DBX);
// Initialize: use `o' and `b' as default menu items
XtCallActionProc(octal_w, "ArmAndActivate",
(XEvent *)0, (String *)0, 0);
XtCallActionProc(byte_w, "ArmAndActivate",
(XEvent *)0, (String *)0, 0);
tie_combo_box_to_history(address_w, arg_history_filter);
XtAddCallback(dialog, XmNokCallback,
PrintExaminedCB, XtPointer(0));
XtAddCallback(dialog, XmNapplyCallback,
DisplayExaminedCB, XtPointer(0));
XtAddCallback(dialog, XmNcancelCallback,
UnmanageThisCB, XtPointer(dialog));
XtAddCallback(dialog, XmNhelpCallback,
ImmediateHelpCB, XtPointer(0));
}
string arg = source_arg->get_string();
if (!is_file_pos(arg) && !arg.empty())
XmTextFieldSetString(address_w, XMST(arg.chars()));
manage_and_raise(dialog);
}
void gdbHistoryCB(Widget w, XtPointer, XtPointer)
{
if (gdb_history_w)
{
manage_and_raise(gdb_history_w);
return;
}
Arg args[10];
int arg;
// Create history viewer
arg = 0;
gdb_history_w =
verify(createTopLevelSelectionDialog(find_shell(w), "history_dialog",
args, arg));
Delay::register_shell(gdb_history_w);
XtUnmanageChild(XmSelectionBoxGetChild(gdb_history_w,
XmDIALOG_OK_BUTTON));
XtUnmanageChild(XmSelectionBoxGetChild(gdb_history_w,
XmDIALOG_TEXT));
XtUnmanageChild(XmSelectionBoxGetChild(gdb_history_w,
XmDIALOG_SELECTION_LABEL));
gdb_commands_w = XmSelectionBoxGetChild(gdb_history_w, XmDIALOG_LIST);
XtVaSetValues(gdb_commands_w,
XmNselectionPolicy, XmSINGLE_SELECT,
XtPointer(0));
XtAddCallback(gdb_commands_w,
XmNsingleSelectionCallback, SelectHistoryCB, 0);
XtAddCallback(gdb_commands_w,
XmNmultipleSelectionCallback, SelectHistoryCB, 0);
XtAddCallback(gdb_commands_w,
XmNextendedSelectionCallback, SelectHistoryCB, 0);
XtAddCallback(gdb_commands_w,
XmNbrowseSelectionCallback, SelectHistoryCB, 0);
XtAddCallback(gdb_history_w, XmNokCallback, gdbApplySelectionCB, 0);
XtAddCallback(gdb_history_w, XmNapplyCallback, gdbApplySelectionCB, 0);
XtAddCallback(gdb_history_w, XmNcancelCallback, DestroyThisCB,
gdb_history_w);
XtAddCallback(gdb_history_w, XmNhelpCallback, ImmediateHelpCB, 0);
XtAddCallback(gdb_history_w, XmNdestroyCallback,
HistoryDestroyedCB, XtPointer(gdb_history_w));
bool *selected = new bool[gdb_history.size() + 1];
for (int i = 0; i < gdb_history.size() + 1; i++)
selected[i] = false;
selected[gdb_current_history] = true;
setLabelList(gdb_commands_w, gdb_history.values(),
selected, gdb_history.size(), false, false);
delete[] selected;
set_history_from_line(current_line());
XmListSelectPos(gdb_commands_w, 0, False);
XmListSetBottomPos(gdb_commands_w, 0);
manage_and_raise(gdb_history_w);
}
static void DoExportCB(Widget w, XtPointer client_data, XtPointer call_data)
{
SelectPlotCB(w, client_data, call_data);
PlotWindowInfo *plot = (PlotWindowInfo *)client_data;
string target = get_file(w, client_data, call_data);
if (target.empty())
return;
const StringArray& titles = plot->plotter->data_titles();
const StringArray& sources = plot->plotter->data_files();
string source = "";
string title = "";
for (int i = 0; source.empty() && i < sources.size(); i++)
{
if (!sources[i].empty())
{
source = sources[i];
title = titles[i];
}
}
if (source.empty())
return; // This should not happen
if (access(target.chars(), W_OK) == 0 && is_regular_file(target))
{
// File exists - request confirmation
static Widget confirm_overwrite_dialog = 0;
if (confirm_overwrite_dialog != 0)
DestroyWhenIdle(confirm_overwrite_dialog);
Arg args[10];
Cardinal arg = 0;
XtSetArg(args[arg], XmNdialogStyle,
XmDIALOG_FULL_APPLICATION_MODAL); arg++;
confirm_overwrite_dialog =
verify(XmCreateQuestionDialog(plot->shell,
XMST("confirm_overwrite_dialog"),
args, arg));
Delay::register_shell(confirm_overwrite_dialog);
bool yes = false;
bool no = false;
XtAddCallback(confirm_overwrite_dialog,
XmNokCallback, SetCB, XtPointer(&yes));
XtAddCallback(confirm_overwrite_dialog,
XmNcancelCallback, SetCB, XtPointer(&no));
XtAddCallback(confirm_overwrite_dialog,
XmNhelpCallback, ImmediateHelpCB, 0);
MString question = rm("Overwrite existing file "
+ quote(target) + "?");
XtVaSetValues (confirm_overwrite_dialog, XmNmessageString,
question.xmstring(), XtPointer(0));
manage_and_raise(confirm_overwrite_dialog);
XtAppContext app_context = XtWidgetToApplicationContext(plot->shell);
while (!yes && !no)
XtAppProcessEvent(app_context, XtIMAll);
if (no)
return;
}
StatusDelay delay("Saving " + title + " data to " + quote(target));
// Copy SOURCE to TARGET
std::ifstream is(source.chars());
std::ofstream os(target.chars());
if (os.bad())
{
FILE *fp = fopen(target.chars(), "w");
post_error(string("Cannot open ")
+ quote(target) + ": " + strerror(errno),
"export_failed_error", plot->shell);
if (fp)
fclose(fp);
delay.outcome = strerror(errno);
return;
}
int c;
while ((c = is.get()) != EOF)
os.put((unsigned char) c);
XtUnmanageChild(plot->export_dialog);
}
// 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;
}
// Answer GDB question
static void select_from_gdb(const string& question, string& reply)
{
int count = question.freq('\n') + 1;
string *choices = new string[count];
bool *selected = new bool[count];
split(question, choices, count, '\n');
// Highlight choice #1 by default
for (int i = 0; i < count; i++)
{
if (!has_nr(choices[i]))
{
// Choice has no number (prompt) - remove it
for (int j = i; j < count - 1; j++)
choices[j] = choices[j + 1];
count--;
i--;
}
else
{
selected[i] = (get_positive_nr(choices[i]) == 1);
}
}
if (count < 2)
{
// Nothing to choose from
if (count == 1)
{
// Take the first choice.
reply = itostring(atoi(choices[0].chars())) + "\n";
}
delete[] choices;
delete[] selected;
return;
}
// Popup selection dialog
static string selection_reply;
if (gdb_selection_dialog == 0)
{
Arg args[10];
Cardinal arg = 0;
XtSetArg(args[arg], XmNautoUnmanage, False); arg++;
gdb_selection_dialog =
verify(XmCreateSelectionDialog(find_shell(gdb_w),
XMST("gdb_selection_dialog"),
args, arg));
Delay::register_shell(gdb_selection_dialog);
XtUnmanageChild(XmSelectionBoxGetChild(gdb_selection_dialog,
XmDIALOG_TEXT));
XtUnmanageChild(XmSelectionBoxGetChild(gdb_selection_dialog,
XmDIALOG_SELECTION_LABEL));
XtUnmanageChild(XmSelectionBoxGetChild(gdb_selection_dialog,
XmDIALOG_APPLY_BUTTON));
gdb_selection_list_w = XmSelectionBoxGetChild(gdb_selection_dialog,
XmDIALOG_LIST);
XtVaSetValues(gdb_selection_list_w,
XmNselectionPolicy, XmSINGLE_SELECT,
XtPointer(0));
XtAddCallback(gdb_selection_dialog,
XmNokCallback, SelectCB, &selection_reply);
XtAddCallback(gdb_selection_dialog,
XmNcancelCallback, CancelCB, &selection_reply);
XtAddCallback(gdb_selection_dialog,
XmNhelpCallback, ImmediateHelpCB, 0);
}
setLabelList(gdb_selection_list_w, choices, selected, count, false, false);
delete[] choices;
delete[] selected;
manage_and_raise(gdb_selection_dialog);
selection_reply = "";
while (selection_reply.empty()
&& gdb->running() && !gdb->isReadyWithPrompt())
XtAppProcessEvent(XtWidgetToApplicationContext(gdb_w), XtIMAll);
// Found a reply - return
reply = selection_reply;
}
// 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();
}
