// 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 AttachArea::activateDeactivate()
{
//
// If exactly one icon is selected then activate the open command
//
if(getIconSelectedCount() == 1) {
openCmd()->activate();
} else {
openCmd()->deactivate();
}
// If no icons are selected then deactivate the OK button on the FS Dialog
if(getIconSelectedCount() > 0) {
if(getFsDialog())
XtSetSensitive(
XmSelectionBoxGetChild(
getFsDialog(), XmDIALOG_OK_BUTTON), TRUE
);
} else {
if(getFsDialog())
XtSetSensitive(
XmSelectionBoxGetChild(
getFsDialog(), XmDIALOG_OK_BUTTON
),
(getFsState() == SAVEAS) ? FALSE : TRUE
);
}
}
static void
SetValues(
ChangeDirRec *change_dir_rec,
ChangeDirData *change_dir_data )
{
Arg args[4];
char *tmp_str, *host_name;
XmString host_string;
DialogData * dialog_data;
FileMgrData * file_mgr_data;
dialog_data = _DtGetInstanceData (change_dir_data->file_mgr_rec);
file_mgr_data = (FileMgrData *) dialog_data->data;
if(change_dir_data->string_path)
XmStringFree (change_dir_data->string_path);
if( restrictMode
&& file_mgr_data->toolbox == False )
change_dir_data->string_path =
XmStringCreateLocalized( users_home_dir);
else if( file_mgr_data->restricted_directory )
change_dir_data->string_path =
XmStringCreateLocalized( file_mgr_data->current_directory);
else
change_dir_data->string_path = NULL;
XtSetArg (args[0], XmNlistItemCount, change_dir_data->list_count);
XtSetArg (args[1], XmNlistVisibleItemCount, change_dir_data->visible_count);
XtSetArg (args[2], XmNtextString, change_dir_data->string_path);
XtSetArg (args[3], XmNlistItems, change_dir_data->history_list);
XtSetValues (change_dir_rec->change_dir, args, 4);
if( change_dir_data->string_path )
{
Widget text;
text = XmSelectionBoxGetChild(change_dir_rec->change_dir, XmDIALOG_TEXT);
XtAddCallback (text, XmNmodifyVerifyCallback,
(XtCallbackProc)TextChange, (XtPointer)file_mgr_data );
XtAddCallback (text, XmNmotionVerifyCallback,
(XtCallbackProc)TextChange, (XtPointer)file_mgr_data );
XtAddCallback (text, XmNvalueChangedCallback,
(XtCallbackProc)TextChange, (XtPointer)file_mgr_data );
}
tmp_str = GETMESSAGE(2, 16, "System Name: ");
host_name = XtMalloc(strlen(tmp_str) + strlen(change_dir_data->host_name)+1);
sprintf(host_name, "%s%s", tmp_str, change_dir_data->host_name);
host_string = XmStringCreateLocalized (host_name);
XtSetArg (args[0], XmNlabelString, host_string);
XtSetValues (XmSelectionBoxGetChild (change_dir_rec->change_dir,
XmDIALOG_LIST_LABEL), args, 1);
XtFree(host_name);
XmStringFree(host_string);
}
// Update list of arguments
static void update_arguments(Widget dialog, Widget arguments_w,
StringArray& arguments, const string& last,
bool& updated)
{
if (updated || dialog == 0)
return;
bool *selected = new bool[arguments.size()];
int pos = -1;
for (int i = 0; i < arguments.size(); i++)
{
if (arguments[i] == last)
pos = i;
selected[i] = false;
}
if (pos >= 0)
selected[pos] = true;
setLabelList(arguments_w, arguments.values(),
selected, arguments.size(), false, false);
if (pos >= 0)
XmListSelectPos(arguments_w, pos + 1, False);
delete[] selected;
Widget text_w = XmSelectionBoxGetChild(dialog, XmDIALOG_TEXT);
XmTextSetString(text_w, XMST(last.chars()));
updated = true;
}
static XmString motFileDlgPrompt(Widget parent, const char* message)
{
Widget promptbox;
Arg args[2];
ImotPromt prompt;
XmString title;
XtSetArg(args[0], XmNautoUnmanage, False);
XtSetArg(args[1], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL);
promptbox = XmCreatePromptDialog(parent, "filedlg_prompt", args, 2);
iupmotSetString(promptbox, XmNselectionLabelString, message);
XtVaGetValues(parent, XmNdialogTitle, &title, NULL);
XtVaSetValues(promptbox, XmNdialogTitle, title, NULL);
prompt.ret_code = 0;
prompt.xm_dir = NULL;
XtAddCallback(promptbox, XmNokCallback, (XtCallbackProc)motFileDlgPromptCallback, (XtPointer)&prompt);
XtAddCallback(promptbox, XmNcancelCallback, (XtCallbackProc)motFileDlgPromptCallback, (XtPointer)&prompt);
XtUnmanageChild(XmSelectionBoxGetChild(promptbox, XmDIALOG_HELP_BUTTON));
XtManageChild(promptbox);
while (prompt.ret_code == 0)
XtAppProcessEvent(iupmot_appcontext, XtIMAll);
XtUnmanageChild(promptbox);
return prompt.xm_dir;
}
void
pushed(Widget pb, XtPointer foo, XtPointer bar)
{
static Widget dialog;
XmString t = XmStringCreateSimple("Enter New Button Name:");
extern void read_name(Widget, XtPointer, XtPointer);
extern void toggle_callback(Widget, XtPointer, XtPointer);
Arg args[3];
XtSetArg(args[0], XmNselectionLabelString, t);
XtSetArg(args[1], XmNautoUnmanage, False);
XtSetArg(args[2], XmNuserData, 0);
dialog = XmCreatePromptDialog(XtParent(pb), "notice", args, 3);
XmStringFree(t);
XtAddCallback(dialog, XmNokCallback, read_name, NULL);
XtAddCallback(dialog, XmNcancelCallback, (XtCallbackProc)XtDestroyWidget,
NULL);
XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
{
XmString btn1 = XmStringCreateSimple("Change Name");
XmString btn2 = XmStringCreateSimple("Change Color");
Widget toggle_box =
XmVaCreateSimpleRadioBox(dialog, "radio_box", 0, toggle_callback,
XmVaRADIOBUTTON, btn1, 0, NULL, NULL,
XmVaRADIOBUTTON, btn2, 0, NULL, NULL,
NULL);
XtManageChild(toggle_box);
}
XtManageChild(dialog);
XtPopup(XtParent(dialog), XtGrabNone);
}
/* Procedure to create de dialog. */
void create_sigma_dialog(Widget parent){
XmString message;
Widget temp_widget = parent;
/* Ensure the parent of the dialog is a shell widget */
while ( !XtIsShell(temp_widget) ) {
temp_widget = XtParent(temp_widget);
}
message = XmStringLtoRCreate(SIGMA_MESSAGE, XmSTRING_DEFAULT_CHARSET);
argcount = 0;
XtSetArg(args[argcount], XmNselectionLabelString, message); argcount++;
sigma_dialog = XmCreatePromptDialog(temp_widget, "gaussian dialog",
args, argcount);
/* Remove the help button from the dialog */
temp_widget = XmSelectionBoxGetChild(sigma_dialog, XmDIALOG_HELP_BUTTON);
XtUnmanageChild(temp_widget);
/* Add the actions to the buttons */
XtAddCallback(sigma_dialog, XmNokCallback,
(XtCallbackProc) ok_sigmabutton_callback, (XtPointer) NULL);
XtAddCallback(sigma_dialog, XmNcancelCallback,
(XtCallbackProc) cancel_sigmabutton_callback, (XtPointer) NULL);
XmStringFree(message);
}/*end create_sigma_dialog*/
void create_split_dialog(Widget parent)
{
XmString message;
Widget temp_widget = parent;
/* Ensure the parent of the dialog is a shell widget */
while ( !XtIsShell(temp_widget) ) {
temp_widget = XtParent(temp_widget);
}
message = XmStringLtoRCreate(SPLIT_MESSAGE, XmSTRING_DEFAULT_CHARSET);
argcount = 0;
XtSetArg(args[argcount], XmNselectionLabelString, message); argcount++;
split_dialog = XmCreatePromptDialog(temp_widget, "split dialog",
args, argcount);
/* Remove the help button from the dialog */
temp_widget = XmSelectionBoxGetChild(split_dialog, XmDIALOG_HELP_BUTTON);
XtUnmanageChild(temp_widget);
/* Add the actions to the buttons */
XtAddCallback(split_dialog, XmNokCallback,
(XtCallbackProc) start_split, (XtPointer) NULL);
XtAddCallback(split_dialog, XmNokCallback,
(XtCallbackProc) activate_merge_dialog, (XtPointer) NULL);
XmStringFree(message);
create_merge_dialog(main_window);
}
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);
}
// Set program arguments from list
static void SelectMakeArgsCB(Widget, XtPointer, XtPointer call_data)
{
XmListCallbackStruct *cbs = (XmListCallbackStruct *)call_data;
int pos = cbs->item_position - 1;
const string& args = make_arguments[pos];
Widget text_w = XmSelectionBoxGetChild(make_dialog, XmDIALOG_TEXT);
XmTextSetString(text_w, XMST(args.chars()));
}
// Make program with given arguments
static void gdbMakeDCB(Widget, XtPointer, XtPointer)
{
Widget text = XmSelectionBoxGetChild(make_dialog, XmDIALOG_TEXT);
String _args = XmTextGetString(text);
string args(_args);
XtFree(_args);
gdb_command(gdb->make_command(args));
}
// Set program arguments from list
static void SelectChangeDirectoryArgsCB(Widget, XtPointer, XtPointer call_data)
{
XmListCallbackStruct *cbs = (XmListCallbackStruct *)call_data;
int pos = cbs->item_position - 1;
string args = source_view->full_path(cd_arguments[pos]);
Widget text_w = XmSelectionBoxGetChild(cd_dialog, XmDIALOG_TEXT);
XmTextSetString(text_w, XMST(args.chars()));
}
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);
}
static void
SetFocus(
ChangeDirRec *change_dir_rec,
ChangeDirData *change_dir_data )
{
Widget text;
/* Force the focus to the text field */
text = XmSelectionBoxGetChild (change_dir_rec->change_dir, XmDIALOG_TEXT);
XmProcessTraversal(text, XmTRAVERSE_CURRENT);
}
int
main (int argc, char *argv[])
{
Arg al[1];
int ac;
XtAppContext context;
Widget toplevel, dialog, form, work;
toplevel = XtAppInitialize (&context, "", NULL, 0,
&argc, argv, NULL, NULL, 0);
dialog = XmCreateSelectionDialog (toplevel, "filesb", NULL, 0);
work=XmSelectionBoxGetChild(dialog, XmDIALOG_WORK_AREA);
#if 0
/* try to add one "manually": */
if (!work)
form=XtVaCreateManagedWidget("form", xmFormWidgetClass, dialog,
NULL);
work=XmSelectionBoxGetChild(dialog, XmDIALOG_WORK_AREA);
#endif
if (!work) {
printf("work==NULL\n");
exit(0);
} else if (work!=form) {
printf("form != work\n");
exit(1);
} else {
/* Motif 1.2 does so */
printf("form == work\n");
#if 0
XtManageChild(dialog);
XtRealizeWidget (toplevel);
LessTifTestMainLoop (toplevel);
#endif
exit(2);
}
}
Widget UISelectionCreate (char *selectTitle)
{
Widget dShell, selection;
dShell = XtVaCreatePopupShell (selectTitle,xmDialogShellWidgetClass,UITopLevel (),
XmNminWidth, 200,
XmNallowShellResize, true,
XmNtransient, true,
XmNkeyboardFocusPolicy, XmEXPLICIT,
NULL);
selection = XtVaCreateWidget ("UISelectionDialog",xmSelectionBoxWidgetClass,dShell,
XmNnoResize, true,
XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL,
XmNautoUnmanage, false,
XmNmustMatch, true,
NULL);
XtVaSetValues (XmSelectionBoxGetChild (selection,XmDIALOG_OK_BUTTON),XmNdefaultButtonShadowThickness, 0,NULL);
XtVaSetValues (XmSelectionBoxGetChild (selection,XmDIALOG_CANCEL_BUTTON),XmNdefaultButtonShadowThickness, 0,NULL);
XtUnmanageChild (XmSelectionBoxGetChild (selection,XmDIALOG_HELP_BUTTON));
XtUnmanageChild (XmSelectionBoxGetChild (selection,XmDIALOG_APPLY_BUTTON));
XtUnmanageChild (XmSelectionBoxGetChild (selection,XmDIALOG_SELECTION_LABEL));
XtUnmanageChild (XmSelectionBoxGetChild (selection,XmDIALOG_TEXT));
XtAddCallback (selection,XmNokCallback,(XtCallbackProc) _UIOkSelectionCallback,NULL);
XtAddCallback (selection,XmNokCallback,(XtCallbackProc) UILoopStopCBK,NULL);
XtAddCallback (selection,XmNcancelCallback,(XtCallbackProc) UILoopStopCBK,NULL);
XtAddCallback (selection,XmNdestroyCallback,(XtCallbackProc) UILoopStopCBK,NULL);
XtAddCallback (selection,XmNnoMatchCallback,(XtCallbackProc) _UINoMatchSelectionCallback,NULL);
return (selection);
}
static void scale_value_changed (Widget widget, XtPointer client_data,
XtPointer call_data)
{
Widget form;
Widget patch_widget;
Widget text_widget;
ColorDataPtr colordata;
Arg arg[2];
XmScaleCallbackStruct *callback_data;
char *tag;
callback_data = (XmScaleCallbackStruct *) call_data;
tag = (char *) client_data;
form = XtParent(XtParent(widget));
patch_widget = XtNameToWidget(form,"color_patch");
text_widget = XmSelectionBoxGetChild(
XtNameToWidget(form,"color_sb"),
XmDIALOG_TEXT);
XtSetArg(arg[0],XmNuserData,&colordata);
XtGetValues(form,arg,1);
/* based on the tag, set either the red,green, or blue static variables, */
/* then set color of label0 */
if(*tag == 'r'){
colordata->color.red = callback_data->value * COLOR_PCT_MULTIPLIER;
sprintf(colordata->redname,"%4.4x",colordata->color.red);
}
else if(*tag == 'g'){
colordata->color.green = callback_data->value * COLOR_PCT_MULTIPLIER;
sprintf(colordata->greenname,"%4.4x",colordata->color.green);
}
else if(*tag == 'b'){
colordata->color.blue = callback_data->value * COLOR_PCT_MULTIPLIER;
sprintf(colordata->bluename,"%4.4x",colordata->color.blue);
}
/* update the color cell */
XStoreColor(dpy,cmap,&(colordata->color));
/* assemble complete hex-string and set editable text to it */
strcpy(colordata->colorname,"#");
strcat(colordata->colorname,colordata->redname);
strcat(colordata->colorname,colordata->greenname);
strcat(colordata->colorname,colordata->bluename);
XmTextSetString(text_widget,colordata->colorname);
}
// 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);
}
// 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);
}
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);
}
static void load_rgb_text(Widget widget, XtPointer client_data,
XtPointer call_data)
{
Arg arg[2];
FILE *rgb_text;
int item_count;
XmString xms[MAX_DEFINED_COLORS];
char buf[360];
if(!(rgb_text=fopen(data.rgb_text_file,"r"))) {
return;
}
for(item_count=0; (item_count<MAX_DEFINED_COLORS) &&
fgets(buf,sizeof(buf),rgb_text); item_count++) {
char *name;
/* get correct (4th) field of rgb.txt lines */
strtok(buf," \t\n");
strtok(NULL," \t\n");
strtok(NULL," \t\n");
name = strtok(NULL,"\t\n");
while (isspace(*name) && name != NULL && *name != '\0')
name++;
/* if you don't set the array item, counteract the autoincrement */
if(name)
xms[item_count] = XmStringDefCreate(name);
else item_count--;
}
fclose(rgb_text);
XtSetArg(arg[0],XmNlistItems,xms);
XtSetArg(arg[1],XmNlistItemCount,item_count);
XtSetValues(widget,arg,2);
while(--item_count > 0)
XmStringFree(xms[item_count]);
widget = XmSelectionBoxGetChild(widget, XmDIALOG_LIST);
XtAddCallback(widget,
XmNsingleSelectionCallback,colorlist_selection_made,NULL);
XtAddCallback(widget,
XmNbrowseSelectionCallback,colorlist_selection_made,NULL);
XtAddCallback(widget,
XmNdefaultActionCallback,colorlist_selection_made,NULL);
}
static void setcolor_colorform(Widget form, char *valuestring)
{
Arg arg[1];
ColorDataPtr colordata;
Widget scale;
Widget text;
XtSetArg(arg[0],XmNuserData,&colordata);
XtGetValues(form,arg,1);
/* set the color cell to valuestring */
if(*valuestring=='#'){
XParseColor(dpy,cmap,valuestring,&(colordata->color));
XStoreColor(dpy,cmap,&(colordata->color));
}
else
XStoreNamedColor(dpy,cmap,valuestring,
colordata->color.pixel,
colordata->color.flags);
/* and fill the XColor struct with RGB values for scales */
XQueryColor(dpy,cmap,&(colordata->color));
/* based on the values in the color fields, set the slider values */
scale = XtNameToWidget(form,"slider_box.scale1");
XtSetArg(arg[0],XmNvalue,(int)(colordata->color.red/COLOR_PCT_MULTIPLIER));
XtSetValues(scale,arg,1);
sprintf(colordata->redname,"%4.4x",colordata->color.red);
scale = XtNameToWidget(form,"slider_box.scale2");
XtSetArg(arg[0],XmNvalue,(int)(colordata->color.green/COLOR_PCT_MULTIPLIER));
XtSetValues(scale,arg,1);
sprintf(colordata->greenname,"%4.4x",colordata->color.green);
scale = XtNameToWidget(form,"slider_box.scale3");
XtSetArg(arg[0],XmNvalue,(int)(colordata->color.blue/COLOR_PCT_MULTIPLIER));
XtSetValues(scale,arg,1);
sprintf(colordata->bluename,"%4.4x",colordata->color.blue);
sprintf(colordata->colorname,valuestring);
text = XmSelectionBoxGetChild(
XtNameToWidget(form,"color_sb"),
XmDIALOG_TEXT);
XmTextSetString(text,valuestring);
}
// ChangeDirectory program with given arguments
static void gdbChangeDirectoryDCB(Widget, XtPointer, XtPointer)
{
Widget text = XmSelectionBoxGetChild(cd_dialog, XmDIALOG_TEXT);
String _args = XmTextGetString(text);
string args(_args);
XtFree(_args);
string path = source_view->full_path(args);
switch (gdb->type()) {
case PERL:
gdb_command("chdir " + quote(path, '\''));
break;
case BASH:
gdb_command("eval cd " + path);
break;
default:
gdb_command("cd " + path);
}
}
// Run program with given arguments
static void gdbRunDCB(Widget, XtPointer, XtPointer)
{
Widget text = XmSelectionBoxGetChild(run_dialog, XmDIALOG_TEXT);
String _args = XmTextGetString(text);
string args(_args);
XtFree(_args);
string cmd = gdb->run_command(args);
while (!cmd.empty())
{
string c;
if (cmd.contains('\n'))
c = cmd.before('\n');
else
c = cmd;
cmd = cmd.after('\n');
gdb_command(c, run_dialog);
}
}
static void
InstallClose(
ChangeDirRec *change_dir_rec,
XtCallbackProc callback,
XtPointer client_data )
{
Widget close_widget;
Atom delete_window_atom;
close_widget =
XmSelectionBoxGetChild (change_dir_rec->change_dir,
XmDIALOG_CANCEL_BUTTON);
XtAddCallback (close_widget, XmNactivateCallback, callback, client_data);
delete_window_atom = XmInternAtom (XtDisplay(change_dir_rec->shell),
"WM_DELETE_WINDOW", True);
XmRemoveWMProtocols( change_dir_rec->shell, &delete_window_atom, 1 );
XmAddWMProtocolCallback( change_dir_rec->shell, delete_window_atom, callback,
(XtPointer)client_data );
}
void text_save(Widget w, XtPointer client_data, XtPointer call_data)
{
Widget child;
char *ptr, bufr[256], nam1[256];
XmString namx;
if (!savetextdialog) {
savetextdialog = XmCreateFileSelectionDialog(GetTopShell(w), "textfile", NULL, 0);
/* Get rid of Help button */
XtUnmanageChild(XmSelectionBoxGetChild(savetextdialog, XmDIALOG_HELP_BUTTON));
XtAddCallback(savetextdialog, XmNokCallback, get_textfile, NULL);
XtAddCallback(savetextdialog, XmNcancelCallback, (XtCallbackProc)XtUnmanageChild, NULL);
child = XmFileSelectionBoxGetChild(savetextdialog, XmDIALOG_TEXT);
XtVaGetValues(child, XmNvalue, &ptr, NULL);
}
namx = XmStringCreateLocalized(raobsavefilename);
printf( "Setting Default Output File Name = %s\n", raobsavefilename);
XtVaSetValues( savetextdialog, XmNdirSpec, namx);
XtManageChild(savetextdialog);
XtPopup(XtParent(savetextdialog), XtGrabNone);
}
void getStartupPrefs(Widget mainWin)
{
Widget prefForm;
Widget portLabel;
Widget child;
XmString labelString;
Arg args[4];
int argcount;
FILE *confFile;
char serverPortNum[6];
char *confFilePath;
argcount = 0;
labelString = XM_STRING_CREATE("Startup Prefs");
XtSetArg(args[argcount], XmNdialogTitle, labelString);
argcount++;
XtSetArg(args[argcount], XmNautoUnmanage, True);
argcount++;
startPrefDiag = XmCreatePromptDialog(mainWin, "startup_prefs", args, argcount);
XmStringFree(labelString);
/* Now get rid of the things we don't want */
child = XmSelectionBoxGetChild(startPrefDiag, XmDIALOG_SELECTION_LABEL);
XtUnmanageChild(child);
child = XmSelectionBoxGetChild(startPrefDiag, XmDIALOG_TEXT);
XtUnmanageChild(child);
prefForm = XtVaCreateWidget("form", xmFormWidgetClass, startPrefDiag,
XmNfractionBase, 18, NULL);
labelString = XM_STRING_CREATE("Name:");
XtVaCreateManagedWidget("name_label",
xmLabelWidgetClass, prefForm,
XmNlabelString, labelString,
XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 0,
XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 0,
NULL);
XmStringFree(labelString);
labelString = XM_STRING_CREATE("Nick:");
XtVaCreateManagedWidget("nick_label",
xmLabelWidgetClass, prefForm,
XmNlabelString, labelString,
XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 6,
XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 0,
NULL);
XmStringFree(labelString);
labelString = XM_STRING_CREATE("Server:");
XtVaCreateManagedWidget("server_label",
xmLabelWidgetClass, prefForm,
XmNlabelString, labelString,
XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 12,
XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 0,
NULL);
XmStringFree(labelString);
nameTextForm = XtVaCreateManagedWidget("name_form",
xmTextFieldWidgetClass, prefForm,
XmNmaxLength, MAX_NAME_LEN,
XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 0,
XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 4,
XmNrightAttachment, XmATTACH_POSITION, XmNrightPosition, 18,
NULL);
nickTextForm = XtVaCreateManagedWidget("nick_form",
xmTextFieldWidgetClass, prefForm,
XmNmaxLength, MAX_NICK_LEN,
XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 6,
XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 4,
XmNrightAttachment, XmATTACH_POSITION, XmNrightPosition, 18,
NULL);
portTextForm = XtVaCreateManagedWidget("port_form",
xmTextFieldWidgetClass, prefForm,
XmNmaxLength, 5,
XmNcolumns, 5,
XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 12,
XmNrightAttachment, XmATTACH_POSITION, XmNrightPosition, 18,
NULL);
labelString = XM_STRING_CREATE("Port: ");
portLabel = XtVaCreateManagedWidget("port_label",
xmLabelWidgetClass, prefForm,
XmNlabelString, labelString,
XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 12,
XmNrightAttachment, XmATTACH_WIDGET, XmNrightWidget, portTextForm,
NULL);
XmStringFree(labelString);
serverTextForm = XtVaCreateManagedWidget("server_form",
xmTextFieldWidgetClass, prefForm,
XmNmaxLength, MAX_SERVERNAME_LEN,
XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 12,
XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 4,
XmNrightAttachment, XmATTACH_WIDGET, XmNrightWidget, portLabel,
NULL);
XtAddCallback(startPrefDiag, XmNokCallback, okButtStartupCbk, NULL);
XtAddCallback(startPrefDiag, XmNhelpCallback, helpButtStartupCbk, NULL);
XtManageChild(prefForm);
XtManageChild(startPrefDiag);
/* read configuration file */
if (confFilePath = getPreferencesFilePath())
{
confFile = fopen (confFilePath, "r");
if (confFile)
{
char buff[FILE_BUFF_SIZE];
char *pos;
fgets(buff, FILE_BUFF_SIZE, confFile);
if (buff[strlen(buff)-1] == '\n')
buff[strlen(buff)-1] = '\0';
if(!strncmp(buff, "DefaultNick", strlen("DefaultNick")))
if (pos = strchr(buff, ' '))
strcpy(sysState.myNick, pos+1);
fgets(buff, FILE_BUFF_SIZE, confFile);
if (buff[strlen(buff)-1] == '\n')
buff[strlen(buff)-1] = '\0';
if(!strncmp(buff, "DefaultName", strlen("DefaultName")))
if (pos = strchr(buff, ' '))
strcpy(sysState.myName, pos+1);
fgets(buff, FILE_BUFF_SIZE, confFile);
if (buff[strlen(buff)-1] == '\n')
buff[strlen(buff)-1] = '\0';
if(!strncmp(buff, "DefaultServer", strlen("DefaultServer")))
if (pos = strchr(buff, ' '))
strcpy(sysState.serverName, pos+1);
fgets(buff, FILE_BUFF_SIZE, confFile);
if (buff[strlen(buff)-1] == '\n')
buff[strlen(buff)-1] = '\0';
if(!strncmp(buff, "DefaultPortNum", strlen("DefaultPortNum")))
if (pos = strchr(buff, ' '))
strcpy(serverPortNum, pos+1);
fclose(confFile);
} else
{
printf("config file not found.\n");
strcpy(sysState.myNick, "nebula_user");
strcpy(sysState.myName, "Nebula User");
strcpy(sysState.serverName, "irc.freenode.org");
strcpy(serverPortNum, "6666");
}
free(confFilePath);
}
XmTextSetString(nickTextForm, sysState.myNick);
XmTextSetString(nameTextForm, sysState.myName);
XmTextSetString(serverTextForm, sysState.serverName);
XmTextSetString(portTextForm, serverPortNum);
}
Widget
XFE_Dialog::createDialogChromeWidget(Widget parent,
char *name,
Boolean ok,
Boolean cancel,
Boolean help,
Boolean apply,
Boolean separator,
Boolean modal)
{
Visual *v = 0;
Colormap cmap = 0;
Cardinal depth = 0;
Arg av[20];
int ac;
Widget chrome;
XtVaGetValues (parent,
XtNvisual, &v,
XtNcolormap, &cmap,
XtNdepth, &depth,
0);
ac = 0;
XtSetArg (av[ac], XmNvisual, v); ac++;
XtSetArg (av[ac], XmNdepth, depth); ac++;
XtSetArg (av[ac], XmNcolormap, cmap); ac++;
XtSetArg (av[ac], XmNallowShellResize, TRUE); ac++;
XtSetArg (av[ac], XmNtransientFor, parent); ac++;
if (modal) {
XtSetArg (av[ac], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ac++;
}
XtSetArg (av[ac], XmNdialogType, XmDIALOG_QUESTION); ac++;
XtSetArg (av[ac], XmNdeleteResponse, XmDESTROY); ac++;
XtSetArg (av[ac], XmNautoUnmanage, False); ac++;
XtSetArg (av[ac], XmNnoResize, True); ac++;
chrome = XmCreatePromptDialog (parent, name, av, ac);
if (!separator)
fe_UnmanageChild_safe(XmSelectionBoxGetChild(chrome,
XmDIALOG_SEPARATOR));
fe_UnmanageChild_safe (XmSelectionBoxGetChild (chrome,
XmDIALOG_TEXT));
fe_UnmanageChild_safe (XmSelectionBoxGetChild (chrome,
XmDIALOG_SELECTION_LABEL));
if (!ok)
fe_UnmanageChild_safe (XmSelectionBoxGetChild (chrome,
XmDIALOG_OK_BUTTON));
else
m_okButton = XmSelectionBoxGetChild(chrome, XmDIALOG_OK_BUTTON);
if (!cancel)
fe_UnmanageChild_safe (XmSelectionBoxGetChild (chrome,
XmDIALOG_CANCEL_BUTTON));
else
m_cancelButton = XmSelectionBoxGetChild(chrome, XmDIALOG_CANCEL_BUTTON);
fe_UnmanageChild_safe (XmSelectionBoxGetChild (chrome, XmDIALOG_HELP_BUTTON));
if (help) {
// TODO: Enable help later
fe_UnmanageChild_safe (XmSelectionBoxGetChild (chrome, XmDIALOG_HELP_BUTTON));
// m_helpButton = XmSelectionBoxGetChild(chrome, XmDIALOG_HELP_BUTTON);
}
else
fe_UnmanageChild_safe (XmSelectionBoxGetChild (chrome, XmDIALOG_HELP_BUTTON));
if (apply) {
m_applyButton = XmSelectionBoxGetChild(chrome, XmDIALOG_APPLY_BUTTON);
XtManageChild(m_applyButton);
}
return chrome;
}
Widget
PromptDialogManager::post( char *title,
char *text,
void *clientData,
DialogCallback ok,
DialogCallback cancel,
DialogCallback help )
{
// Get a dialog widget from the cache
Widget dialog = getDialog();
// Make sure the dialog exists, and that it is an XmMessageBox
// or subclass, since the callbacks assume this widget type
assert ( dialog != NULL );
assert ( XtIsSubclass ( dialog, xmSelectionBoxWidgetClass ) );
// Convert the text string to a compound string and
// specify this to be the message displayed in the dialog.
XmString titleStr = XmStringCreateLocalized (title);
XmString xmstr = XmStringCreateLocalized ( text );
XtVaSetValues ( dialog,
XmNmessageString, xmstr,
XmNdialogTitle, titleStr,
NULL );
XmStringFree ( xmstr );
XmStringFree ( titleStr );
// Create an object to carry the additional data needed
// to cache the dialogs.
DialogCallbackData *dcb = new DialogCallbackData( this,
clientData,
ok, cancel,
help );
// Install callback function for each button
// support by Motif dialogs. If there is no help callback
// unmanage the corresponding button instead, if possible.
if ( ok )
XtAddCallback ( dialog,
XmNokCallback,
&DialogManager::okCallback,
(XtPointer) dcb );
else
{
Widget w = XmSelectionBoxGetChild ( dialog,
XmDIALOG_OK_BUTTON );
XtUnmanageChild ( w );
}
if ( cancel )
XtAddCallback ( dialog,
XmNcancelCallback,
&DialogManager::cancelCallback,
(XtPointer) dcb );
else
{
Widget w = XmSelectionBoxGetChild ( dialog,
XmDIALOG_CANCEL_BUTTON );
XtUnmanageChild ( w );
}
if ( help )
XtAddCallback ( dialog,
XmNhelpCallback,
&DialogManager::helpCallback,
(XtPointer) dcb );
else
{
Widget w = XmSelectionBoxGetChild ( dialog,
XmDIALOG_HELP_BUTTON );
XtUnmanageChild ( w );
}
// Post the dialog.
XtManageChild ( dialog );
return 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);
}
