dialogf.c

nedit 是一款linux下的开发源码的功能强大的编辑器

static const char CVSID[] = "$Id: DialogF.c,v 1.27 2003/04/24 11:47:23 edg Exp $";
/*******************************************************************************
*                                                                              *
* DialogF -- modal dialog printf routine                                       *
*                                                                              *
* Copyright (C) 1999 Mark Edel                                                 *
*                                                                              *
* This is free software; you can redistribute it and/or modify it under the    *
* terms of the GNU General Public License as published by the Free Software    *
* Foundation; either version 2 of the License, or (at your option) any later   *
* version.                                                                       *
*                                                                                *
* This software is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License        *
* for more details.                                                               *
*                                                                                *
* You should have received a copy of the GNU General Public License along with *
* software; if not, write to the Free Software Foundation, Inc., 59 Temple     *
* Place, Suite 330, Boston, MA  02111-1307 USA                                       *
*                                                                               *
* Nirvana Text Editor                                                                   *
* April 26, 1991                                                               *
*                                                                               *
* Written by Joy Kyriakopulos                                                       *
*                                                                               *
*******************************************************************************/

#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif

#include "DialogF.h"
#include "misc.h"

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>

#include <Xm/Xm.h>
#include <Xm/MessageB.h>
#include <Xm/DialogS.h>
#include <Xm/PushB.h>
#include <Xm/PushBG.h>
#include <Xm/SelectioB.h>
#include <X11/StringDefs.h>
#include <X11/Intrinsic.h>
#include <X11/keysym.h>

#ifdef HAVE_DEBUG_H
#include "../debug.h"
#endif

#define NUM_DIALOGS_SUPPORTED 6
#define NUM_BUTTONS_SUPPORTED 3		/* except prompt dialog */
#define NUM_BUTTONS_MAXPROMPT 4
#define MAX_TITLE_LEN 256

enum dialogBtnIndecies {OK_BTN, APPLY_BTN, CANCEL_BTN, HELP_BTN};

struct dfcallbackstruct {
    unsigned button;		/* button pressed by user		     */
    Boolean done_with_dialog;	/* set by callbacks; dialog can be destroyed */
    unsigned apply_up;		/* will = 1 when apply button managed	     */
    Boolean destroyed;		/* set when dialog is destroyed unexpectedly */
};

static char **PromptHistory = NULL;
static int NPromptHistoryItems = -1;

static void apply_callback (Widget w, struct dfcallbackstruct *client_data,
	caddr_t call_data);
static void help_callback (Widget w, struct dfcallbackstruct *client_data,
	caddr_t call_data);
static void cancel_callback (Widget w, struct dfcallbackstruct *client_data,
	caddr_t call_data);
static void ok_callback (Widget w, struct dfcallbackstruct *client_data,
	caddr_t call_data);
static void destroy_callback (Widget w, struct dfcallbackstruct *client_data,
	caddr_t call_data);
static void focusCB(Widget w, Widget dialog, caddr_t call_data);
static void addEscapeHandler(Widget dialog, struct dfcallbackstruct *df,
    	int whichBtn);
static void escapeHelpCB(Widget w, XtPointer callData, XEvent *event,
    	Boolean *cont);
static void escapeApplyCB(Widget w, XtPointer callData, XEvent *event,
    	Boolean *cont);
static void createMnemonics(Widget w);

/*******************************************************************************
* DialogF()                                                                    *
*                                                                              *
* function to put up modal versions of the XmCreate<type>Dialog functions      *
* (where <type> is Error, Information, Prompt, Question, Message, or Warning). *
* The purpose of this routine is to allow a printf-style dialog box to be      *
* invoked in-line without giving control back to the main loop. The message    *
* string can contain vsprintf specifications.                                  *
* DialogF displays the dialog in application-modal style, blocking the         *
* application and keeping the modal dialog as the top window until the user    *
* responds. DialogF accepts a variable number of arguments, so the calling     *
* routine needs to #include <stdarg.h>. The first button is automatically      *
* marked as the default button (activated when the user types Return,          *
* surrounded by a special outline), and any button named either Cancel, or     *
* Dismiss is marked as the cancel button (activated by the ESC key). Buttons   *
* marked Dismiss or Cancel are also triggered by close of dialog via the       *
* window close box. If there's no Cancel or Dismiss button, button 1 is        *
* invoked when the close box is pressed.                                       *
*                                                                              *
* Arguments:                                                                   *
*                                                                              *
* unsigned dialog_type  dialog type (e.g. DF_ERR for error dialog, refer to    *
*                       DialogF.h for dialog type values)                      *
* Widget parent         parent widget ID                                       *
* unsigned n            # of buttons to display; if set to 0, use defaults in  *
*                       XmCreate<type>Dialog; value in range 0 to              *
*                       NUM_BUTTONS_SUPPORTED (for prompt dialogs:             *
*                       NUM_BUTTONS_MAXPROMPT)                                 *
* char* title           dialog title                                           *
* char* msgstr          message string (may contain conversion specifications  *
*                       for vsprintf)                                          *
* char* input_string    if dialog type = DF_PROMPT, then: a character string   *
*                       array in which to put the string input by the user. Do *
*                       NOT include an input_string argument for other dialog  *
*                       types.                                                 *
* char* but_lbl         button label(s) for buttons requested (if n > 0, one   *
*                       but_lbl argument per button)                           *
* <anytype> <args>      arguments for vsprintf (if any)                        *
*                                                                              *
*                                                                              *
* Returns:                                                                     *
*                                                                              *
* button selected by user (i.e. 1, 2, or 3. or 4 for prompt)                   *
*                                                                              *
*                                                                              *
* Examples:                                                                    *
*                                                                              *
* but_pressed = DialogF (DF_QUES, toplevel, 3, "Direction?", "up",             *
*              "down", "other");                                               *
* but_pressed = DialogF (DF_ERR, toplevel, 1, "You can't do that!",            *
*              "Acknowledged");                                                *
* but_pressed = DialogF (DF_PROMPT, toplevel, 0, "New %s",                     *
*             new_sub_category, categories[i]);                                *
*/
unsigned DialogF(int dialog_type, Widget parent, unsigned n, const char* title,
        const char* msgstr, ...)                    /* variable # arguments */
{
    va_list var;

    Widget dialog, dialog_shell;
    unsigned dialog_num, prompt;
    XmString but_lbl_xms[NUM_BUTTONS_MAXPROMPT];
    XmString msgstr_xms, input_string_xms, titstr_xms;
    char msgstr_vsp[DF_MAX_MSG_LENGTH+1];
    char *but_lbl, *input_string = NULL, *input_string_ptr;
    int argcount, num_but_lbls = 0, i, but_index, cancel_index = -1;
    Arg args[256];
    char titleCopy[MAX_TITLE_LEN];
    
    struct dfcallbackstruct df;

    static int dialog_types[] = {		/* Supported dialog types */
		XmDIALOG_ERROR,
		XmDIALOG_INFORMATION,
		XmDIALOG_MESSAGE,
		XmDIALOG_QUESTION,
		XmDIALOG_WARNING,
		XmDIALOG_PROMPT
    };
    static char *dialog_name[] = {		/* Corresponding dialog names */
		"Error",
		"Information",
		"Message",
		"Question",
		"Warning",
		"Prompt"
    };
    static char *button_name[] = {		/* Motif button names */
		XmNokLabelString,
		XmNapplyLabelString,		/* button #2, if managed */
		XmNcancelLabelString,
		XmNhelpLabelString
    };
						/* Validate input parameters */
    if ((dialog_type > NUM_DIALOGS_SUPPORTED) || (dialog_type <= 0)) {
	printf ("\nError calling DialogF - Unsupported dialog type\n");
	return (0);
    }
    dialog_num = dialog_type - 1;
    prompt = (dialog_type == DF_PROMPT);
    if  ((!prompt && (n > NUM_BUTTONS_SUPPORTED)) ||
	  (prompt && (n > NUM_BUTTONS_MAXPROMPT))) {
	printf ("\nError calling DialogF - Too many buttons specified\n");
	return (0);
    }

    df.done_with_dialog = False;
    df.destroyed = False;

    va_start (var, msgstr);
    if (prompt) {		      /* Get where to put dialog input string */
	input_string = va_arg(var, char*);
    }
    if (n == NUM_BUTTONS_MAXPROMPT)
	df.apply_up = 1;		/* Apply button will be managed */
    else
    	df.apply_up = 0;		/* Apply button will not be managed */
    for (argcount = 0; argcount < (int)n; ++argcount) {   /* Set up button labels */
	but_lbl = va_arg(var, char *);
	but_lbl_xms[num_but_lbls] = XmStringCreateLtoR (but_lbl, 
		XmSTRING_DEFAULT_CHARSET);
	but_index = df.apply_up ? argcount : 
	    	((argcount == 0) ? argcount : argcount+1);
	XtSetArg (args[argcount], button_name[but_index], 
		but_lbl_xms[num_but_lbls++]);
	if (!strcmp(but_lbl, "Cancel") || !strcmp(but_lbl, "Dismiss"))
	    cancel_index = but_index;
    }

    /* Get & translate msg string. NOTE: the use of vsprintf is inherently
       dangerous because there is no way to control the length of the written
       string. vnsprintf isn't available on all platforms, unfortunately.
       Therefore we have to make sure that msgstr_vsp is large enough such
       that it cannot overflow under any circumstances (within the context
       of any DialogF call). A necessary condition is that it can at least
       hold one file name (MAXPATHLEN). Therefore, DF_MAX_MSG_LENGTH must be
       sufficiently larger than MAXPATHLEN.
    */
    vsprintf (msgstr_vsp, msgstr, var);
    va_end(var);
    
    strncpy(&titleCopy[0], title, MAX_TITLE_LEN);
    titleCopy[MAX_TITLE_LEN-1] = '\0';

    msgstr_xms = XmStringCreateLtoR(msgstr_vsp, XmSTRING_DEFAULT_CHARSET);
    titstr_xms = XmStringCreateLtoR(titleCopy, XmSTRING_DEFAULT_CHARSET);

    if (prompt) {				/* Prompt dialog */
	XtSetArg (args[argcount], XmNselectionLabelString, msgstr_xms);
		argcount++;
	XtSetArg (args[argcount], XmNdialogTitle, titstr_xms);
		argcount++;
	XtSetArg (args[argcount], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL);
		argcount ++;

	dialog = CreatePromptDialog(parent, dialog_name[dialog_num], args,
			argcount);
	XtAddCallback (dialog, XmNokCallback, (XtCallbackProc)ok_callback,
		(char *)&df);
	XtAddCallback (dialog, XmNcancelCallback,
		(XtCallbackProc)cancel_callback, (char *)&df);
	XtAddCallback (dialog, XmNhelpCallback, (XtCallbackProc)help_callback,
		(char *)&df);
	XtAddCallback (dialog, XmNapplyCallback, (XtCallbackProc)apply_callback,
		(char *)&df);
	RemapDeleteKey(XmSelectionBoxGetChild(dialog, XmDIALOG_TEXT));

	/* Text area in prompt dialog should get focus, not ok button
	   since user enters text first.  To fix this, we need to turn
	   off the default button for the dialog, until after keyboard
	   focus has been established */
	XtVaSetValues(dialog, XmNdefaultButton, NULL, NULL);
    	XtAddCallback(XmSelectionBoxGetChild(dialog, XmDIALOG_TEXT),
    		XmNfocusCallback, (XtCallbackProc)focusCB, (char *)dialog);

	/* Limit the length of the text that can be entered in text field */
	XtVaSetValues(XmSelectionBoxGetChild(dialog, XmDIALOG_TEXT),
		XmNmaxLength, DF_MAX_PROMPT_LENGTH-1, NULL);
	
	/* Turn on the requested number of buttons in the dialog by
	   managing/unmanaging the button widgets */
	switch (n) {		/* number of buttons requested */
	case 0: case 3:
	    break;		/* or default of 3 buttons */
	case 1:
	    XtUnmanageChild (XmSelectionBoxGetChild (dialog,
		XmDIALOG_CANCEL_BUTTON) );
	case 2:
	    XtUnmanageChild (XmSelectionBoxGetChild (dialog,
		XmDIALOG_HELP_BUTTON) );
	    break;
	case 4:
	    XtManageChild (XmSelectionBoxGetChild (dialog,
		XmDIALOG_APPLY_BUTTON) );
	    df.apply_up = 1;		/* apply button managed */
	default:
	    break;
	}				/* end switch */

    	/* If the button labeled cancel or dismiss is not the cancel button, or
    	   if there is no button labeled cancel or dismiss, redirect escape key
    	   events (this is necessary because the XmNcancelButton resource in
    	   the bulletin board widget class is blocked from being reset) */
    	if (cancel_index == -1)
    	    addEscapeHandler(dialog, NULL, 0);
    	else if (cancel_index != CANCEL_BTN)
    	    addEscapeHandler(dialog, &df, cancel_index);

    	/* Add a callback to the window manager close callback for the dialog */
    	AddMotifCloseCallback(XtParent(dialog),
    	    	(XtCallbackProc)(cancel_index == APPLY_BTN ? apply_callback :
    	    	(cancel_index == CANCEL_BTN ? cancel_callback :
    	    	(cancel_index == HELP_BTN ? help_callback : ok_callback))), &df);