Esempio n. 1
0
void wxChoice::Clear()
{
    m_stringList.Clear ();
    size_t i;
    for (i = 0; i < m_noStrings; i++)
    {
        XtRemoveCallback((Widget) m_widgetArray[i],
                         XmNactivateCallback, (XtCallbackProc)wxChoiceCallback,
                         (XtPointer)this);
        XtUnmanageChild ((Widget) m_widgetArray[i]);
        XtDestroyWidget ((Widget) m_widgetArray[i]);
    }
    m_widgetArray.Clear();
    if (m_buttonWidget)
        XtVaSetValues ((Widget) m_buttonWidget,
                       XmNmenuHistory, (Widget) NULL,
                       NULL);

    if ( HasClientObjectData() )
        m_clientDataDict.DestroyData();

    m_noStrings = 0;
}
Esempio n. 2
0
char *UISelection (Widget widget,char *items,int itemSize,int itemNum)

	{
	int i;
	XmString *strings;

	if ((strings = (XmString *) calloc	(itemNum,sizeof (XmString))) == NULL)
		{
		CMmsgPrint (CMmsgSysError, "Memory Allocation Error in: %s %d",__FILE__,__LINE__);
		return (NULL);
		}
	for (i = 0;i < itemNum;++i) strings [i] = XmStringCreate (items + i * itemSize,UICharSetNormal);
	_UISelection = NULL;
	XtVaSetValues (widget,XmNlistItems, strings,XmNlistItemCount, itemNum,NULL);
	XtManageChild (widget);

	while (UILoop ());
	XtUnmanageChild (widget);

	for (i = 0;i < itemNum;++i) XmStringFree (strings [i]);
	free (strings);
	return (_UISelection);
	}
Esempio n. 3
0
static XmxCallback (history_win_cb)
{
  mo_window *win = mo_fetch_window_by_id (XmxExtractUniqid ((int)client_data));

  switch (XmxExtractToken ((int)client_data))
    {
    case 0:
      XtUnmanageChild (win->history_win);
      /* Dismissed -- do nothing. */
      break;
    case 1:
      mo_post_mailhist_win (win);
      break;
    case 2:
      mo_open_another_window
        (win, 
         mo_assemble_help_url ("docview-menubar-navigate.html#history"),
         NULL, NULL);
      break;
    }

  return;
}
Esempio n. 4
0
static void do_netcdffile_proc(Widget, XtPointer, XtPointer)
{
    Widget dialog = (Widget)client_data;
    Arg args;
    XmString list_item;
    char *s;
    char fname[256];

    set_wait_cursor();

    XtSetArg(args, XmNtextString, &list_item);
    XtGetValues(dialog, &args, 1);
    XmStringGetLtoR(list_item, charset, &s);

    xv_setstr(netcdf_file_item, s);

    XtFree(s);

    unset_wait_cursor();

    XtUnmanageChild(dialog);
    update_netcdfs();
}
Esempio n. 5
0
Widget UIFileSelectionCreate (char *titleText,char *directory,char *pattern,int type)

	{
	static char fullPath [DBDataFileNameLen];
	XmString string;
	Widget dShell, selection;

	dShell = XtVaCreatePopupShell (titleText,xmDialogShellWidgetClass,UITopLevel (),
							XmNallowShellResize,			true,
							XmNtransient,					true,
							XmNkeyboardFocusPolicy,		XmEXPLICIT,
							NULL);
	selection = XtVaCreateWidget ("UIFileSelectionDialog",xmFileSelectionBoxWidgetClass,dShell,
							XmNfileTypeMask,				type,
							XmNdialogStyle,				XmDIALOG_FULL_APPLICATION_MODAL,
							NULL);
	if (directory != NULL)
		{
		string = XmStringCreate (directory,UICharSetNormal);
		XtVaSetValues (selection,XmNdirectory,string,NULL);
		XmStringFree (string);
		}
	if (pattern   != NULL)
		{
		string = XmStringCreate (pattern,UICharSetNormal);
		XtVaSetValues (selection,XmNpattern,   string,NULL);
		XmStringFree (string);
		}

	XtUnmanageChild (XmFileSelectionBoxGetChild (selection,XmDIALOG_HELP_BUTTON));
	XtAddCallback (selection,XmNokCallback,(XtCallbackProc) _UIFileSelectionOkCBK,fullPath);
	XtAddCallback (selection,XmNokCallback,(XtCallbackProc) 	UILoopStopCBK,NULL);
	XtAddCallback (selection,XmNcancelCallback,(XtCallbackProc) UILoopStopCBK,NULL);
	XtAddCallback (selection,XmNnoMatchCallback,(XtCallbackProc) _UIFileSelectionNoMatchCBK,NULL);

	return (selection);
	}
Esempio n. 6
0
void wxListBox::DoSetItems(const wxArrayString& items, void** clientData)
{
    wxSizeKeeper sk( this );
    Widget listBox = (Widget) m_mainWidget;

    if( HasClientObjectData() )
        m_clientDataDict.DestroyData();

    bool managed = XtIsManaged(listBox);

    if (managed)
        XtUnmanageChild (listBox);
    XmString *text = new XmString[items.GetCount()];
    size_t i;
    for (i = 0; i < items.GetCount(); ++i)
        text[i] = wxStringToXmString (items[i]);

    if ( clientData )
        for (i = 0; i < items.GetCount(); ++i)
            m_clientDataDict.Set(i, (wxClientData*)clientData[i], false);

    XmListAddItems (listBox, text, items.GetCount(), 0);
    for (i = 0; i < items.GetCount(); i++)
        XmStringFree (text[i]);
    delete[] text;

    // It seems that if the list is cleared, we must re-ask for
    // selection policy!!
    SetSelectionPolicy();

    if (managed)
        XtManageChild (listBox);

    sk.Restore();

    m_noItems = items.GetCount();
}
Esempio n. 7
0
static void DialogButtonPrecallback(Widget FileDialog,
                                    void (*Callback)(char *),
                                    XmFileSelectionBoxCallbackStruct *CbS) {

    /* Retrieve file name. */

    char *FileName;
    XmStringGetLtoR(CbS->value,XmSTRING_DEFAULT_CHARSET,&FileName);

    /* No file has been selected. */

    if (!(*FileName))
        return;

    /* In case the user has not specified the directory, we must supply it. */

    char *FileSpec;
    if ((*FileName)!='/') {
        char *Path;
        if (!XmStringGetLtoR(CbS->dir,XmSTRING_DEFAULT_CHARSET,&Path))
            return;
        FileSpec=XtMalloc(strlen(Path)+1+strlen(FileName)+1);
        sprintf(FileSpec,"%s/%s",Path,FileName);
        XtFree(Path);
        XtFree(FileName);
    } else
        FileSpec=FileName;

    /* Invoke user callback. */

    (*Callback)(FileSpec);

    /* Cleanup. */

    XtFree(FileSpec);
    XtUnmanageChild(FileDialog);
}
Esempio n. 8
0
/* ARGSUSED */
void LocalProduct_Callback ( Widget w, long which, 
				XmFileSelectionBoxCallbackStruct *call )
{
Widget list;
int    itemc;
/*---------------------------------------------------------------------*/
	switch( which ) {

	    case 0: /* ok callback (select) */
		OpenModel = 1;
		Select_File_Callback( local_toplevel,
			NULL, call);
		XtManageChild( group_select_toplevel );
		break;

	    case 1: /* cancel callback (close)  */
		XtUnmanageChild( local_toplevel );
		break;

	    case 2: /* apply callback ( update model ) */
		list = XmFileSelectionBoxGetChild(
			local_toplevel,
				XmDIALOG_LIST);
		XtVaGetValues(list, 
		    XmNitemCount, &itemc,
		    NULL); 
		XmListDeselectAllItems(list);
		XmFileSelectionDoSearch( local_toplevel,
			call->mask);
		XmListSetHorizPos(list, call->dir_length);
		XtVaSetValues(list, 
		    XmNitemCount, itemc,
		    NULL); 
		break;
	}
}
Esempio n. 9
0
/*
 * file->save->ok
 */
static void
file_save_ok(Widget w, XtPointer closure, XtPointer call)
{
	XmFSS	*cbs = (XmFSS *)call;
	MGV	*m   = (MGV *)closure;
	char	*buf = NULL;
	USEUP(w);
	assert(MgvOK(m));

	if(m->save_query != NULL)
		XtUnmanageChild(m->save_query);
	XtFree((XtPointer)m->savefile);
	m->savefile = NULL;
	if(!XmStringGetLtoR(cbs->value, XmFONTLIST_DEFAULT_TAG, &m->savefile))
		return;
	if(access(m->savefile, F_OK) != 0) {
		file_save_write(w, (XtPointer)m, NULL);
		return;
	}

	if(m->save_query == NULL) {
		m->save_query = wl_create(m->fs_save, save_query);
		wl_callback(XtParent(m->save_query), &save_query_cb[0],
								(XtPointer)m);
	}

	buf = XtMalloc(strlen(m->savefile) + 128);
	sprintf(buf, "%s\n%s", m->savefile, mgv_s(w, MgvSfileExists));
	XtVaSetValues(m->save_query,
		XtVaTypedArg,	XmNmessageString,
				XmRString, buf,
				strlen(buf) + 1,
		NULL);
	XtFree(buf);
	wl_dlg_popup(m->save_query);
}
Esempio n. 10
0
/*
 * Process callback from Dialog cancel actions.
 */
static void
cancel_callback(Widget w,
                XtPointer client_data,
                XtPointer call_data)
{
    struct filesel_callback *callback = (struct filesel_callback *)client_data;

    UNUSED(w);
    UNUSED(call_data);
#if 0
    /* DON'T reset browse_fname, so that user gets the current
       value as default next time when he cancels now */
    if (callback->browse_fname != NULL)
    {
        XtFree(callback->browse_fname);
        callback->browse_fname = NULL;
    }
#endif

    XtUnmanageChild(callback->shell);
    if (callback->exit_on_cancel) {
        exit(0);
    }
}
Esempio n. 11
0
static void enableSample(xfselControlBlkType *ctrlBlk, Bool turn_on, 
        XmFontList *fontList)
{
    int n=0;
    Arg args[4];

    XtSetArg(args[n], XmNeditable, turn_on); n++;
    XtSetArg(args[n], XmNcursorPositionVisible, turn_on); n++;
    if( turn_on ) {
        if( !fontList ) {
            fprintf(stderr, "nedit: Internal error in fontsel.c, line %i\n", \
                    __LINE__);
        } else {
            XtSetArg(args[n], XmNfontList, *fontList); n++;
        }
        XtSetArg(args[n], XmNforeground, ctrlBlk->sampleFG); n++;
    } else {
        XtSetArg(args[n], XmNforeground, ctrlBlk->sampleBG); n++;
    }
    XtSetValues(ctrlBlk->dispField, args, n);
    /* Make sure the sample area gets resized if the font size changes */
    XtUnmanageChild(ctrlBlk->dispField);
    XtManageChild(ctrlBlk->dispField);
}
Esempio n. 12
0
void mpcstw_popdown ( void )
/************************************************************************
 * mpcstw_popdown							*
 *									*
 * This function pops down the data selection popup window.		*
 *									*
 * void mpcstw_popdown()						*
 *									*
 * Input parameters:							*
 * Output parameters:							*
 * Return parameters:							*
 *			NONE						*
 *									*
 **									*
 * Log: 								*
 * C. Lin/EAI		04/96						*
 * S. Wang/GSC		09/96	 add clean up before exit		*
 ***********************************************************************/
{
int	i;
/*---------------------------------------------------------------------*/

/*
 * unset all buttons
 */
	XmToggleButtonSetState(_defaultBt, FALSE, FALSE);
	mpcstw_resetDefCon();
	for ( i =1; i<NAMEPROJSHOW; i++ )
	    XmToggleButtonSetState( _toggleBt[i], FALSE, FALSE );
	XmToggleButtonSetState(_othersBt, FALSE, FALSE);

	if ( strcmp( _projCopy, "SAT" ) == 0 )
		mpcstw_projBtSnstv(True);

	XtUnmanageChild(_mapCustomW);
}
Esempio n. 13
0
/* ARGSUSED */
void CtrB_Callback ( Widget w, long which, XtPointer call )
/************************************************************************
 *
 *	Callback function of control buttons for group creation panel.
 *
 *		ctrB_Callback ( w, which, call )
 *
 ***********************************************************************/
{
int		status = 0;

/*---------------------------------------------------------------------*/

	switch (which) {

	case	0:	/* HELP */
		NxmHelp_helpBtnCb( NULL, 7, NULL );
		status = 0;
		break;

	case	1:	/* CANCEL */
		status = 1;
		break;

	default:
		status = 1;
		break;
	}

	if (status) {
		XmListDeselectAllItems(gframe_listW);
		XmTextSetString(group_nameW, "");
		XtUnmanageChild(group_panel_toplevel);
	}

}
Esempio n. 14
0
void wxRadioBox::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
    bool managed = XtIsManaged((Widget) m_mainWidget);

    if (managed)
        XtUnmanageChild ((Widget) m_mainWidget);

    int xx = x;
    int yy = y;
    AdjustForParentClientOrigin(xx, yy, sizeFlags);

    if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
        XtVaSetValues ((Widget) m_mainWidget, XmNx, xx, NULL);
    if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
        XtVaSetValues ((Widget) m_mainWidget, XmNy, yy, NULL);

    if (width > 0)
        XtVaSetValues ((Widget) m_mainWidget, XmNwidth, width, NULL);
    if (height > 0)
        XtVaSetValues ((Widget) m_mainWidget, XmNheight, height, NULL);

    if (managed)
        XtManageChild ((Widget) m_mainWidget);
}
Esempio n. 15
0
void get_textfile(Widget w, XtPointer client_data, XtPointer call_data)
{
    int   i;
    char *file=NULL;
    XmFileSelectionBoxCallbackStruct *cbs =
        (XmFileSelectionBoxCallbackStruct *)call_data;

    /* Retrieve the string */
    if (!XmStringGetLtoR(cbs->value, XmFONTLIST_DEFAULT_TAG, &file)) {
        errordialog(w, "No file specified!");
        return;
    }

    /* Pop down the dialog box */
    XtPopdown(XtParent(w));
    XtUnmanageChild(savetextdialog);
    savetextdialog = NULL;
    XtFree(savetextdialog);

    /*
     * Make sure we have a sane filename and not just a directory path
     */
    if (file[strlen(file)-1] == '/') {
        errordialog(w, "No file specified!");
    }
    else {
        /* i = save_text(file); */
        write_file2(file);
        if (i == 1) {
            errordialog(w, "Unable to properly write text file.");
        }
    }

    /* Need to free file */
    XtFree(file);
}
Esempio n. 16
0
void create_merge_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(MERGE_MESSAGE, XmSTRING_DEFAULT_CHARSET);
    argcount = 0;
    XtSetArg(args[argcount], XmNselectionLabelString, message); argcount++;
    merge_dialog = XmCreatePromptDialog(temp_widget, "merge dialog",
				args, argcount);
    /* Remove the help button from the dialog */
    temp_widget = XmSelectionBoxGetChild(merge_dialog, XmDIALOG_HELP_BUTTON);
    XtUnmanageChild(temp_widget);
    /* Add the actions to the buttons */
    XtAddCallback(merge_dialog, XmNokCallback,
		(XtCallbackProc) start_merge, (XtPointer) NULL);
    XtAddCallback(merge_dialog, XmNokCallback,
		(XtCallbackProc) activate_merge_dialog, (XtPointer) NULL);
    XmStringFree(message);
}
Esempio n. 17
0
void
includeFileCB( Widget w, XtPointer client_data, 
 		XtPointer call_data)
{
	char *file_data, *c_path;
	Widget widget;
	XmFileSelectionBoxCallbackStruct *res;
	XmTextPosition pos;
	
	res = (XmFileSelectionBoxCallbackStruct *) call_data; 
	c_path = XmStringUnparse(res->value, 
	    NULL, XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL); 
	file_data = get_file_contents(w, "fileOpenCB", c_path);
	widget = get_document_text(w, "fileOpenCB");
	pos = XmTextGetInsertionPosition(widget);
	XmTextInsert(widget, pos, file_data);
	
	update_document_linecount(w, "includeFileCB");
	update_message(w, "fileOpenCB", "Included file.");
	
	XtFree(c_path);
	XtFree(file_data);
	XtUnmanageChild(w);
}
Esempio n. 18
0
XtCallbackProc xGRgetfilename(
Widget w,
XtPointer Input,
XtPointer Output
)

{
	extern GRAGLOB graglob;
	extern XtPointer adrptr;
	extern XtCallbackProc (*funcquestion)();
	XmFileSelectionBoxCallbackStruct *call_data;


	if (Input) {
		call_data = (XmFileSelectionBoxCallbackStruct *)Output;
		if (graglob.fileselected) {
			XtFree((void *)graglob.fileselected);
		}
		XmStringGetLtoR(call_data->value, XmSTRING_DEFAULT_CHARSET,
		&graglob.fileselected);
		(*funcquestion)(w, adrptr, 0);
	}
	XtUnmanageChild(w);
}
Esempio n. 19
0
// OK pressed in `Open Core'
static void openCoreDone(Widget w, XtPointer client_data, XtPointer call_data)
{
    string corefile = get_file(w, client_data, call_data);
    if (corefile.empty())
	return;

    ProgramInfo info;

    XtUnmanageChild(w);

    if (corefile != NO_GDB_ANSWER)
    {
	switch(gdb->type())
	{
	case GDB:
	    gdb_command("core-file " + gdb->quote_file(corefile));
	    break;

	case DBX:
	    if (info.file != NO_GDB_ANSWER && !info.file.empty())
		gdb_command(gdb->debug_command(info.file) + " " + 
			    gdb->quote_file(info.core));
	    else
		post_error("No program.", "no_program", w);
	    break;

	case BASH:
	case DBG:
	case JDB:
	case PERL:
	case PYDB:
	case XDB:
	    break;		// FIXME
	}
    }
}
Esempio n. 20
0
File: CWnd.C Progetto: dhaley/dcp
BOOL CWnd::xd_show_window(int nCmdShow)
{
    // Changes the visibility state of a child widget
    // by mapping or unmapping it or a child gadget by
    // managing or unmanaging it.

    Boolean wasvisible = TRUE;
    Boolean gadget     = XmIsGadget(_xd_rootwidget);

    if (gadget)
	wasvisible = XtIsManaged(_xd_rootwidget);
    else
	XtVaGetValues(_xd_rootwidget, XmNmappedWhenManaged, &wasvisible, NULL);

    switch(nCmdShow)
    {
	case SW_HIDE:       if (gadget)
				XtUnmanageChild(_xd_rootwidget);
			    else
				XtSetMappedWhenManaged(_xd_rootwidget, FALSE);
			    break;

	case SW_RESTORE:    if (gadget)
				XtManageChild(_xd_rootwidget);
			    else
				XtSetMappedWhenManaged(_xd_rootwidget, TRUE);
			    break;

        case SW_SHOW:            XtManageChild(_xd_rootwidget);
                            break;

	default:            cerr << "CWnd::ShowWindow: Only SW_HIDE and SW_RESTORE supported for child windows" << endl;
    }

    return wasvisible;
}
Esempio n. 21
0
// 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);
}
Esempio n. 22
0
// 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);
}
Esempio n. 23
0
void NxmUndisplayCbColorcell ( int index )
/************************************************************************
 * NxmUndisplayCbColorcell                                              *
 *                                                                      *
 * This function make the selected color cell not shown in color bar.   *
 *                                                                      *
 * void NxmUndisplayCbColorcell( index )                                *
 *                                                                      *
 * Input parameters:                                                    *
 *  index            int   index of the selected color                  *
 *                                                                      *
 * Output parameters:                                                   *
 *                      NULL                                            *
 *                                                                      *
 * Return parameters:                                                   *
 *                      NULL                                            *
 *                                                                      *
 **                                                                     *
 * Log:                                                                 *
 * C. Lin/EAI       05/94                                               *
 ***********************************************************************/
{
    XtUnmanageChild(NXMcolrCells[index]);
}
Esempio n. 24
0
void close_packages_windows()
{
  if (product_packages_main_form && XtIsManaged (product_packages_main_form))
  {
    XtUnmanageChild(product_packages_main_form);
    XtPopdown(product_packages_shell);
  }
  if (pp_secondary_form && XtIsManaged (pp_secondary_form))
  {
    XtUnmanageChild(pp_secondary_form);
    XtPopdown(pp_secondary_shell);
  }
  if (pp_provision_form && XtIsManaged (pp_provision_form))
  {
    XtUnmanageChild(pp_provision_form);
    XtPopdown(pp_provision_shell);
  }
  if (emfp_shell_up)
  {
    XtUnmanageChild(emfp_main_form);
    XtPopdown(emf_products_shell);
    emfp_shell_up = FALSE;
  }
  if (emfpm_shell_up)
  {
    XtUnmanageChild(emfp_modify_form);
    XtPopdown(emfp_modify_shell);
    emfpm_shell_up = FALSE;
  }
  if (emfx_shell_up)
  {
    XtUnmanageChild(emf_iddetail_form);
    XtPopdown(emf_iddetail_shell);
    emfx_shell_up = FALSE;
  }

}
void XmdsUnmanageChildCallback(Widget w1,Widget *w2)
{
  XtUnmanageChild(*w2);
}
void ControlPanelAccessDialog::makeToggles()
{
     int i, inst;
     Boolean set;
     Widget widget, lastwidget = NULL; // NULL stops scary cc warnings 
     ControlPanel *cp;
     Network      *network = this->panelManager->getNetwork();
     PanelGroupManager * pgm = network->getPanelGroupManager();
     char   *gname, *pname;

     XtUnmanageChild(this->sform);

     ListIterator  li(this->toggleList[0]);
     int size = network->getPanelCount();

     if(this->toggleList[0].getSize() > 0)
     {
        while( (widget = (Widget)li.getNext()) )
             XtDestroyWidget(widget);

	li.setList(this->toggleList[1]);
        while( (widget = (Widget)li.getNext()) )
             XtDestroyWidget(widget);

        this->toggleList[0].clear();
        this->toggleList[1].clear();
     }

     if(this->separator)
     {
	XtDestroyWidget(this->separator);
	this->separator = NULL;
     }

     if(this->toggleList[2].getSize() > 0)
     {
	li.setList(this->toggleList[2]);
        while( (widget = (Widget)li.getNext()) )
             XtDestroyWidget(widget);

        this->toggleList[2].clear();
     }

     if(size == 0)
        return;

     for(i = 0; i < size; i++)
     {
        cp = network->getPanelByIndex(i+1);
	inst = cp->getInstanceNumber();
	set  = this->panelManager->isAccessiblePanel(inst);

        pname = (char*)cp->getPanelNameString();
        if(IsBlankString(pname))
            pname = "Control Panel";

        widget = XmCreateToggleButton(this->sform,
                                     pname, 
                                     NULL,
                                     0);
        XtVaSetValues(widget,
		      XmNset,		 set,
		      XmNindicatorType,	 XmN_OF_MANY,
		      XmNalignment,	 XmALIGNMENT_BEGINNING,
		      XmNshadowThickness,0,
		      XmNleftAttachment, XmATTACH_FORM,
		      XmNrightAttachment,XmATTACH_POSITION,
		      XmNrightPosition,  80,
		      XmNtopOffset,      2,
		      XmNleftOffset,     2,
                      NULL);
	if(i == 0)
            XtVaSetValues(widget, XmNtopAttachment,XmATTACH_FORM,NULL);
	else
            XtVaSetValues(widget,
		          XmNtopAttachment,XmATTACH_WIDGET,
		          XmNtopWidget,    lastwidget,
                          NULL);

	if(this->panelManager->getControlPanel() == cp)
            XtVaSetValues(widget, 
			  XmNsensitive, False,
			  XmNset,	False, 
			  NULL);

        this->toggleList[0].appendElement((void*)widget);
        XtManageChild(widget);

	set = cp->isManaged();
        widget = XmCreateToggleButton(this->sform,
                                     "...",
                                     NULL,
                                     0);
        XtVaSetValues(widget,
		      XmNuserData,      cp,
		      XmNset,		set,
		      XmNindicatorOn,	False,
    		      XmNfillOnSelect,  False,
		      XmNrightAttachment,XmATTACH_FORM,
		      XmNleftAttachment,XmATTACH_POSITION,
		      XmNleftPosition,  80,
		      XmNtopOffset,     2,
		      XmNleftOffset,    5,
		      XmNindicatorSize, 1,
		      XmNspacing,	0,
                      NULL);
	if(i == 0)
            XtVaSetValues(widget, XmNtopAttachment,XmATTACH_FORM,NULL);
	else
            XtVaSetValues(widget,
		          XmNtopAttachment,XmATTACH_WIDGET,
		          XmNtopWidget,    lastwidget,
                          NULL);

	if(this->panelManager->getControlPanel() == cp)
            XtVaSetValues(widget, XmNsensitive, False, NULL);

        XtAddCallback(widget,
                      XmNvalueChangedCallback,
                      (XtCallbackProc)ControlPanelAccessDialog_OpenPanelCB,
                      (XtPointer)this);

        this->toggleList[1].appendElement((void*)widget);
        XtManageChild(widget);

	lastwidget = widget;
     }

    size = pgm->getGroupCount();

    if(size == 0)
    {
     	XtManageChild(this->sform);
	return;
    }

    this->separator = XtVaCreateManagedWidget("separator",
	xmSeparatorGadgetClass, this->sform,
        XmNleftAttachment,    XmATTACH_FORM,
        XmNleftOffset,        2,
        XmNrightAttachment,   XmATTACH_FORM,
        XmNrightOffset,       2,
        XmNtopAttachment,     XmATTACH_WIDGET,
        XmNtopWidget,         lastwidget,
        XmNtopOffset,         5,
        NULL);
   
     for(i = 1; i <= size; i++)
     {
	gname = (char*)pgm->getPanelGroup(i, NULL);
	set  = this->panelManager->isAccessibleGroup(gname);

        widget = XmCreateToggleButton(this->sform, gname, NULL, 0);
        XtVaSetValues(widget,
                      XmNset,            set,
                      XmNindicatorType,  XmN_OF_MANY,
                      XmNalignment,      XmALIGNMENT_BEGINNING,
                      XmNshadowThickness,0,
                      XmNleftAttachment, XmATTACH_FORM,
                      XmNtopAttachment,  XmATTACH_WIDGET,
                      XmNtopOffset,      2,
                      XmNleftOffset,     2,
                      NULL);
        if(i == 1)
            XtVaSetValues(widget, 
			  XmNtopWidget,    this->separator,
                          XmNtopOffset,    5,
			  NULL);
        else
            XtVaSetValues(widget,
                          XmNtopWidget,    lastwidget,
                          NULL);

        this->toggleList[2].appendElement((void*)widget);
        XtManageChild(widget);

	lastwidget = widget;
    }

     XtManageChild(this->sform);
}
Esempio n. 27
0
//
// Create a new foe window
// SG 09.02.91 : Create a new toplevel widget and give it an pixmap icon
// SG : 13.02.91 Fetch a caution box and save the id of the widget in the 
//               foe context for futher use
// SG : 24.02.91 Fetch a widget ( again !) . This time a message box
// SG : 24.03.91 Send the routine the desired position (x_top , y_top) 
// and the desired size ( width_adb , height_adb ) for the window to be created.
// The two first parameters are set to the top level widget
// and the two last paramters are set to the adb widget (see in uil file
// the widget hierarchy )
// SG 14.04.91 A new widget to fetch , the help widget ! 
// SG 2.05.91 New parameter : function ( edit , trace , view , simulate ..)
// to indicate which neted events and which menu entries should be alllowed.
//
pwr_tStatus WFoeMotif::create_window( int x_top,
				 int y_top,
				 int width_adb,
				 int height_adb, 
				 ldh_tSesContext ldhsession,
				 foe_eFuncAccess function_access)
{
  Arg	args[20];
  int	sts;
  Widget *children;
  int i, num_children;
  XmString   	TitleStr;
  Dimension icon_w, icon_h;

  /* DRM database hierarchy related variables */
  MrmHierarchy s_MrmH;
  MrmType dclass;
  char		uid_filename[200] = {"pwr_exe:wb_foe.uid"};
  char		*uid_filename_p = uid_filename;
  static Atom	MwmDeleteWind = 0;
  static char translations[] = "\
<FocusIn>: foe_inputfocus()\n";
  static XtTranslations compiled_translations = NULL;

  static XtActionsRec actions[] =
    {
      {(char*) "foe_inputfocus",      (XtActionProc) action_inputfocus}
    };
       
  sts = dcli_translate_filename( uid_filename, uid_filename);
  if ( EVEN(sts)) {
    printf( "** pwr_exe is not defined\n");
    exit(0);
  }

  /*
   * Now start the module creation
   */

  /* Save the context structure in the widget */
  XtSetArg (args[0], XmNuserData, (XtPointer) this);

  /*
   * Create a new main widget
   */
  /*
   * Open the UID files (the output of the UIL compiler) in the hierarchy
   * Register the items DRM needs to bind for us.
   * Create a new neted-widget
   * Close the hierarchy
   * Compile the additional button translations and augment and add actions
   */ 
  sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_MrmH);
  if (sts != MrmSUCCESS) {
    printf("can't open hierarchy\n");
    return 0;
  }

  register_callbacks();

  /* SG 09.02.91 : create the new hierarchy. By the way use a pixmap define
  with help of wb_foe_ptrn.h */

  /* create a pixmap for the icon */
  if ( icon_pixmap == 0 )
    sts = MrmFetchBitmapLiteral(s_MrmH,(char*) "icon",
				XtScreen(parent_wid), XtDisplay(parent_wid),
				&icon_pixmap, &icon_w, &icon_h);  
 
  i=0;
  XtSetArg(args[i],XmNiconName,name);  i++;
  XtSetArg(args[i],XtNiconPixmap,icon_pixmap);  i++;
  
  /* SG 11.02.91 Save the id of the top in the context */ 
  parent_wid = XtCreatePopupShell("plcEditor", 
		     topLevelShellWidgetClass, parent_wid, args, i);

  if (compiled_translations == NULL) 
    XtAppAddActions( XtWidgetToApplicationContext( parent_wid), 
						actions, XtNumber(actions));

  /* the positioning of a top level can only be define after the creation
      of the widget . So i do it know: 
     SG 24.02.91 use the parameters received x and y 
  */

  i=0;
  XtSetArg(args[i],XmNx,x_top);i++;
  XtSetArg(args[i],XmNy,y_top);i++;
  XtSetArg(args[i],XtNallowShellResize,TRUE), i++;

  if ( ! map_window) {
    XtSetArg(args[i],XmNmappedWhenManaged,FALSE); i++;
  }

  XtSetValues( parent_wid, args, i);

  XtSetArg (args[0], XmNuserData, (XtPointer) this);

  /* now that we have a top level we can get the main window */
  sts = MrmFetchWidgetOverride(s_MrmH, (char*) "foe_window", parent_wid ,
		name, args, 1,
		&widgets.foe_window, &dclass);
  if (sts != MrmSUCCESS) printf("can't fetch foedit widget\n");

  /* SG 24.02.91 Set the width and hight desired for the main window to his
	child the adb widget */
  i=0;
  XtSetArg(args[i],XmNwidth,width_adb);i++;
  XtSetArg(args[i],XmNheight,height_adb);i++;
  XtSetValues( widgets.adb  ,args,i);

  /* SG 24.02.91
     Get a litle message box widget that you will make appears when you want by
     calling foe_msgbox
  */

  if (MrmFetchWidget (s_MrmH, 
			(char*) "foe_msgbox", 
			widgets.foe_window,
			&widgets.msgbox,
			&dclass) != MrmSUCCESS)
	printf("can't fetch msgbox \n");

  TitleStr = XmStringCreateLtoR((char*) "PlcEdit Message" , (char*) "ISO8859-1");    
  XtSetArg(args[0],XmNdialogTitle,TitleStr);
  XtSetValues( widgets.msgbox, args, 1);
  XmStringFree(TitleStr);


  /* SG 13.02.91 
     Get a litle caution widget that you will make appears when you want by
     calling foe_popupmsg 
  */

  if (MrmFetchWidget (s_MrmH, 
			(char*) "foe_popupmsg", 
			widgets.foe_window,
			&widgets.caution,
			&dclass) != MrmSUCCESS)
    printf("can't fetch popupmsg\n");

  TitleStr = XmStringCreateLtoR((char*) "PlcEdit Confirm" , (char*) "ISO8859-1");    
  XtSetArg(args[0],XmNdialogTitle,TitleStr);
  XtSetValues( widgets.caution, args, 1);
  XmStringFree(TitleStr);


  /* create the pane widgets */
  /* create the palette module */
  /* SG 07.03.91 put two palletes in the sub pane widget */

  node_palctx = new PalMotif( this, widgets.subpane, "Objects",
		ldhsession, "PlcEditorPalette", 
		&widgets.node_palette, &sts);
  node_palette_managed = 1;

  navctx = new NavMotif( this, widgets.subpane, "Plant",
		ldhsession, "NavigatorW1",
		&widgets.nav_palette, &sts);
  XtUnmanageChild( widgets.nav_palette);

  con_palctx = new PalMotif( this, widgets.subpane, "Connections",
		ldhsession, "PlcEditorConPalette", 
		&widgets.con_palette, &sts);
  XtUnmanageChild( widgets.con_palette);


  /* Turn off traversal for sash widgets */
  XtVaGetValues(widgets.subpane, 
		XmNchildren, &children,
		XmNnumChildren, &num_children,
		NULL);
  for (i = 0; i < num_children; i++) {
    if (XmIsSash(children[i]))
      XtVaSetValues(children[i], XmNtraversalOn, False, NULL);
  }

  /* create the gredit module */
  XtManageChild(widgets.foe_window);


  gre = new WGreMotif( this, widgets.pane, "Name");

  ((WGreMotif *)gre)->new_navigator( widgets.subpane);

  if ( map_window)
    XtPopup(parent_wid, XtGrabNone);
  else
    XtRealizeWidget( parent_wid);

  gre->init();

  /* create the setup ie:
     enable netedevents,
     enable menu entries
     setup backcalls from the gredit module */

  function_setup();

  MrmCloseHierarchy(s_MrmH);

  if (compiled_translations == NULL) 
    compiled_translations = XtParseTranslationTable(translations);
  XtOverrideTranslations( widgets.foe_window, compiled_translations);

  XtUnmanageChild(widgets.textinput);

  if ( !(CoLogin::privilege() & pwr_mPrv_DevPlc ) || 
       (function_access == foe_eFuncAccess_View)) {
    /* Mode Edit and Simulate is not allowed */
    i=0;
    XtSetArg(args[i],XmNsensitive,0); i++;

    XtSetValues( widgets.edit_togg,args,i);
    XtSetValues( widgets.simulate_togg,args,i);
  }

  if (MwmDeleteWind == 0)
    MwmDeleteWind = XInternAtom(XtDisplay(parent_wid), "WM_DELETE_WINDOW", FALSE);

  if (MwmDeleteWind != 0) {
    XtVaSetValues(parent_wid, XmNdeleteResponse, XmDO_NOTHING, NULL);
    XmAddWMProtocolCallback(parent_wid, MwmDeleteWind, 
			    (XtCallbackProc)activate_quit, this);
  }

  CoWowMotif::GetAtoms( parent_wid, 0, &objid_atom, 0);

  /* SG 09.02.91 a top level should always be realized !
   * ML 16.03.94 changed Realize to Popup
   */

  return FOE__SUCCESS;
}
Esempio n. 28
0
WGeMotif::WGeMotif( Widget wge_parent_wid, void *wge_parent_ctx, char *wge_name, char *wge_filename,
	  int wge_scrollbar, int wge_menu, int wge_navigator, int wge_width, int wge_height, 
	  int x, int y, char *object_name, int wge_modal = 0) :
  WGe(wge_parent_ctx, wge_name, wge_filename, wge_scrollbar, wge_menu, wge_navigator, wge_width,
      wge_height, x, y, object_name, wge_modal),
  parent_wid(wge_parent_wid), value_dialog(0), set_focus_disabled(0), focus_timerid(0)
{
  pwr_tFileName	uid_filename = {"$pwr_exe/wb_wge.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  char 		title[300];
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  Widget	wge_widget;
  char		wname[] = "Proview/R Ge";

  static char translations[] =
    "<ConfigureNotify>: resize()\n\
<FocusIn>: wge_inputfocus()";
  static XtTranslations compiled_translations = NULL;

  static XtActionsRec actions[] =
  {
    {(char*) "wge_inputfocus",      (XtActionProc) action_inputfocus},
    {(char*) "resize",      (XtActionProc) action_resize},
  };

  static MrmRegisterArg	reglist[] = {
        {(char*) "wge_ctx", 0 },
	{(char*) "wge_activate_exit",(caddr_t)activate_exit },
	{(char*) "wge_activate_zoom_in",(caddr_t)activate_zoom_in },
	{(char*) "wge_activate_zoom_out",(caddr_t)activate_zoom_out },
	{(char*) "wge_activate_zoom_reset",(caddr_t)activate_zoom_reset },
	{(char*) "wge_activate_help",(caddr_t)activate_help },
	{(char*) "wge_create_graph_form",(caddr_t)create_graph_form },
	{(char*) "wge_create_menu",(caddr_t)create_menu },
	{(char*) "wge_create_value_input",(caddr_t)create_value_input },
	{(char*) "wge_activate_value_input",(caddr_t)activate_value_input },
	{(char*) "wge_activate_confirm_ok",(caddr_t)activate_confirm_ok },
	{(char*) "wge_activate_confirm_cancel",(caddr_t)activate_confirm_cancel },
	{(char*) "wge_create_message_dia",(caddr_t)create_message_dia }
	};

  static int	reglist_num = (sizeof reglist / sizeof reglist[0]);

  dcli_translate_filename( uid_filename, uid_filename);

  // Create object context
  strcpy( filename, wge_filename);
  strcpy( name, wge_name);
  // command_cb = command_cb;
  // help_cb = help_cb;
  // close_cb = close_cb;
  // is_authorized_cb = is_authorized_cb;

  // Motif
  MrmInitialize();

  cdh_StrncpyCutOff( title, name, sizeof(title), 1);

  reglist[0].value = (caddr_t) this;


  sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_DRMh);
  if (sts != MrmSUCCESS) printf("can't open %s\n", uid_filename);

  // Save the context structure in the widget
  i = 0;
  XtSetArg(args[i], XmNuserData, (XtPointer) this);i++;
  XtSetArg(args[i],XmNdeleteResponse, XmDO_NOTHING);i++;

  toplevel = XtCreatePopupShell( title, 
		topLevelShellWidgetClass, parent_wid, args, i);

  MrmRegisterNames(reglist, reglist_num);

  sts = MrmFetchWidgetOverride( s_DRMh, (char*) "wge_window", toplevel,
			wname, args, 1, &wge_widget, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch %s\n", wname);

  sts = MrmFetchWidget(s_DRMh, (char*) "input_dialog", toplevel,
		&value_dialog, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch input dialog\n");

  sts = MrmFetchWidget(s_DRMh, (char*) "confirm_dialog", toplevel,
		&confirm_widget, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch confirm dialog\n");

  sts = MrmFetchWidget(s_DRMh, (char*) "message_dialog", toplevel,
		&message_dia_widget, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch message dialog\n");

  MrmCloseHierarchy(s_DRMh);

  if (compiled_translations == NULL) 
    XtAppAddActions( XtWidgetToApplicationContext(toplevel), 
						actions, XtNumber(actions));
 
  if (compiled_translations == NULL) 
    compiled_translations = XtParseTranslationTable(translations);
  XtOverrideTranslations( wge_widget, compiled_translations);

  i = 0;
  if ( width == 0 || height == 0)
  {
    XtSetArg(args[i],XmNwidth,600);i++;
    XtSetArg(args[i],XmNheight,500);i++;
  }
  else
  {
    XtSetArg(args[i],XmNwidth,width);i++;
    XtSetArg(args[i],XmNheight,height);i++;
    XtSetArg(args[i], XmNminAspectX, width); i++;
    XtSetArg(args[i], XmNminAspectY, height); i++;
    XtSetArg(args[i], XmNmaxAspectX, width); i++;
    XtSetArg(args[i], XmNmaxAspectY, height); i++;
  }
  if ( !(x == 0 && y == 0))
  {
    XtSetArg(args[i],XmNx, x);i++;
    XtSetArg(args[i],XmNy, y);i++;
  }
  XtSetValues( toplevel, args,i);
    
  XtManageChild( wge_widget);

  if ( !menu)
    XtUnmanageChild( menu_widget);

  graph = new GraphMotif( this, graph_form, "Plant", 
		&grow_widget, &sts, "pwrp_exe:", graph_eMode_Runtime, 
		scrollbar, 1, object_name, 0, 0);
  ((Graph *)graph)->message_cb = &message;
  ((Graph *)graph)->close_cb = &graph_close_cb;
  ((Graph *)graph)->init_cb = &graph_init_cb;
  ((Graph *)graph)->change_value_cb = &change_value_cb;
  ((Graph *)graph)->confirm_cb = &confirm_cb;
  ((Graph *)graph)->message_dialog_cb = &message_dialog_cb;
  ((Graph *)graph)->command_cb = &wge_command_cb;
  ((Graph *)graph)->is_authorized_cb = &wge_is_authorized_cb;
 
  XtPopup( toplevel, XtGrabNone);

  if ( navigator)
  {
    // Create navigator popup

    i = 0;
    XtSetArg(args[i],XmNallowShellResize, TRUE); i++;
    XtSetArg(args[i],XmNallowResize, TRUE); i++;
    XtSetArg(args[i],XmNwidth,200);i++;
    XtSetArg(args[i],XmNheight,200);i++;
    XtSetArg(args[i],XmNx,500);i++;
    XtSetArg(args[i],XmNy,500);i++;
    XtSetArg(args[i],XmNdeleteResponse, XmDO_NOTHING);i++;

    nav_shell = XmCreateDialogShell( grow_widget, (char*) "Navigator",
        args, i);
    XtManageChild( nav_shell);

    ((GraphMotif *)graph)->create_navigator( nav_shell);
//    XtManageChild( nav_widget);
    XtRealizeWidget( nav_shell);
    ((Graph *)graph)->set_nav_background_color();
  }

  // Connect the window manager close-button to exit
  flow_AddCloseVMProtocolCb( toplevel, 
	(XtCallbackProc)activate_exit, this);

}
Esempio n. 29
0
void WGeMotif::create_message_dia( Widget w, WGe *ge, XmAnyCallbackStruct *data)
{
  XtUnmanageChild( XmMessageBoxGetChild( w, XmDIALOG_OK_BUTTON));
  XtUnmanageChild( XmMessageBoxGetChild( w, XmDIALOG_HELP_BUTTON));
}
Esempio n. 30
0
void WGeMotif::activate_confirm_cancel( Widget w, WGe *ge, XmAnyCallbackStruct *data)
{
  ge->confirm_open = 0;
  XtUnmanageChild( ((WGeMotif *)ge)->confirm_widget);
}