Beispiel #1
0
/*********************************************************************
HelpCB: This function is called when the user requests help.  This
        function displays a Message DialogBox. 
*********************************************************************/
void
HelpCB(Widget   w,
       XtPointer cd,
       XtPointer cb
      )
{
 int       what_kind_of_help = (int)cd;  
 char      help_string[400]; 
 XmString  hs_as_cs; 
 Widget    dialog_general_help; 
 Arg       arg[3];

 sprintf(help_string, 
"This program demonstrates how to use an XmComboBox in an application.\n\
You can make a selection by typing it directly into the TextField\n\
or by selecting the item from the DropDown list.  To make the list\n\
drop down, click on the arrow that appears next to the TextField.");

   hs_as_cs = XmStringCreateLtoR(help_string, 
                                 XmFONTLIST_DEFAULT_TAG);
   
   XtSetArg(arg[0], XmNmessageString, hs_as_cs);
   dialog_general_help = (Widget)XmCreateMessageDialog(top_level, 
                                             "message", arg, 1);
   XmStringFree(hs_as_cs);
 
   switch (what_kind_of_help)  {
     case 1: XtManageChild(dialog_general_help);
             break;
     default: /* no other help */
             break; 
   }
          
}
Beispiel #2
0
Widget post_dialog( Widget parent, int dialog_type, const char * msg) {

    Widget dialog;
    XmString text;

    dialog = XmCreateMessageDialog( parent, "dialog", NULL, 0);
    text = XmStringCreateLocalized( (char *)msg);
    XtVaSetValues( dialog,
                   XmNdialogType, dialog_type,
                   XmNmessageString, text,
                   NULL);
            XmStringFree( text);

            // Remove the Cancel Button from the dialog.
            XtUnmanageChild( XmMessageBoxGetChild( dialog, XmDIALOG_CANCEL_BUTTON));

            // Grey out the Help Button
            XtSetSensitive( XmMessageBoxGetChild( dialog, XmDIALOG_HELP_BUTTON), False);

            // Destroy the widget when the user clicks OK.
            XtAddCallback( dialog, XmNokCallback, DestroyWidget_cb, (XtPointer)NULL);

            XtManageChild( dialog);

            return dialog;
}
Beispiel #3
0
/*********************************************************************
HelpCB
*********************************************************************/
void
HelpCB(Widget   w,
       XtPointer cd,
       XtPointer cb
      )
{
    int       what_kind_of_help = (int)cd;
    char      help_string[400];
    XmString  hs_as_cs;
    Widget    dialog_general_help;
    Arg       arg[3];

    sprintf(help_string,
            "This program demonstrates how to add a destination callback\n\
to an application.\n\
You should drag the displayed pixmap from the Label widget\n\
and drop it inside the framed DrawingArea widget.");

    hs_as_cs = XmStringCreateLtoR(help_string,
                                  XmFONTLIST_DEFAULT_TAG);

    XtSetArg(arg[0], XmNmessageString, hs_as_cs);
    dialog_general_help = (Widget)XmCreateMessageDialog(toplevel,
                          "message", arg, 1);
    XmStringFree(hs_as_cs);

    switch (what_kind_of_help)  {
    case 1:
        XtManageChild(dialog_general_help);
        break;
    default: /* no other help */
        break;
    }

}
Beispiel #4
0
int
XmLMessageBox(Widget w,
	      char *string,
	      Boolean okOnly)
	{
	int status = 0;
	Widget dialog, shell;
	Arg args[3];
	XtAppContext context;
	XmString str, titleStr;
	String shellTitle;
	Atom WM_DELETE_WINDOW;

	str = XmStringCreateLtoR(string, XmSTRING_DEFAULT_CHARSET);
	XtSetArg(args[0], XmNmessageString, str);
	XtSetArg(args[1], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL);
	shell = XmLShellOfWidget(w);
	if (shell)
		XtVaGetValues(shell, XmNtitle, &shellTitle, NULL);
	if (shell && shellTitle)
		titleStr = XmStringCreateLtoR(shellTitle,
			XmSTRING_DEFAULT_CHARSET);
	else
		titleStr = XmStringCreateSimple("Notice");
	XtSetArg(args[2], XmNdialogTitle, titleStr);
	if (okOnly == True)
		dialog = XmCreateMessageDialog(XtParent(w), "popup", args, 3);
	else
		dialog = XmCreateQuestionDialog(XtParent(w), "popup", args, 3);
	WM_DELETE_WINDOW = XmInternAtom(XtDisplay(w), "WM_DELETE_WINDOW",
		False);
	XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW, XmLMessageBoxWMDelete,
		(caddr_t)&status);
	XmStringFree(str);
	XmStringFree(titleStr);
	XtAddCallback(dialog, XmNokCallback, XmLMessageBoxResponse,
		(XtPointer)&status);
	if (okOnly == True)
		{
		XtUnmanageChild(XmMessageBoxGetChild(dialog,
			XmDIALOG_CANCEL_BUTTON));
		XtUnmanageChild(XmMessageBoxGetChild(dialog,
			XmDIALOG_HELP_BUTTON));
		}
	else
		{
		XtAddCallback(dialog, XmNcancelCallback, XmLMessageBoxResponse,
			(XtPointer)&status);
		XtAddCallback(dialog, XmNhelpCallback, XmLMessageBoxResponse,
			(XtPointer)&status);
		}
	XtManageChild(dialog);

	context = XtWidgetToApplicationContext(w);
	while (!status ||  XtAppPending(context))
		XtAppProcessEvent(context, XtIMAll);
	XtDestroyWidget(dialog);
	return status;
	}
Beispiel #5
0
/******************************************************
  createDialog
******************************************************/
void createDialog(Widget parent,int dialogType,char *message1,char *message2)
{
	XmString        str,str1,str2,str3,string,string2;
	Widget   dialog = 0;

	dialog = XmCreateMessageDialog(parent, "Dialog", NULL, 0);
	XtUnmanageChild(XmMessageBoxGetChild(dialog,XmDIALOG_CANCEL_BUTTON));
	XtUnmanageChild(XmMessageBoxGetChild(dialog,XmDIALOG_HELP_BUTTON));
	XtSetSensitive(XmMessageBoxGetChild(dialog,XmDIALOG_HELP_BUTTON),FALSE);
	XtAddCallback(dialog,XmNokCallback,killDialog,NULL);

	switch(dialogType) {
	case XmDIALOG_WARNING:
		str=XmStringCreateLtoR("WarningDialog",XmSTRING_DEFAULT_CHARSET);
		break;
	case XmDIALOG_ERROR:
		str=XmStringCreateLtoR("ErrorDialog",XmSTRING_DEFAULT_CHARSET);
		break;
	case XmDIALOG_INFORMATION:
		str=XmStringCreateLtoR("InformationDialog",XmSTRING_DEFAULT_CHARSET);
		break;
	case XmDIALOG_MESSAGE:
		str=XmStringCreateLtoR("MessageDialog",XmSTRING_DEFAULT_CHARSET);
		break;
	case XmDIALOG_QUESTION:
		str=XmStringCreateLtoR("QuestionDialog",XmSTRING_DEFAULT_CHARSET);
		break;
	case XmDIALOG_WORKING:
		str=XmStringCreateLtoR("WorkDialog",XmSTRING_DEFAULT_CHARSET);
		break;
	default:
		str=XmStringCreateLtoR("Dialog",XmSTRING_DEFAULT_CHARSET);
		break;
	}

	str1 = XmStringCreateLtoR(message1,XmFONTLIST_DEFAULT_TAG);
	str2 = XmStringCreateLtoR(message2,XmFONTLIST_DEFAULT_TAG);
	string = XmStringConcat(str1,str2);

	str3 = XmStringCreateLtoR("ALH ",XmFONTLIST_DEFAULT_TAG);
	string2 = XmStringConcat(str3,str);

	XtVaSetValues(dialog,
	    XmNdialogType,  dialogType,
	    XmNdialogTitle, string2,
	    XmNmessageString, string,
	    (XtPointer)NULL);
	XmStringFree(str);
	XmStringFree(str1);
	XmStringFree(str2);
	XmStringFree(string);

	XtManageChild(dialog);
	XFlush(display);
}
Beispiel #6
0
static void create_completions_dialog(char *title)
{
  Arg args[20];
  int n;
  XmString titlestr;
  titlestr = XmStringCreateLocalized(title);

  n = 0;
  XtSetArg(args[n], XmNbackground, ss->sgx->basic_color); n++;
  XtSetArg(args[n], XmNdialogTitle, titlestr); n++;
  XtSetArg(args[n], XmNresizePolicy, XmRESIZE_GROW); n++;
  XtSetArg(args[n], XmNnoResize, false); n++;
  /* XtSetArg(args[n], XmNtransient, false); n++; */
  completions_dialog = XmCreateMessageDialog(MAIN_PANE(ss), "snd-completion-help", args, n);

  XtUnmanageChild(XmMessageBoxGetChild(completions_dialog, XmDIALOG_CANCEL_BUTTON));
  XtUnmanageChild(XmMessageBoxGetChild(completions_dialog, XmDIALOG_SYMBOL_LABEL));
  XmStringFree(titlestr);

  n = 0;
  completions_list = XmCreateScrolledList(completions_dialog, "completion-help-text", args, n);
  XtVaSetValues(completions_list, XmNbackground, ss->sgx->white, XmNforeground, ss->sgx->black, NULL);

  XtManageChild(completions_list);

  XtAddCallback(completions_list, XmNbrowseSelectionCallback, completions_browse_callback, NULL);
  XtAddCallback(completions_dialog, XmNhelpCallback, completions_help_callback, NULL);
  XtAddCallback(completions_dialog, XmNokCallback, completions_ok_callback, NULL);

  XtManageChild(completions_dialog);

  map_over_children(completions_dialog, set_main_color_of_widget);
  XtVaSetValues(completions_list, XmNbackground, ss->sgx->white, XmNforeground, ss->sgx->black, NULL);
  XtVaSetValues(XmMessageBoxGetChild(completions_dialog, XmDIALOG_OK_BUTTON), XmNarmColor, ss->sgx->pushed_button_color, NULL);
  XtVaSetValues(XmMessageBoxGetChild(completions_dialog, XmDIALOG_HELP_BUTTON), XmNarmColor, ss->sgx->pushed_button_color, NULL);
  XtVaSetValues(XmMessageBoxGetChild(completions_dialog, XmDIALOG_OK_BUTTON), XmNbackground, ss->sgx->quit_button_color, NULL);
  XtVaSetValues(XmMessageBoxGetChild(completions_dialog, XmDIALOG_HELP_BUTTON), XmNbackground, ss->sgx->help_button_color, NULL);

  set_dialog_widget(COMPLETION_DIALOG, completions_dialog);
}
Beispiel #7
0
void CreateTrans(char *text, char *name)
{
    XmString message, button_text, title;
    int n;
    Arg args[MAX_ARGS];
    Widget box, button;

    message = XmStringCreateLtoR(text, XmSTRING_DEFAULT_CHARSET);
    button_text = XmStringCreateLtoR(TRANSBUTTON,
        XmSTRING_DEFAULT_CHARSET);

    title = XmStringCreateLtoR(name, XmSTRING_DEFAULT_CHARSET);

    n = 0;
    XtSetArg(args[n], XmNdialogTitle, title); n++;
    XtSetArg(args[n], XmNokLabelString, button_text); n++;
    XtSetArg(args[n], XmNmessageString, message); n++;
    box = XmCreateMessageDialog(globl.parent, "helpbox", args, n);

    button = XmMessageBoxGetChild(box, XmDIALOG_CANCEL_BUTTON);
    XtUnmanageChild(button);

    button = XmMessageBoxGetChild(box, XmDIALOG_HELP_BUTTON);
    XtUnmanageChild(button);

    if (title)
	XmStringFree(title);

    if (button_text)
	XmStringFree(button_text);

    if (message)
	XmStringFree(message);

    XtManageChild(box);
}
Beispiel #8
0
void
XltHostSelect(Widget W, Widget w)
{
    while (!XtIsTopLevelShell(W))
	W = XtParent(W);
    /*
    fprintf(stderr, "%s:%s(%d) - %s %s %s\n", __FILE__, __FUNCTION__, __LINE__,
    	XtName(W), XtName(w),
    	Host_Dialog(w) ? XtName(Host_Dialog(w)) : "NULL");
    */
    if (Host_Dialog(w) == NULL)
    {
	Widget Form;
	Widget Form1;
	Widget Form2;
	Widget HostLabel;
	Widget HostText;
	Widget PortLabel;
	Widget PortText;
	String Name;

	Name = XtMalloc(strlen(XtName(w)) + 7);
	sprintf(Name, "%sSelect", XtName(w));
	Host_Dialog(w) = XmCreateMessageDialog(W, Name, NULL, 0);
	XtFree(Name);
	Form = XmCreateForm(Host_Dialog(w), "Form", NULL, 0);

	Form1 = XmCreateForm(Form, "HostForm", NULL, 0);
	XtVaSetValues(Form1,
		      XmNtopAttachment, XmATTACH_FORM,
		      XmNleftAttachment, XmATTACH_FORM,
		      XmNrightAttachment, XmATTACH_FORM,
		      NULL);
	HostLabel = XmCreateLabel(Form1, "Host", NULL, 0);
	HostText = XmCreateTextField(Form1, "HostText", NULL, 0);
	XtVaSetValues(HostLabel,
		      XmNtopAttachment, XmATTACH_FORM,
		      XmNleftAttachment, XmATTACH_FORM,
		      XmNbottomAttachment, XmATTACH_FORM,
		      NULL);
	XtVaSetValues(HostText,
		      XmNtopAttachment, XmATTACH_FORM,
		      XmNbottomAttachment, XmATTACH_FORM,
		      XmNleftAttachment, XmATTACH_WIDGET,
		      XmNleftWidget, HostLabel,
		      XmNrightAttachment, XmATTACH_FORM,
		      NULL);
	XtManageChild(HostLabel);
	XtManageChild(HostText);
	XtManageChild(Form1);

	Form2 = XmCreateForm(Form, "PortForm", NULL, 0);
	XtVaSetValues(Form2,
		      XmNtopAttachment, XmATTACH_WIDGET,
		      XmNtopWidget, Form1,
		      XmNleftAttachment, XmATTACH_FORM,
		      XmNrightAttachment, XmATTACH_FORM,
		      NULL);
	PortLabel = XmCreateLabel(Form2, "Port", NULL, 0);
	PortText = XmCreateTextField(Form2, "PortText", NULL, 0);
	XtVaSetValues(PortLabel,
		      XmNtopAttachment, XmATTACH_FORM,
		      XmNleftAttachment, XmATTACH_FORM,
		      XmNbottomAttachment, XmATTACH_FORM,
		      NULL);
	XtVaSetValues(PortText,
		      XmNtopAttachment, XmATTACH_FORM,
		      XmNbottomAttachment, XmATTACH_FORM,
		      XmNleftAttachment, XmATTACH_WIDGET,
		      XmNleftWidget, PortLabel,
		      XmNrightAttachment, XmATTACH_FORM,
		      NULL);
	XtManageChild(PortLabel);
	XtManageChild(PortText);
	XtManageChild(Form2);

	XtManageChild(Form);
	XtAddCallback(Host_Dialog(w), XmNokCallback, (XtCallbackProc)OpenHost, w);
	XtAddCallback(Host_Dialog(w), XmNhelpCallback, (XtCallbackProc)XltHelpOnHostSelect, w);
    }
    XmTextFieldSetString(XtNameToWidget(Host_Dialog(w), "*HostText"), Host_Name(w));
    XmTextFieldSetString(XtNameToWidget(Host_Dialog(w), "*PortText"), Host_Port(w));
    XtManageChild(Host_Dialog(w));
}
Beispiel #9
0
static void
PostPrimaryModalDialog(Widget w, XtPointer client_data, XtPointer call_data)
{

    Widget	parent, spawnButton, okButton, cancelButton;
    int 	n;
    Arg 	args[MAX_ARGS];
    XmString tcs;
	char	title[NAME_LEN + 1];
	int		DialogCount;

	char	get_menu[1000];

	title[0] = '\0';

	if (PrimaryDialogCount >= MAX_DIALOGS) {
		fprintf(stderr, "Too many primary dialogs\n");
		return;
	}

	for (DialogCount = 0; DialogCount < MAX_DIALOGS; DialogCount++)
		if (PrimaryDia[DialogCount].DialogIndex == -1)
			break;
	if (DialogCount == MAX_DIALOGS) {
		fprintf(stderr, "No more primary dialogs\n");
		return;
	}
	sprintf(title, "Primary%d", DialogCount);
    parent = (Widget) client_data;

    n = 0;
    /* message box resources */
    XtSetArg (args[n], XmNmessageString, 
			  XmStringCreateSimple (PrimaryMsg)); n++;
    XtSetArg (args[n], XmNhelpLabelString, 
			  XmStringCreateSimple ("Spawn Dialog Child")); n++;

    /* dialog shell resources */
    XtSetArg (args[n], XmNtitle, title); n++;
    XtSetArg (args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL);
			  n++;

	/* VendorShell resources */
#ifndef MOTIF1_1

	if (Test1_2 == True) {
		XtSetArg(args[n], XmNmwmMenu, MeuStrDia2); n++;
	}
	else {
		XtSetArg(args[n], XmNmwmMenu, MenuStrDia1); n++;
	}

#else

	XtSetArg(args[n], XmNmwmMenu, MenuStrDia1); n++;

#endif /* MOTIF1_1 */

    PrimaryDia[DialogCount].Dialog= XmCreateMessageDialog(parent, title, 
															 args, n);

/* make HELP button spawn a child */
    spawnButton = XmMessageBoxGetChild (PrimaryDia[DialogCount].Dialog, 
										XmDIALOG_HELP_BUTTON);
    XtAddCallback (spawnButton, XmNactivateCallback, 
				   PostPrimaryModalDialog, PrimaryDia[DialogCount].Dialog);

    okButton = XmMessageBoxGetChild (PrimaryDia[DialogCount].Dialog, 
									 XmDIALOG_OK_BUTTON);
    cancelButton = XmMessageBoxGetChild (PrimaryDia[DialogCount].Dialog, 
									 	 XmDIALOG_CANCEL_BUTTON);
    XtAddCallback (okButton, XmNactivateCallback, 
				   DestroyPrimaryDialog, 
				   (XtPointer) &PrimaryDia[DialogCount]);
    XtAddCallback (cancelButton, XmNactivateCallback, 
				   DestroyPrimaryDialog, 
				   (XtPointer) &PrimaryDia[DialogCount]);

    XtManageChild (PrimaryDia[DialogCount].Dialog);
	PrimaryDia[DialogCount].DialogIndex = DialogCount;
	PrimaryDia[DialogCount].Parent = parent;
	PrimaryDialogCount++;

	n = 0;
	XtSetArg(args[n], XmNmwmMenu, get_menu); n++;
	XtGetValues(PrimaryDia[DialogCount].Dialog, args, n);
	fprintf(stderr, "Menu of %d Prim dialog = %s\n", DialogCount, get_menu);

}
Beispiel #10
0
Widget XmCreateMessageDialog_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateMessageDialog(parent, name, arglist, argcount);}
Beispiel #11
0
/* Pop up a dialog for editing the text flags.
 * If the user hits OK, clear out the pixcache and resize the phototable.
 */
void ConfigureText(Widget pb, void *userData,
		   XmAnyCallbackStruct *callData)
{
  Widget shell, pane, subpane, w;
  Arg arg[20];
  int n;
  char str[100];

  n=0;
  XtSetArg(arg[n], XmNvisual, appData->visual); n++;
  XtSetArg(arg[n], XmNdepth, appData->depth); n++;
  XtSetArg(arg[n], XmNcolormap, appData->colormap); n++;

  XtSetArg(arg[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
  shell = XmCreateMessageDialog(appData->shell, "Configure Text", arg, n);
  XtUnmanageChild(XmMessageBoxGetChild(shell, XmDIALOG_HELP_BUTTON));
  XtAddCallback(shell, XmNokCallback, (XtCallbackProc)OkCallback, NULL);

  n=0;
  pane = XmCreateRowColumn(shell, "configTextPane", arg, n);

  n = 0;
  XtSetArg(arg[n], XmNset, appData->show_name); n++;
  w = XmCreateToggleButton(pane, "nameToggle", arg, n);
  XtManageChild(w);
  nameToggle = w;

  n = 0;
  XtSetArg(arg[n], XmNorientation, XmHORIZONTAL); n++;
  subpane = XmCreateRowColumn(pane, "annSubpane", arg, n);
  n = 0;
  if(appData->show_annotation)
    XtSetArg(arg[n], XmNvalue, appData->show_annotation); n++;
  XtSetArg(arg[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
  w = XmCreateText(subpane, "annText", arg, n);
  XtManageChild(w);
  annText = w;
  w = XmCreateLabel(subpane, "annLabel", NULL, 0);
  XtManageChild(w);
  XtManageChild(subpane);

  n = 0;
  XtSetArg(arg[n], XmNset, appData->show_label); n++;
  w = XmCreateToggleButton(pane, "labelToggle", arg, n);
  XtAddCallback(w, XmNvalueChangedCallback,
		(XtCallbackProc)toggleCB, NULL);
  XtManageChild(w);
  labelToggle = w;

  n = 0;
  XtSetArg(arg[n], XmNset, appData->show_tree); n++;
  XtSetArg(arg[n], XmNsensitive, appData->show_label); n++;
  w = XmCreateToggleButton(pane, "treeToggle", arg, n);
  XtManageChild(w);
  treeToggle = w;

  n = 0;
  XtSetArg(arg[n], XmNset, appData->show_dist); n++;
  w = XmCreateToggleButton(pane, "distToggle", arg, n);
  XtManageChild(w);
  distToggle = w;

  XtManageChild(pane);
  XtManageChild(shell);
}
Beispiel #12
0
int CoWowMotif::DisplayWarranty()
{
    char    text[4000];
    Arg	    arg[12];
    Widget  question_widget;
    XmString CStr2, TitleStr, okstr, cancelstr, helpstr;
    wow_t_question_cb *cbdata;
    XmFontList fontlist;
    XFontStruct *font;
    XmFontListEntry fontentry;
    char 	title[80];
    FILE 	*fp;
    int 	i;
    char 	fname[256];

    // Display only once
    if ( HideWarranty())
      return 1;

    sprintf( fname, "$pwr_exe/%s/acceptlicense.txt", lng_get_language_str());
    dcli_translate_filename( fname, fname);

    fp = fopen( fname, "r");
    if ( !fp) {
      strcpy( fname, "$pwr_exe/en_us/acceptlicense.txt");
      dcli_translate_filename( fname, fname);
      fp = fopen( fname, "r");
      if ( !fp) return 1;
    }

    for ( i = 0; i < (int)sizeof(text) - 1; i++) {
      text[i] = fgetc( fp);
      if ( text[i] == EOF)
	break;
    }
    text[i] = 0;
    fclose( fp);

    strcpy( title, lng_translate("Accept License Terms"));

    // Set default fontlist
    font = XLoadQueryFont( XtDisplay(m_parent),
	      "-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
    fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
    fontlist = XmFontListAppendEntry( NULL, fontentry);
    XtFree( (char *)fontentry);
    
    CStr2 = XmStringCreateLtoR( text, XmSTRING_DEFAULT_CHARSET);
    TitleStr = XmStringCreateLtoR( title, XmSTRING_DEFAULT_CHARSET);    
    okstr = XmStringCreateLtoR( lng_translate( "I Accept"), XmSTRING_DEFAULT_CHARSET );    
    cancelstr = XmStringCreateLtoR( lng_translate( "Quit"), XmSTRING_DEFAULT_CHARSET );    
    helpstr = XmStringCreateLtoR( lng_translate( "Show License"), XmSTRING_DEFAULT_CHARSET );    
    XtSetArg(arg[0],XmNheight,75);
    XtSetArg(arg[1],XmNwidth,700);
    XtSetArg(arg[2],XmNmessageString, CStr2);
    XtSetArg(arg[3],XmNx,400);
    XtSetArg(arg[4],XmNy,300);
    XtSetArg(arg[5],XmNdialogTitle,TitleStr);
    XtSetArg(arg[6], XmNokLabelString, okstr);
    XtSetArg(arg[7], XmNcancelLabelString, cancelstr);
    XtSetArg(arg[8], XmNhelpLabelString, helpstr);
    XtSetArg(arg[9], XmNbuttonFontList, fontlist);
    XtSetArg(arg[10], XmNlabelFontList, fontlist);
    XtSetArg(arg[11], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL);

    cbdata = (wow_t_question_cb *) XtCalloc( 1, sizeof(*cbdata));
    cbdata->questionbox_ok = warranty_ok_cb;
    cbdata->questionbox_cancel = warranty_cancel_cb;
    cbdata->questionbox_help = warranty_help_cb;
    cbdata->ctx = 0;
    cbdata->data = (void *)this;

    question_widget = XmCreateMessageDialog( m_parent,(char*) "questionDialog",arg, 12);
    XtAddCallback( question_widget, XmNokCallback,
		(XtCallbackProc) question_ok_cb, cbdata);
    XtAddCallback( question_widget, XmNcancelCallback, 
		(XtCallbackProc) question_cancel_cb, cbdata);
    XtAddCallback( question_widget, XmNhelpCallback, 
		(XtCallbackProc) question_help_cb, cbdata);

    XmStringFree( CStr2);
    XmStringFree( TitleStr);
    XmStringFree( okstr);
    XmStringFree( cancelstr);
    XmStringFree( helpstr);
    XmFontListFree( fontlist);
   
    XtManageChild( question_widget);	       
    return 1;
}
Beispiel #13
0
void CoWowMotif::DisplayLicense()
{
    char text[20000];
    Arg	    arg[11];
    Widget  question_widget;
    XmString CStr2, TitleStr, cancelstr;
    XmFontList fontlist;
    XFontStruct *font;
    XmFontListEntry fontentry;
    char title[80];
    Widget w;
    FILE *fp;
    char fname[200];
    int i;
    Widget wcancel;

    strcpy( title, lng_translate("License"));

    sprintf( fname, "$pwr_exe/%s/license.txt", lng_get_language_str());
    dcli_translate_filename( fname, fname);

    fp = fopen( fname, "r");
    if ( !fp) {
      strcpy( fname, "$pwr_exe/en_us/lincense.txt");
      dcli_translate_filename( fname, fname);
      fp = fopen( fname, "r");
      if ( !fp)
	return;
    }

    for ( i = 0; i < (int)sizeof(text) - 1; i++) {
      text[i] = fgetc( fp);
      if ( text[i] == EOF)
	break;
    }
    fclose( fp);
    text[i] = 0;

    // Set default fontlist
    font = XLoadQueryFont( XtDisplay(m_parent),
	      "-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
    fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
    fontlist = XmFontListAppendEntry( NULL, fontentry);
    XtFree( (char *)fontentry);

    CStr2 = XmStringCreateLtoR( (char*) "", XmSTRING_DEFAULT_CHARSET);
    TitleStr = XmStringCreateLtoR( title, XmSTRING_DEFAULT_CHARSET);    
    cancelstr = XmStringCreateLtoR( (char*) " Close ", XmSTRING_DEFAULT_CHARSET );    
    XtSetArg(arg[0],XmNheight,400);
    XtSetArg(arg[1],XmNwidth,600);
    XtSetArg(arg[2],XmNmessageString, CStr2);
    XtSetArg(arg[3],XmNx,400);
    XtSetArg(arg[4],XmNy,300);
    XtSetArg(arg[5],XmNdialogTitle,TitleStr);
    XtSetArg(arg[6], XmNcancelLabelString, cancelstr);
    XtSetArg(arg[7], XmNbuttonFontList, fontlist);
    XtSetArg(arg[8], XmNlabelFontList, fontlist);

    question_widget = XmCreateMessageDialog( m_parent,(char*) "questionDialog",arg,9);
    XmStringFree( CStr2);
    XmStringFree( TitleStr);
    XmStringFree( cancelstr);
    XmFontListFree( fontlist);
    wcancel = XmMessageBoxGetChild(question_widget, XmDIALOG_CANCEL_BUTTON);
   

    XtSetArg(arg[0], XmNscrollHorizontal, True);
    XtSetArg(arg[1], XmNscrollVertical, True);
    XtSetArg(arg[2], XmNeditMode, XmMULTI_LINE_EDIT);
    XtSetArg(arg[3], XmNeditable, False);
    XtSetArg(arg[4], XmNcursorPositionVisible, False);
    XtSetArg(arg[5], XmNrows, 30);
    XtSetArg(arg[6], XmNvalue, text);
    XtSetArg(arg[7], XmNfontList, fontlist);
    w = XmCreateScrolledText( question_widget, (char*) "text", arg, 7);
    XtVaSetValues( XtParent(w), 
		   XmNleftAttachment, XmATTACH_FORM,
		   XmNrightAttachment, XmATTACH_FORM,
		   XmNtopAttachment, XmATTACH_FORM,
		   XmNbottomAttachment, XmATTACH_WIDGET,
		   XmNbottomWidget, wcancel,
		   NULL);
    XtManageChild(w);

    w = XmMessageBoxGetChild(question_widget, XmDIALOG_OK_BUTTON);
    XtUnmanageChild( w);    
    
    w = XmMessageBoxGetChild(question_widget, XmDIALOG_HELP_BUTTON);
    XtUnmanageChild( w);    

    XtManageChild( question_widget);	       
}
Beispiel #14
0
void MAPaintTabletInit(
  ThreeDViewStruct	*view_struct)
{
  TabletEvent	event;
  int		quitFlag;
  Widget	dialog;
  XmString	text, title;
  WlzDVertex2	tabVtxs[2], wlzVtxs[2];
  Widget	slider;
  WlzAffineTransform	*trans;

  /* ignore if already open */
  if( tablet ){
    return;
  }

  /* open the tablet */
  if( (tablet = TabletOpen(WACOM_IV_TABLET_TYPE,
			   "/dev/term/b", NULL)) == NULL ){
    HGU_XmUserError(globals.topl,
		    "Open Wacom Tablet:\n"
		    "    Failed to open the tablet, please check\n"
		    "    the tablet is connected to serial line b\n"
		    "    and switched on, then try again.",
		    XmDIALOG_FULL_APPLICATION_MODAL);
    return;
  }

  /* set tilt mode and start the tablet */
  TabletSetMode(tablet, TABLET_TILTMODE_MASK);
  tablet->cntrlMode2 |= TABLET_CORRECT_TILT_MASK;
  tablet->cntrlMode2 |= TABLET_TRANSFORM_MASK;
  TabletStart(tablet);

  /* if the tablet needs the coordinates set then do so here */
  if( !view_struct->tablet_initialised ){
    /* get first coordinate */
    /* put up an application modal dialog to request first
       coordinate */
    dialog = XmCreateMessageDialog(view_struct->canvas,
				   "MAPaint Message", NULL, 0);
    XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_CANCEL_BUTTON));
    XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_OK_BUTTON));
    XtSetSensitive(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON),
		   False);
    text  = XmStringCreateLtoR("Input tablet reference point 1 please",
			       XmSTRING_DEFAULT_CHARSET);
    title = XmStringCreateSimple("MAPaint Tablet Message");

    XtVaSetValues(dialog,
		  XmNmessageString,	text,
		  XmNdialogTitle,	title,
		  XmNdialogStyle,	XmDIALOG_FULL_APPLICATION_MODAL,
		  NULL);

    XmStringFree( text );
    XmStringFree( title );

    /* popup widget and process events */
    XtManageChild( dialog );
    XSync(XtDisplay(view_struct->canvas), False);
    quitFlag = 0;
    while( quitFlag < 100 ){
      if((XtAppPending(globals.app_con) > 0) ){
	XtAppProcessEvent(globals.app_con, XtIMAll);
      }
      else {
	XSync(XtDisplay(view_struct->canvas), False);
	usleep(1000);
	quitFlag++;
      }
    }
    
    quitFlag = 0;
    while( !quitFlag ){
      if( TabletNextEvent(tablet, &event) == TABLET_ERR_NONE ){
	if(event.buttonPressed && 
	   ((event.buttons == 1) || (event.buttons == 3))){
	  tabVtxs[0].vtX = event.x;
	  tabVtxs[0].vtY = event.y;
	  quitFlag = 1;
	  XBell(XtDisplay(view_struct->canvas), 100);
	  XFlush(XtDisplay(view_struct->canvas));
	}
      }
      else {
	TabletClose(tablet);
	tablet = NULL;
	XtDestroyWidget(dialog);
	return;
      }
    }

    /* get second coordinate */
    text  = XmStringCreateLtoR("Input tablet reference point 2 please",
			       XmSTRING_DEFAULT_CHARSET);

    XtVaSetValues(dialog,
		  XmNmessageString,	text,
		  NULL);

    XmStringFree( text );

    /* popup widget and process events */
    XtManageChild( dialog );
    XSync(XtDisplay(view_struct->canvas), False);
    while( (XtAppPending(globals.app_con) > 0) ){
      XtAppProcessEvent(globals.app_con, XtIMAll);
      XSync(XtDisplay(view_struct->canvas), False);
    }
    
    quitFlag = 0;
    sleep(1);
    TabletClearEvents(tablet);
    while( !quitFlag ){
      if( TabletNextEvent(tablet, &event) == TABLET_ERR_NONE ){
	if(event.buttonPressed && 
	   ((event.buttons == 1) || (event.buttons == 3))){
	  tabVtxs[1].vtX = event.x;
	  tabVtxs[1].vtY = event.y;
	  quitFlag = 1;
	  XBell(XtDisplay(view_struct->canvas), 100);
	  XFlush(XtDisplay(view_struct->canvas));
	}
      }
      else {
	TabletClose(tablet);
	XtDestroyWidget(dialog);
	tablet = NULL;
	return;
      }
    }
    TabletStop(tablet);
    XtDestroyWidget(dialog);
    usleep(10000);
    TabletClearEvents(tablet);

    /* set the reference coordinates */
    view_struct->ref1.vtX = tabVtxs[0].vtX;
    view_struct->ref1.vtY = tabVtxs[0].vtY;
    view_struct->ref2.vtX = tabVtxs[1].vtX;
    view_struct->ref2.vtY = tabVtxs[1].vtY;
  }
  else {
    tabVtxs[0].vtX = view_struct->ref1.vtX;
    tabVtxs[0].vtY = view_struct->ref1.vtY;
    tabVtxs[1].vtX = view_struct->ref2.vtX;
    tabVtxs[1].vtY = view_struct->ref2.vtY;
  }

  /* set tablet transform parameters */
  if((slider = XtNameToWidget(tablet_controls, "*.x1")) )
  {
    wlzVtxs[0].vtX = HGU_XmGetSliderValue(slider);
  }
  if((slider = XtNameToWidget(tablet_controls, "*.y1")) )
  {
    wlzVtxs[0].vtY = HGU_XmGetSliderValue(slider);
  }
  if((slider = XtNameToWidget(tablet_controls, "*.x2")) )
  {
    wlzVtxs[1].vtX = HGU_XmGetSliderValue(slider);
  }
  if( (slider = XtNameToWidget(tablet_controls, "*.y2")))
  {
    wlzVtxs[1].vtY = HGU_XmGetSliderValue(slider);
  }
  trans = WlzAffineTransformLSq2D(2, tabVtxs, 2, wlzVtxs, 0, NULL,
				  WLZ_TRANSFORM_2D_NOSHEAR, NULL);
  tablet->xTrans[0] = trans->mat[0][0];
  tablet->xTrans[1] = trans->mat[0][1];
  tablet->xTrans[2] = trans->mat[0][2];
  tablet->yTrans[0] = trans->mat[1][0];
  tablet->yTrans[1] = trans->mat[1][1];
  tablet->yTrans[2] = trans->mat[1][2];
  WlzFreeAffineTransform(trans);
  view_struct->tablet_initialised = 1;

  /* initialise the globals */
  modifiers = 0;
  tabletDrawingFlag = 0;
  quitDrawingTrigger = 0;
  if( tabletPoly ){
    WlzFreePolyDmn(tabletPoly);
    tabletPoly = NULL;
  }

  /* now add the tablet stream as an event input source */
  TabletStart(tablet);
  TabletClearEvents(tablet);
  tabletInputId = XtAppAddInput(globals.app_con, tablet->fd,
				(XtPointer) XtInputReadMask,
				tabletInputProc, (XtPointer) view_struct);

  return;
}
Beispiel #15
0
static void make_edit_find_dialog(bool managed)
{
  if (!edit_find_dialog)
    {
      Widget dl, rc;
      Arg args[20];
      int n;
      XmString xmstr1, xmstr3, titlestr;

      n = 0;
      XtSetArg(args[n], XmNbackground, ss->basic_color); n++;
      xmstr1 = XmStringCreateLocalized((char *)"Go Away");
      xmstr3 = XmStringCreateLocalized((char *)"Previous");
      titlestr = XmStringCreateLocalized((char *)"Find");
      XtSetArg(args[n], XmNokLabelString, xmstr1); n++;
      XtSetArg(args[n], XmNcancelLabelString, xmstr3); n++;
      XtSetArg(args[n], XmNautoUnmanage, false); n++;
      XtSetArg(args[n], XmNdialogTitle, titlestr); n++;
      XtSetArg(args[n], XmNresizePolicy, XmRESIZE_GROW); n++;
      XtSetArg(args[n], XmNnoResize, false); n++;
      XtSetArg(args[n], XmNtransient, false); n++;
      edit_find_dialog = XmCreateMessageDialog(MAIN_SHELL(ss), (char *)"find", args, n);
      
      XmStringFree(xmstr1);
      XmStringFree(xmstr3);
      XmStringFree(titlestr);
      
      XtUnmanageChild(XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_SYMBOL_LABEL));
      XtUnmanageChild(XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_MESSAGE_LABEL));
      
      XtAddCallback(edit_find_dialog, XmNhelpCallback, edit_find_help_callback, NULL);
      XtAddCallback(edit_find_dialog, XmNcancelCallback, edit_find_previous_callback, NULL);
      XtAddCallback(edit_find_dialog, XmNokCallback, edit_find_cancel_callback, NULL);
      
      n = 0;
      XtSetArg(args[n], XmNbackground, ss->highlight_color); n++;
      XtSetArg(args[n], XmNarmColor, ss->selection_color); n++;
      findnextB = XtCreateManagedWidget("Next", xmPushButtonGadgetClass, edit_find_dialog, args, n);
      XtAddCallback(findnextB, XmNactivateCallback, edit_find_next_callback, NULL);
      
      rc = XtCreateManagedWidget("row", xmFormWidgetClass, edit_find_dialog, NULL, 0);
      
      n = 0;
      XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
      XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
      XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
      XtSetArg(args[n], XmNrightAttachment, XmATTACH_NONE); n++;
      dl = XtCreateManagedWidget("find:", xmLabelWidgetClass, rc, args, n);
      
      n = 0;
      XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
      XtSetArg(args[n], XmNleftWidget, dl); n++;
      XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
      XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
      XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
      edit_find_text = make_textfield_widget("text", rc, args, n, ACTIVATABLE, add_completer_func(expression_completer, NULL));
      
      n = 0;
      XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
      XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
      XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
      XtSetArg(args[n], XmNtopWidget, edit_find_text); n++;
      XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
      XtSetArg(args[n], XmNmarginHeight, 10); n++;
      edit_find_label = XtCreateManagedWidget("    ", xmLabelWidgetClass, rc, args, n);
      
      n = 0;
      XtSetArg(args[n], XmNbackground, ss->basic_color); n++;
      XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
      XtSetArg(args[n], XmNtopWidget, edit_find_label); n++;
      XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
      XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
      XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
      XtSetArg(args[n], XmNallowResize, true); n++;
      XtSetArg(args[n], XmNshadowType, XmSHADOW_ETCHED_IN); n++;
      XtSetArg(args[n], XmNshadowThickness, 2); n++;
      find_error_frame = XtCreateManagedWidget("find-error-frame", xmFrameWidgetClass, rc, args, n);

      n = 0;
      XtSetArg(args[n], XmNbackground, ss->highlight_color); n++;
      find_error_label = XtCreateManagedWidget("", xmLabelWidgetClass, find_error_frame, args, n);
      
      map_over_children(edit_find_dialog, set_main_color_of_widget);
      XtVaSetValues(XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_OK_BUTTON), XmNarmColor, ss->selection_color, NULL);
      XtVaSetValues(XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_CANCEL_BUTTON), XmNarmColor, ss->selection_color, NULL);
      XtVaSetValues(XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_HELP_BUTTON), XmNarmColor, ss->selection_color, NULL);
      XtVaSetValues(XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_OK_BUTTON), XmNbackground, ss->highlight_color, NULL);
      XtVaSetValues(XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_CANCEL_BUTTON), XmNbackground, ss->highlight_color, NULL);
      XtVaSetValues(XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_HELP_BUTTON), XmNbackground, ss->highlight_color, NULL);

      cancelB = XmMessageBoxGetChild(edit_find_dialog, XmDIALOG_OK_BUTTON);
      set_dialog_widget(FIND_DIALOG, edit_find_dialog);

      XtUnmanageChild(find_error_frame);

      if (managed) XtManageChild(edit_find_dialog);

      {
	Atom wm_delete_window;
	wm_delete_window = XmInternAtom(MAIN_DISPLAY(ss), (char *)"WM_DELETE_WINDOW", false);
	XmAddWMProtocolCallback(XtParent(edit_find_dialog), wm_delete_window, find_dialog_close, NULL);
      }
    }
  else
    {
      if (managed)
	{
	  if (!XtIsManaged(edit_find_dialog)) XtManageChild(edit_find_dialog);
	  raise_dialog(edit_find_dialog);
	}
    }
}
Beispiel #16
0
static int motMessageDlgPopup(Ihandle* ih, int x, int y)
{
  InativeHandle* parent = iupDialogGetNativeParent(ih);
  Widget msgbox, dialog;
  int style = XmDIALOG_FULL_APPLICATION_MODAL;
  int type = XmDIALOG_MESSAGE;
  int num_but = 2;
  char *value;

  iupAttribSetInt(ih, "_IUPDLG_X", x);   /* used in iupDialogUpdatePosition */
  iupAttribSetInt(ih, "_IUPDLG_Y", y);

  if (parent)
  {
    msgbox = XmCreateMessageDialog(parent, "messagedialog", NULL, 0);
    dialog = XtParent(msgbox);
  }
  else
  {
    dialog = XtAppCreateShell(NULL, "messagedialog", topLevelShellWidgetClass, iupmot_display, NULL, 0);
    msgbox = XmCreateMessageBox(dialog, "messagebox", NULL, 0);
    style = XmDIALOG_MODELESS;
    XtVaSetValues(dialog,
      XmNmwmInputMode, MWM_INPUT_FULL_APPLICATION_MODAL,
      XmNmappedWhenManaged, False,
      XmNsaveUnder, True,
      NULL);
  }
  if (!msgbox)
    return IUP_NOERROR;

  value = iupAttribGetStr(ih, "DIALOGTYPE");
  if (iupStrEqualNoCase(value, "ERROR"))
    type = XmDIALOG_ERROR;
  else if (iupStrEqualNoCase(value, "WARNING"))
    type = XmDIALOG_WARNING;
  else if (iupStrEqualNoCase(value, "INFORMATION"))
    type = XmDIALOG_INFORMATION;
  else if (iupStrEqualNoCase(value, "QUESTION"))
    type = XmDIALOG_QUESTION;


  value = iupAttribGet(ih, "TITLE");
  if (value)
    iupmotSetString(msgbox, XmNdialogTitle, value);
  else
  {
    if (parent)
    {
      XmString title;
      XtVaGetValues(parent, XmNdialogTitle, &title, NULL);
      XtVaSetValues(msgbox, XmNdialogTitle, title, NULL);
    }
  }

  value = iupAttribGet(ih, "VALUE");
  if (value)
    iupmotSetString(msgbox, XmNmessageString, value);

  XtVaSetValues(msgbox,
                XmNdialogType, type,
                XmNdialogStyle, style,
                XmNautoUnmanage, False,
                XmNnoResize, True,
                NULL);

  value = iupAttribGetStr(ih, "BUTTONS");
  if (iupStrEqualNoCase(value, "OK"))
  {
    XtUnmanageChild(XmMessageBoxGetChild(msgbox, XmDIALOG_CANCEL_BUTTON));
    num_but = 1;
  }
  else if (iupStrEqualNoCase(value, "YESNO"))
  {
    iupmotSetString(msgbox, XmNokLabelString, iupStrMessageGet("IUP_YES"));
    iupmotSetString(msgbox, XmNcancelLabelString, iupStrMessageGet("IUP_NO"));
  }

  if (!IupGetCallback(ih, "HELP_CB"))
    XtUnmanageChild(XmMessageBoxGetChild(msgbox, XmDIALOG_HELP_BUTTON));

  if (num_but == 2 && iupAttribGetInt(ih, "BUTTONDEFAULT") == 2)
    XtVaSetValues(msgbox, XmNdefaultButtonType, XmDIALOG_CANCEL_BUTTON, NULL);
  else
    XtVaSetValues(msgbox, XmNdefaultButtonType, XmDIALOG_OK_BUTTON, NULL);

  XtAddCallback(msgbox, XmNokCallback, (XtCallbackProc)motMessageDlgCallback, (XtPointer)ih);
  XtAddCallback(msgbox, XmNcancelCallback, (XtCallbackProc)motMessageDlgCallback, (XtPointer)ih);
  XtAddCallback(msgbox, XmNhelpCallback, (XtCallbackProc)motMessageDlgHelpCallback, (XtPointer)ih);

  XmAddWMProtocolCallback(dialog, iupmot_wm_deletewindow, motMessageDlgDeleteWindowCallback, (XtPointer)ih);
  XtManageChild(msgbox);

  XtRealizeWidget(dialog);
  ih->handle = dialog;
  iupDialogUpdatePosition(ih);
  ih->handle = NULL;  /* reset handle */

  if (style == XmDIALOG_MODELESS)
    XtPopup(dialog, XtGrabExclusive);

  /* while the user hasn't provided an answer, simulate main loop.
  ** The answer changes as soon as the user selects one of the
  ** buttons and the callback routine changes its value. */
  iupAttribSetStr(ih, "BUTTONRESPONSE", NULL);
  while (iupAttribGet(ih, "BUTTONRESPONSE") == NULL)
    XtAppProcessEvent(iupmot_appcontext, XtIMAll);

  if (!iupAttribGet(ih, "_IUP_WM_DELETE"))
  {
    XtUnmanageChild(msgbox);

    if (style == XmDIALOG_MODELESS)
    {
      XtPopdown(dialog);
      XtDestroyWidget(dialog);
    }
  }

  return IUP_NOERROR;
}
Beispiel #17
0
/******************************************************
  createActionDialog
******************************************************/
void createActionDialog(Widget parent,int dialogType,char *message1,
XtCallbackProc okCallback,XtPointer okParm,XtPointer userParm)
{
	static Widget         dialog = 0; /* make it static for reuse */
	XmString              str,str1,str2,str3;
	static XtCallbackProc oldOkCallback = 0;
	static XtPointer      oldOkParm = 0;

	if (dialog && XtIsManaged(dialog)) XtUnmanageChild(dialog);
	if (!dialogType ) return;

	/* destroy runtimeToplevel dialog so dialog is positioned properly */
	if ( parent && dialog &&
	    XtParent(XtParent(dialog)) != parent) {
		XtDestroyWidget(dialog);
		dialog = 0;
	}

	if (!dialog) {
		dialog = XmCreateMessageDialog(parent, "Dialog", NULL, 0);
		XtSetSensitive(XmMessageBoxGetChild(dialog,XmDIALOG_HELP_BUTTON),FALSE);
		XtAddCallback(dialog,XmNcancelCallback,(XtCallbackProc) XtUnmanageChild,NULL);

	} else {
		XtRemoveCallback(dialog,XmNokCallback,oldOkCallback,(XtPointer)oldOkParm);
	}

	switch(dialogType) {
	case XmDIALOG_WARNING:
		str = XmStringCreateSimple("WarningDialog");
		break;
	case XmDIALOG_ERROR:
		str = XmStringCreateSimple("ErrorDialog");
		break;
	case XmDIALOG_INFORMATION:
		str = XmStringCreateSimple("InformationDialog");
		break;
	case XmDIALOG_MESSAGE:
		str = XmStringCreateSimple("MessageDialog");
		break;
	case XmDIALOG_QUESTION:
		str = XmStringCreateSimple("QuestionDialog");
		break;
	case XmDIALOG_WORKING:
		str = XmStringCreateSimple("WorkingDialog");
		break;
	default:
		str = XmStringCreateSimple("InformationDialog");
		break;
	}

	str1 = XmStringCreateLtoR("ALH ",XmFONTLIST_DEFAULT_TAG);
	str3 = XmStringConcat(str1,str);

	str2=XmStringCreateLtoR(message1,XmSTRING_DEFAULT_CHARSET);
	XtVaSetValues(dialog,
	    XmNuserData,      userParm,
	    XmNdialogType,  dialogType,
	    XmNdialogTitle, str3,
	    XmNmessageString, str2,
	    (XtPointer)NULL);
	XmStringFree(str);
	XmStringFree(str2);

	XtAddCallback(dialog,XmNokCallback,okCallback,okParm);
	oldOkCallback = okCallback;
	oldOkParm = okParm;

	XtManageChild(dialog);
	XFlush(display);
	/*
	     XmUpdateDisplay(dialog);
	*/
	return;
}
Beispiel #18
0
static void
PostSystemModalDialog(Widget w, XtPointer client_data, XtPointer call_data)
{

    Widget	parent, spawnButton, okButton, cancelButton;
    int 	n;
    Arg 	args[MAX_ARGS];
    XmString tcs;
	char	title[NAME_LEN + 1];
	int		DialogCount;

	title[0] = '\0';

	if (SystemDialogCount >= MAX_DIALOGS) {
		fprintf(stderr, "Too many system dialogs\n");
		return;
	}

	for (DialogCount = 0; DialogCount < MAX_DIALOGS; DialogCount++)
		if (SystemDia[DialogCount].DialogIndex == -1)
			break;
	if (DialogCount == MAX_DIALOGS) {
		fprintf(stderr, "No more system dialogs\n");
		return;
	}
	sprintf(title, "System%d", DialogCount);
    parent = (Widget) client_data;

    n = 0;
    /* message box resources */
    XtSetArg (args[n], XmNmessageString, 
			  XmStringCreateSimple (SystemMsg)); n++;
    XtSetArg (args[n], XmNhelpLabelString, 
			  XmStringCreateSimple ("Spawn Dialog Child")); n++;

    /* dialog shell resources */
    XtSetArg (args[n], XmNtitle, title); n++;
    XtSetArg (args[n], XmNdialogStyle, XmDIALOG_SYSTEM_MODAL);
			  n++;

	/* VendorShell resources */
#ifndef MOTIF1_1

	if (Test1_2 == True) {
		XtSetArg(args[n], XmNmwmMenu, MeuStrDia2); n++;
	}

#endif /* MOTIF1_1 */

    SystemDia[DialogCount].Dialog= XmCreateMessageDialog(parent, title, 
															 args, n);

/* make HELP button spawn a child */
    spawnButton = XmMessageBoxGetChild (SystemDia[DialogCount].Dialog, 
										XmDIALOG_HELP_BUTTON);
    XtAddCallback (spawnButton, XmNactivateCallback, 
				   PostSystemModalDialog, SystemDia[DialogCount].Dialog);

    okButton = XmMessageBoxGetChild (SystemDia[DialogCount].Dialog, 
									 XmDIALOG_OK_BUTTON);
    cancelButton = XmMessageBoxGetChild (SystemDia[DialogCount].Dialog, 
									 	 XmDIALOG_CANCEL_BUTTON);
    XtAddCallback (okButton, XmNactivateCallback, 
				   DestroySystemDialog, 
				   (XtPointer) &SystemDia[DialogCount]);
    XtAddCallback (cancelButton, XmNactivateCallback, 
				   DestroySystemDialog, 
				   (XtPointer) &SystemDia[DialogCount]);

    XtManageChild (SystemDia[DialogCount].Dialog);
	SystemDia[DialogCount].DialogIndex = DialogCount;
	SystemDia[DialogCount].Parent = parent;
	SystemDialogCount++;

}
Beispiel #19
0
/***************************************************************************
  Creates the process message dialog and callbacks.  Although many
  static items like signal names are set up, values for various fields
  like the priority and and process information are reassigned only
  after a particular process is selected.
***************************************************************************/
Widget
create_process_menu(Widget parent, char *name)
{
  Widget form;

#include "help/process_window.h"
#ifdef HAVE_KILL
  int i;
  XmStringTable xmstr;

  xmstr = ( XmString * ) XtMalloc (sizeof ( XmString ) * sigmap_elts ) ;
  for  ( i = 0; i < sigmap_elts; i++ ) {
    xmstr[i] = XmStringCreateLtoR ( signal_map[i].signal_name, 
				    XmFONTLIST_DEFAULT_TAG );
  }
#endif

  /* Create the dialog widget. */
  process_dialog = XmCreateMessageDialog ( parent, name, NULL, 0 );

  XtAddCallback(process_dialog, XmNokCallback, do_process_action_callback, 
		&dialog_signal_pos);

  XtAddCallback(process_dialog, XmNcancelCallback, do_process_cancel_callback, 
		NULL);

  XtAddCallback(process_dialog, XmNhelpCallback, help_callback, 
		process_window_help);

  /* 
     Remove unneeded buttons and children. 
   */

  /* This is something along the top line */
  XtUnmanageChild( XmMessageBoxGetChild ( process_dialog, 
					  XmDIALOG_SYMBOL_LABEL ) );
  XtUnmanageChild( XmMessageBoxGetChild ( process_dialog, 
					  XmDIALOG_MESSAGE_LABEL ) );
  /* Create a manager widget as a child of the dialog, to be used
     as the work area of the dialog, replacing the label and icon. 
  */

  process_form = XtVaCreateManagedWidget( "form", xmFormWidgetClass, 
					  process_dialog, NULL ) ;

  form = 
    XtVaCreateManagedWidget("processForm", xmFormWidgetClass,
			    process_form,
			    XmNorientation,       XmVERTICAL,
			    XmNtopAttachment,     XmATTACH_NONE,
			    XmNleftAttachment,    XmATTACH_FORM,
			    XmNrightAttachment,   XmATTACH_FORM,
			    XmNbottomAttachment,  XmATTACH_FORM,
			    NULL);

  /* Widget for ps info. XmCreateText doesn't do variable args.
     So set up a local temp argument array. Uck! Motif sucks. */
  {
    Arg args[20];
    int n = 0;
    
    XtSetArg(args[n], XmNeditable, False); n++;
    XtSetArg(args[n], XmNcursorPositionVisible, False); n++;
    XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
    XtSetArg(args[n], XmNscrollHorizontal, True); n++;
    XtSetArg(args[n], XmNscrollVertical, True); n++;
    XtSetArg(args[n], XmNtraversalOn, True); n++;
    XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNbottomWidget,       form); n++;
    /* done as X resource, but must be done. 
    XtSetArg(args[n], XmNwidth,              8000); n++;
    XtSetArg(args[n], XmNheight,             1000); n++; 
    XtSetArg(args[n], XmNunitType,           Xm100TH_FONT_UNITS); n++; 
    */
    XtSetArg(args[n], XmNvisualPolicy,       XmVARIABLE); n++;
    XtSetArg(args[n], XmNscrollingPolicy,    XmAUTOMATIC); n++;
    XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED); n++;
    
    ps_info = XmCreateScrolledText(process_form, "PsInfo", args, n);
    XmTextSetString(ps_info, "");
  }
    
#ifdef HAVE_KILL
  signal_list = XmCreateScrolledList( form, "signal_list", NULL, 0 );

  XtManageChild(signal_list);
  XtVaSetValues(signal_list, 
		 XmNitems, xmstr,
		 XmNitemCount, sigmap_elts,
		 XmNvisibleItemCount, 6, 
		 XmNselectionPolicy,   XmSINGLE_SELECT, 
		 XmNtopAttachment,     XmATTACH_WIDGET,
		 XmNtopWidget,         ps_info, 
		 XmNtopAttachment,     XmATTACH_NONE,
		 XmNleftAttachment,    XmATTACH_FORM,
		 XmNrightAttachment,   XmATTACH_NONE,
		 XmNbottomAttachment,  XmATTACH_FORM,
		 NULL );

  for  ( i = 0; i < sigmap_elts; i++ ) {
    XmStringFree ( xmstr[i] );
  }
  XtFree((char *) xmstr);
  
  XtAddCallback( signal_list, XmNdefaultActionCallback, 
		 SignalListCallback, &dialog_signal_pos);
  XtAddCallback( signal_list, XmNsingleSelectionCallback, 
		 SignalListCallback, &dialog_signal_pos);

#endif
  
  /* Priority slider */
  priority_slider = 
    XtVaCreateManagedWidget ("priority", xmScaleWidgetClass, form,
			     XtVaTypedArg, XmNtitleString, 
			     XmRString, "priority",
			     10,
			     XmNmaximum, PRIO_MAX,
			     XmNminimum, PRIO_MIN,
			     XmNvalue, 10,  /* Will be reset later */
			     XmNshowValue,         True,
			     XmNorientation,       XmVERTICAL,
			     XmNtopAttachment,     XmATTACH_FORM,
			     XmNbottomAttachment,  XmATTACH_FORM,
			     XmNleftAttachment,    XmATTACH_WIDGET,

   /* We use XtParent() below because of some (all?) Lesstif 
      complaints. XmCreateScrolledList seems to creates
      a scrolled widgets parent and a list widget child and returns
      the list widget. */
#ifdef HAVE_KILL
			     XmNleftWidget,        XtParent(signal_list),
#endif

			     XmNrightAttachment,   XmATTACH_NONE,
			     XmNbottomAttachment,  XmATTACH_NONE,
			     NULL);

  XtAddCallback(priority_slider, XmNdragCallback, 
		set_priority_callback,  NULL);
  XtAddCallback(priority_slider, XmNvalueChangedCallback, 
		set_priority_callback,  NULL);

  /* Process group identifier */
  process_group_button = 
      XtVaCreateManagedWidget ("process group", xmToggleButtonWidgetClass, 
			       form, 
			       XmNtopAttachment,     XmATTACH_FORM,
			       XmNleftAttachment,    XmATTACH_WIDGET,
			       XmNleftWidget,        priority_slider,
			       XmNrightAttachment,   XmATTACH_NONE,
			       XmNbottomAttachment,  XmATTACH_NONE,
			       NULL);
  XtAddCallback(process_group_button, XmNvalueChangedCallback, 
		toggle_button_callback, &do_process_group);

#ifdef HAVE_SETPRIORITY
  priority_button = 
      XtVaCreateManagedWidget ("set priority", xmToggleButtonWidgetClass, 
			       form, 
			       XmNtopAttachment,     XmATTACH_WIDGET,
			       XmNtopWidget,         process_group_button,
			       XmNleftAttachment,    XmATTACH_WIDGET,
			       XmNleftWidget,        priority_slider,
			       XmNrightAttachment,   XmATTACH_NONE,
			       XmNbottomAttachment,  XmATTACH_FORM,
			       NULL);
  XtAddCallback(priority_button, XmNvalueChangedCallback, 
		toggle_button_callback, &do_priority);
#endif
    
  return(process_dialog);
  
}
Beispiel #20
0
XSilChessWindow::XSilChessWindow(XtAppContext app, Widget toplevel,
                                 Visual * vsl, int vsldepth, Colormap cmap)
{
	char tmp[512];
	Arg al[10];
	int i;
	XmString xms;

	// Initialize member variables
	App=app;
	TopLevel=toplevel;
	Disp=XtDisplay(TopLevel);
	Vsl=vsl;
	VslDepth=vsldepth;
	CMap=cmap;
	DlgVsl=DefaultVisual(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	DlgVslDepth=DefaultDepth(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	DlgCMap=DefaultColormap(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	PixelSize=(VslDepth<=8 ? 1 : (VslDepth<=16 ? 2 : 4));
	RedMask=Vsl->red_mask;
	GreenMask=Vsl->green_mask;
	BlueMask=Vsl->blue_mask;
	SelX=SelY-1;
	IsSearching=false;
	AbortSearching=false;
	NeedPainting=false;
	IsPainting=false;
	HintWanted=false;
	HintValid=false;

	// Create main window
	MainWin=XtVaCreateManagedWidget(
		"mainWin",xmMainWindowWidgetClass,TopLevel,
		(char*)NULL
	);

	// Create main menu bar
	MainMenu=XmCreateMenuBar(MainWin,(char*)"mainMenu",NULL,0);
	XtManageChild(MainMenu);

	// Create menu item: file
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	FileMenu=XmCreatePulldownMenu(MainMenu,(char*)"fileMenu",al,3);
	BFile=XtVaCreateManagedWidget(
		"file",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,FileMenu,
		(char*)NULL
	);

	// Create menu item: file/load
	BFileLoad=XtVaCreateManagedWidget(
		"load",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileLoad,XmNactivateCallback,HandleCallback,this);

	// Create menu item: file/save
	BFileSave=XtVaCreateManagedWidget(
		"save",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileSave,XmNactivateCallback,HandleCallback,this);

	// Create menu item: file/exit
	XtVaCreateManagedWidget(
		"separator",xmSeparatorWidgetClass,FileMenu,
		(char*)NULL
	);
	BFileExit=XtVaCreateManagedWidget(
		"exit",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileExit,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	GameMenu=XmCreatePulldownMenu(MainMenu,(char*)"gameMenu",al,3);
	BGame=XtVaCreateManagedWidget(
		"game",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,GameMenu,
		(char*)NULL
	);

	// Create menu item: game/new
	BGameNew=XtVaCreateManagedWidget(
		"new",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameNew,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/flip
	BGameFlip=XtVaCreateManagedWidget(
		"flip",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameFlip,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/undo
	BGameUndo=XtVaCreateManagedWidget(
		"undo",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameUndo,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/list
	BGameList=XtVaCreateManagedWidget(
		"list",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameList,XmNactivateCallback,HandleCallback,this);

	// Create menu item: computer
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	CompMenu=XmCreatePulldownMenu(MainMenu,(char*)"compMenu",al,3);
	BComp=XtVaCreateManagedWidget(
		"comp",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,CompMenu,
		(char*)NULL
	);

	// Create menu item: computer/hint
	BCompHint=XtVaCreateManagedWidget(
		"hint",xmPushButtonWidgetClass,CompMenu,
		(char*)NULL
	);
	XtAddCallback(BCompHint,XmNactivateCallback,HandleCallback,this);

	// Create menu item: computer/depth
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	XtSetArg(al[3],XmNradioBehavior,True);
	DepthMenu=XmCreatePulldownMenu(CompMenu,(char*)"depthMenu",al,4);
	BCompDepth=XtVaCreateManagedWidget(
		"depth",xmCascadeButtonWidgetClass,CompMenu,
		XmNsubMenuId,DepthMenu,
		(char*)NULL
	);

	// Create menu items: computer/depth/1...
	for (i=0; i<=SilChessMachine::MAX_SEARCH_DEPTH; i++) {
		sprintf(tmp,"%d",i);
		BDepth[i]=XtVaCreateManagedWidget(
			tmp,xmToggleButtonWidgetClass,DepthMenu,
			(char*)NULL
		);
		XtAddCallback(BDepth[i],XmNvalueChangedCallback,HandleCallback,this);
	}

	// Create menu item: help
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	HelpMenu=XmCreatePulldownMenu(MainMenu,(char*)"helpMenu",al,3);
	BHelp=XtVaCreateManagedWidget(
		"help",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,HelpMenu,
		(char*)NULL
	);
	XtVaSetValues(MainMenu,XmNmenuHelpWidget,BHelp,(char*)NULL);

	// Create menu item: help/about
	BHelpAbout=XtVaCreateManagedWidget(
		"about",xmPushButtonWidgetClass,HelpMenu,
		(char*)NULL
	);
	XtAddCallback(BHelpAbout,XmNactivateCallback,HandleCallback,this);

	// Create a parent for status bar and view
	MainForm=XtVaCreateManagedWidget(
		"mainForm",xmFormWidgetClass,MainWin,
		(char*)NULL
	);

	// Create status line
	StatusFrame=XtVaCreateManagedWidget(
		"statusFrame",xmFrameWidgetClass,MainForm,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNtopAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	StatusLabel=XtVaCreateManagedWidget(
		"statusLabel",xmLabelWidgetClass,StatusFrame,
		XmNalignment, XmALIGNMENT_BEGINNING,
		(char*)NULL
	);

	// Create the chess board view
	ViewFrame=XtVaCreateManagedWidget(
		"viewFrame",xmFrameWidgetClass,MainForm,
		XmNtopAttachment,XmATTACH_WIDGET,
		XmNtopWidget,StatusFrame,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	ViewArea=XtVaCreateManagedWidget(
		"viewArea",xmDrawingAreaWidgetClass,ViewFrame,
		XmNtopAttachment,XmATTACH_FORM,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	XtAddCallback(ViewArea,XmNexposeCallback,HandleCallback,this);
	XtAddCallback(ViewArea,XmNresizeCallback,HandleCallback,this);
	XtAddEventHandler(
		ViewArea,ButtonPressMask|ButtonMotionMask|ButtonReleaseMask|
		StructureNotifyMask,False,HandleEvent,this
	);
	XtVaGetValues(ViewArea,XmNwidth,&ViewWidth,(char*)NULL);
	XtVaGetValues(ViewArea,XmNheight,&ViewHeight,(char*)NULL);
	ViewWin=0;
	ViewGC=NULL;

	// Create dialog: load game
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage,True);
	LoadDialog=XmCreateFileSelectionDialog(TopLevel,(char*)"loadDialog",al,4);
	XtAddCallback(LoadDialog,XmNokCallback,HandleCallback,this);
	XtUnmanageChild(XmFileSelectionBoxGetChild(LoadDialog,XmDIALOG_HELP_BUTTON));

	// Create dialog: save game
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	SaveDialog=XmCreateFileSelectionDialog(TopLevel,(char*)"saveDialog",al,4);
	XtAddCallback(SaveDialog,XmNokCallback,HandleCallback,this);
	XtUnmanageChild(XmFileSelectionBoxGetChild(SaveDialog,XmDIALOG_HELP_BUTTON));

	// Create dialog: file exists, overwrite?
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	OverwriteDialog=XmCreateWarningDialog(TopLevel,(char*)"overwriteDialog",al,4);
	XtUnmanageChild(XmMessageBoxGetChild(OverwriteDialog,XmDIALOG_HELP_BUTTON));
	XtAddCallback(OverwriteDialog,XmNokCallback,HandleCallback,this);

	// Create dialog: error message
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	ErrorBox=XmCreateWarningDialog(TopLevel,(char*)"errorBox",al,4);
	XtUnmanageChild(XmMessageBoxGetChild(ErrorBox,XmDIALOG_CANCEL_BUTTON));
	XtUnmanageChild(XmMessageBoxGetChild(ErrorBox,XmDIALOG_HELP_BUTTON));

	// Create dialog: list of moves
	ListDialogPopup=XtVaCreateWidget(
		"listDialog_popup",xmDialogShellWidgetClass,TopLevel,
		XmNvisual,DlgVsl,
		XmNdepth,DlgVslDepth,
		XmNcolormap,DlgCMap,
		(char*)NULL
	);
	ListDialog=XtVaCreateWidget(
		"listDialog",xmFormWidgetClass,ListDialogPopup,
		(char*)NULL
	);
	LDClose=XtVaCreateManagedWidget(
		"close",xmPushButtonWidgetClass,ListDialog,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	XtAddCallback(LDClose,XmNactivateCallback,HandleCallback,this);
	LDScroll=XtVaCreateManagedWidget(
		"scroll",xmScrolledWindowWidgetClass,ListDialog,
		XmNscrollingPolicy,XmAUTOMATIC,
		XmNscrollBarDisplayPolicy,XmAS_NEEDED,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNtopAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_WIDGET,
		XmNbottomWidget,LDClose,
		(char*)NULL
	);
	LDList=XtVaCreateManagedWidget(
		"list",xmLabelGadgetClass,LDScroll,
		XmNalignment,XmALIGNMENT_BEGINNING,
		(char*)NULL
	);

	// Create dialog: about
	xms=XmStringCreateLtoR((char*)AboutText,XmFONTLIST_DEFAULT_TAG);
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage,True);
	XtSetArg(al[4],XmNmessageString,xms);
	XtSetArg(al[5],XmNmessageAlignment,XmALIGNMENT_CENTER);
	AboutDialog=XmCreateMessageDialog(TopLevel,(char*)"aboutDialog",al,6);
	XmStringFree(xms);
	XtUnmanageChild(XmMessageBoxGetChild(AboutDialog,XmDIALOG_CANCEL_BUTTON));
	XtUnmanageChild(XmMessageBoxGetChild(AboutDialog,XmDIALOG_HELP_BUTTON));

	// Set main window areas
	XmMainWindowSetAreas(MainWin,MainMenu,NULL,NULL,NULL,MainForm);

	// Create chess machine
	Machine = new SilChessMachine();

	// Setup ray tracer
	RT.SetViewSize(ViewWidth,ViewHeight);
	RT.SetWorld(Machine);

	// Update all
	UpdateStatusBar();
	UpdateMovesList();
	UpdateView();
	UpdateDepthMenu();
}
Beispiel #21
0
/*
 * MessageBox_popup
 */
void    MessageBox_popup        (Widget         parent,
                                 Widget         *message_box,
                                 int            type,
                                 char           *title,
                                 char           *btn_txt,
                                 char           *format,
                                 ...)
{
  va_list       args;
  XmString      xstr_title;
  XmString      xstr_msg;
  XmString      xstr_btn;
  char          buf[2048];

  /* make string */
  va_start (args, format);
  vsprintf (buf, format, args);
  va_end (args);

  /* initialize widget if necessary */
  if (*message_box != (Widget)0)
    if (parent != XtParent (*message_box))
    {
      XtDestroyWidget (*message_box);
      *message_box = (Widget)0;
    }
  if (*message_box == (Widget)0)
    *message_box = XmCreateMessageDialog (parent, "Oops", NULL, 0);
  
#if 0
  xstr_msg = XmStringCreateLocalized (buf);
#else
  /* Use XmStringGetLtoR because it handles multiple lines */
   xstr_msg = XmStringCreateLtoR(buf, XmFONTLIST_DEFAULT_TAG);
#endif  
  xstr_btn = XmStringCreateLocalized (btn_txt);
  xstr_title = XmStringCreateLocalized (title);

  XtVaSetValues
    (*message_box,
     XmNdialogType,             type,
     XmNdefaultButtonType,      XmDIALOG_OK_BUTTON,
     XmNnoResize,               True,
     XmNdefaultPosition,        False,
     XmNdialogTitle,            xstr_title,
     XmNmessageString,          xstr_msg,
     XmNokLabelString,          xstr_btn,
     NULL);

  XtUnmanageChild
    (XmMessageBoxGetChild (*message_box, XmDIALOG_CANCEL_BUTTON));
  XtUnmanageChild
    (XmMessageBoxGetChild (*message_box, XmDIALOG_HELP_BUTTON));

  XtAddCallback
    (*message_box, XmNokCallback, MessageBox_cb, (XtPointer)MSGBOX_OK);
  XtAddCallback
    (*message_box, XmNmapCallback, MessageBox_cb, (XtPointer)MSGBOX_MAP);

  XmStringFree (xstr_msg);
  XmStringFree (xstr_btn);
  XmStringFree (xstr_title);

  XtManageChild (*message_box);
  XtPopup (XtParent (*message_box), XtGrabNone);
}
Beispiel #22
0
Widget CreateDialog(Widget parent, char *msg, char *deft,
		    char **buttons, int buttcnt, 
		    XtCallbackProc dialogCB,
		    int DialType)
/*- 
  this routine merely creates a dialog, it dosn't manage it, or wait for a
  response. Note: these dialogs are NOT auto-unmanaging.

  parent:  The parent of the dialog.
  msg:     message for the dialog to display.
  deft:    the default return string for prompt dialogs.
  buttons: array of null-terminated button names.
           the first one is the default button.
  buttcnt: the number of elements in buttons.
  dialogCB: a callback that is to be called when any button is pressed.  
            the button number is passed to the routine as client_data.
	    -1 is passed for the to dialogCB if the cancelCallback of the
	    dialog is invoked.
  DialType: one of
	    XmDIALOG_ERROR,
	    XmDIALOG_WARNING,
	    XmDIALOG_MESSAGE,
	    XmDIALOG_QUESTION,
	    XmDIALOG_WORKING.
 -*/
{
  Arg args[10];
  XmString xmstr[5], xmstr2;
  Widget dial, button, w, DefaultButton;
  int i, n;

  /* make the dialog box */
  n = 0;
  XtSetArg(args[n], XmNautoUnmanage, FALSE);  n++;

  dial = XmCreateMessageDialog(parent, "GXDialog", args, n);
  xmstr[0] = XmStringCreateLtoR(msg, XmFONTLIST_DEFAULT_TAG);
  if (deft)
    xmstr[1] = XmStringCreateLtoR(deft, XmFONTLIST_DEFAULT_TAG);
  else
    xmstr[1] = XmStringCreateLtoR("\0", XmFONTLIST_DEFAULT_TAG);
  xmstr[2] = XmStringCreateLtoR("test10", XmFONTLIST_DEFAULT_TAG);
  /* create buttons */
  DefaultButton = NULL;
  for (i = 0; i < buttcnt; i++) {
    n = 0;
    xmstr2 = XmStringCreateLtoR(buttons[i], XmFONTLIST_DEFAULT_TAG);
    XtSetArg(args[n], XmNlabelString, xmstr2);
    n++;
    button = XmCreatePushButton(dial, "button", args, n);
    XtAddCallback(button, XmNactivateCallback,
		  (XtCallbackProc) dialogCB, (XtPointer) i);
    XtManageChild(button);
    if (!DefaultButton)
      DefaultButton = button;
    XmStringFree(xmstr2);
  }
  XtVaSetValues(dial,
		XmNmessageString, xmstr[0],
		XmNdialogType, DialType,
		XmNdialogTitle, xmstr[2],
		XmNdefaultButton, DefaultButton,
		NULL);
    
  if (dialogCB)
    XtAddCallback(dial, XmNcancelCallback, (XtCallbackProc) dialogCB,
		  (XtPointer) - 1);
  /* unmanage default buttons */
  w=XmMessageBoxGetChild(dial, XmDIALOG_OK_BUTTON);
  if (w)
    XtUnmanageChild(w);
  w=XmMessageBoxGetChild(dial, XmDIALOG_HELP_BUTTON);
  if (w)
    XtUnmanageChild(w);
  w=XmMessageBoxGetChild(dial, XmDIALOG_CANCEL_BUTTON);
  if (w) {
    printf("Destroying cancel button %p\n",w);
    XtDestroyWidget(w);
  }
  XtManageChild(dial);

  XmStringFree(xmstr[0]);
  XmStringFree(xmstr[1]);
  XmStringFree(xmstr[2]);

  return (dial);
}