Esempio n. 1
0
void
pushed(Widget pb, XtPointer foo, XtPointer bar)
{
  static Widget dialog;
  XmString t = XmStringCreateSimple("Enter New Button Name:");
  extern void read_name(Widget, XtPointer, XtPointer);
  extern void toggle_callback(Widget, XtPointer, XtPointer);
  Arg args[3];

  XtSetArg(args[0], XmNselectionLabelString, t);
  XtSetArg(args[1], XmNautoUnmanage, False);
  XtSetArg(args[2], XmNuserData, 0);
  dialog = XmCreatePromptDialog(XtParent(pb), "notice", args, 3);
  XmStringFree(t);

  XtAddCallback(dialog, XmNokCallback, read_name, NULL);
  XtAddCallback(dialog, XmNcancelCallback, (XtCallbackProc)XtDestroyWidget,
		NULL);

  XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));

  {
    XmString btn1 = XmStringCreateSimple("Change Name");
    XmString btn2 = XmStringCreateSimple("Change Color");
    Widget toggle_box =
      XmVaCreateSimpleRadioBox(dialog, "radio_box", 0, toggle_callback,
			       XmVaRADIOBUTTON, btn1, 0, NULL, NULL,
			       XmVaRADIOBUTTON, btn2, 0, NULL, NULL,
			       NULL);
    XtManageChild(toggle_box);
  }

  XtManageChild(dialog);
  XtPopup(XtParent(dialog), XtGrabNone);
}
Esempio n. 2
0
/*ARGSUSED*/
void change_labelType(Widget w, XtPointer client_data, XtPointer call_data)
{
  Widget *entries = (Widget *)client_data;
  XmToggleButtonCallbackStruct *info =
      (XmToggleButtonCallbackStruct *)call_data;
  unsigned char labelType;
  XmString tcs;
  int i, n;
  Arg args[2];

  /* find the value from the first, change it in all the others */
  n = 0;
  XtSetArg(args[n], XmNlabelType, &labelType); 		n++;
  XtGetValues(entries[0], args, n);

  if (XmSTRING == labelType) 
    XtSetArg(args[0], XmNlabelType, XmPIXMAP); 
  else	
    XtSetArg(args[0], XmNlabelType, XmSTRING); 

  for (i=0; i < NUM_CHILDREN; i++)
    XtSetValues(entries[i], args, 1);

  if (! info->set)
     tcs = XmStringCreateSimple("Menu items' XmNlabelType = XmPIXMAP");
  else
     tcs = XmStringCreateSimple("Menu items' XmNlabelType = XmSTRING");

  n = 0;
  XtSetArg(args[n], XmNlabelString, tcs);		n++;
  XtSetValues(w, args, n);
}
void ControlPanelGroupDialog::makeGroupList(int item)
{
    XmString *xmstrings;
    int      items = this->panelManager->getGroupCount();
    int      i = -1;

    if (items != 0)
    {
        xmstrings = new XmString[items];
	for(i=0; i < items; i++)
	{
            xmstrings[i] = 
		XmStringCreateSimple((char*)this->panelManager->getPanelGroup(i+1, NULL));
        }
    }
    else
    {
        items = 1;
        xmstrings = new XmString[1];
        xmstrings[0] = XmStringCreateSimple("(none)");
    }

    XtVaSetValues(this->list, 
    	XmNitemCount,        items,
    	XmNvisibleItemCount, items,
    	XmNitems,            xmstrings,
    	NULL);

    this->lastIndex = 0;

    if(i < 0 OR item == 0)
    {
	XmTextSetString(this->text, NULL);
	XtVaSetValues(this->changebtn, XmNsensitive, False, NULL);
	XtVaSetValues(this->deletebtn, XmNsensitive, False, NULL);
    	XmListDeselectAllItems(this->list);
	this->setToggles();
    }
    else
    {
	if(item > 0)
	     XmListSelectPos(this->list, item > items ? 0 : item, True);
	else
	{
	     char *name = XmTextGetString(this->text);
	     for(i=1; i<=items; i++)
		if(EqualString(name, 
			       (char*)this->panelManager->getPanelGroup(i,NULL)))
		   break;
	     XmListSelectPos(this->list, i, True);
	     XtFree(name);   //	AJ
	}
    }

    for (i=0 ; i<items ; i++)
        XmStringFree(xmstrings[i]);

    delete xmstrings;
}
Esempio n. 4
0
int
main(int argc, char **argv)
{
  Widget toplevel, widget, bb, list;
  XtAppContext app;
  XmString item;
  Arg args[10];
  int n = 0;

  XtSetLanguageProc(NULL, NULL, NULL);

  toplevel = XtVaAppInitialize(&app, "ComBox", NULL, 0, &argc, argv, NULL, NULL);

  bb = XmCreateForm(toplevel, "bb", NULL, 0);
  XtManageChild(bb);

  widget = XmCreateDropDownComboBox(bb, "combo", args, n);
  XtVaSetValues(widget,
  	XmNtopAttachment, XmATTACH_FORM,
  	XmNbottomAttachment, XmATTACH_FORM,
  	XmNleftAttachment, XmATTACH_FORM,
  	XmNrightAttachment, XmATTACH_FORM,
  	NULL);

  /* use list routine to add items */
  list = CB_List(widget);

  item = XmStringCreateSimple("Item 1");
  XmListAddItem(list,item,0);
  item = XmStringCreateSimple("Item 2");
  XmListAddItem(list,item,0);
  item = XmStringCreateSimple("Item 3");
  XmListAddItem(list,item,0);
  item = XmStringCreateSimple("Item 4");
  XmListAddItem(list,item,0);
  item = XmStringCreateSimple("Item 5");
  XmListAddItem(list,item,0);

  XmComboBoxUpdate(widget);

  XtManageChild(widget);

  XtRealizeWidget(toplevel);

#if 0
  XdbPrintResources(CB_ListShell(widget));
  XdbPrintResources(widget);
#endif

  check_geometry(widget);

  LessTifTestMainLoop(toplevel);

  exit(0);
}
Esempio n. 5
0
void OpenFile(Widget w, XtPointer a, XtPointer b)
{
	FILE *fp;
	char *filename;
	XmString filename_sel_text, err_mess;

	// Put the name of the file to be opened in to the variable filename 
	XtVaGetValues(fileDialog, XmNtextString, &filename_sel_text, NULL);
	XmStringGetLtoR(filename_sel_text, XmSTRING_DEFAULT_CHARSET, &filename);
	XmStringFree(filename_sel_text);

	if ((fp = fopen(filename, "ro")) == NULL) { // Oh, can't read that one
		err_mess = XmStringCreateSimple("Can't open that file");
		XtVaSetValues(errorDialog, XmNmessageString, err_mess, NULL);
		XmStringFree(err_mess);
		XtManageChild(errorDialog);
	}
	else { // Ok, read it 
		char msg[80];
		struct stat stat_buf;
		off_t file_size;
		int isDir;
		fstat(fileno(fp), &stat_buf);
		file_size = stat_buf.st_size;
		isDir =  (stat_buf.st_mode & S_IFDIR);
		fclose(fp);
		XtUnmanageChild(fileDialog);

		// check file location and type dir:file to run Xine
		if (strncmp(filename, USBDIR, 4) != 0) {
			sprintf(msg, "Selected file %s must be under %s", filename, USBDIR);
			err_mess = XmStringCreateSimple(msg);
			XtVaSetValues(errorDialog, XmNmessageString, err_mess, NULL);
			XmStringFree(err_mess);
			XtManageChild(errorDialog);
		}
		else {
#if 0
                        sprintf(msg, "Selected file %s size %d is Dir %d", filename, (int)file_size, isDir);
                        err_mess = XmStringCreateSimple(msg);
                        XtVaSetValues(errorDialog, XmNmessageString, err_mess, NULL);
                        XmStringFree(err_mess);
                        XtManageChild(errorDialog);
#else
			sprintf(cmdline, "%s '%s%s' -V xxmc -f", pnames[XINEAPP], isDir?"dvd:/":" ", filename);
			setThread(cmdline);
#endif
		}
  	}
  	free(filename);
}
Esempio n. 6
0
static  void    activateCB_AF_ApplyButton( Widget UxWidget,
                                          XtPointer UxClientData,
                                          XtPointer UxCallbackArg)
{
  FiletypeData  *pFtD;

  /**************************************************************************/
  /* Check if fields are valid.                                             */
  /**************************************************************************/
  if (!AddFiletypeCheckFields()) {

     /***********************************************************************/
     /* Get FiletypeData structure that was allocated when Add button on    */
     /* the CreateActionAppShell interface was activated.                   */
     /***********************************************************************/
     XtVaGetValues(AddFiletype, XmNuserData, &pFtD, NULL);

     /***********************************************************************/
     /* Get all values from gui                                             */
     /***********************************************************************/
     readAFFromGUI(pFtD);

     /***********************************************************************/
     /* Set the variable that indicates that Apply button was used.         */
     /***********************************************************************/
     pFtD->fsInternal |= CA_FT_APPLY;

     /***********************************************************************/
     /* If in edit mode, then don't do apply type things.                   */
     /***********************************************************************/
     if (!(pFtD->fsInternal & CA_FT_EDIT)) {

        /********************************************************************/
        /* Update the Filetype listbox with this new filetype               */
        /********************************************************************/
        if (XmListItemExists(CA_FiletypesList, XmStringCreateSimple("NONE"))) {
          XmListDeleteItem(CA_FiletypesList, XmStringCreateSimple("NONE"));
        }
        AddFiletypeToList();

        /********************************************************************/
        /* Update FiletypeData array within the ActionData structure        */
        /********************************************************************/
        UpdateFiletypeDataArray(pFtD);

     }
  }
}
Esempio n. 7
0
void create_savefit_popup(Widget w, XtPointer client_data, XtPointer call_data)
{
    Widget fr, dialog;
    XmString dirmask;
    
    set_wait_cursor();
    
    if (savefit_dialog == NULL) {
	savefit_dialog = XmCreateFileSelectionDialog(app_shell, "savefit_dialog", NULL, 0);
	XtVaSetValues(XtParent(savefit_dialog), XmNtitle, "Save fit parameter file", NULL);
	XtAddCallback(savefit_dialog, XmNcancelCallback, (XtCallbackProc) destroy_dialog, savefit_dialog);
	XtAddCallback(savefit_dialog, XmNokCallback, (XtCallbackProc) do_savefit_proc, 0);
	XtAddCallback(savefit_dialog, XmNhelpCallback, (XtCallbackProc) HelpCB, 
	              (XtPointer) NULL);
	fr = XmCreateFrame(savefit_dialog, "fr", NULL, 0);
	dialog = XmCreateRowColumn(fr, "dialog_rc", NULL, 0);

	save_title_item = CreateTextItem2(dialog, 25, "Title: ");

	XtManageChild(dialog);
	XtManageChild(fr);
    }
    
    XtManageChild(savefit_dialog);
    XtRaise(XtParent(savefit_dialog));
    
    xv_setstr(save_title_item, nonl_opts.title);

    dirmask = XmStringCreateSimple(workingdir);
    XmFileSelectionDoSearch(savefit_dialog, dirmask);
    XmStringFree(dirmask);

    unset_wait_cursor();
}
Esempio n. 8
0
void update_nonl_frame(void)
{
    int i;
    
    if (nonl_frame) {
        XmString str = XmStringCreateSimple(nonl_opts.title);
        XtVaSetValues(nonl_title_item, XmNlabelString, str, NULL);
/* 
 * If I define only XmALIGNMENT_CENTER (default!) then it's ignored - bug in Motif???
 */
    	XtVaSetValues(nonl_title_item, XmNalignment, XmALIGNMENT_BEGINNING, NULL);
        XtVaSetValues(nonl_title_item, XmNalignment, XmALIGNMENT_CENTER, NULL);
        XmStringFree(str);
        
        xv_setstr(nonl_formula_item, nonl_opts.formula);
        sprintf(buf, "%g", nonl_opts.tolerance);
        xv_setstr(nonl_tol_item, buf);
        SetChoice(nonl_nparm_item, nonl_opts.parnum);
        for (i = 0; i < MAXPARM; i++) {
            sprintf(buf, "%g", nonl_parms[i].value);
            xv_setstr(nonl_value_item[i], buf);
            XmToggleButtonSetState(nonl_constr_item[i], nonl_parms[i].constr, False);
            sprintf(buf, "%g", nonl_parms[i].min);
            xv_setstr(nonl_lowb_item[i], buf);
            XtSetSensitive(nonl_lowb_item[i], nonl_parms[i].constr);
            sprintf(buf, "%g", nonl_parms[i].max);
            xv_setstr(nonl_uppb_item[i], buf);
            XtSetSensitive(nonl_uppb_item[i], nonl_parms[i].constr);
            if (i < nonl_opts.parnum) {
                if (!XtIsManaged (nonl_parm_item[i])) {
                    XtManageChild(nonl_parm_item[i]);
                }
            } else {
                if (XtIsManaged (nonl_parm_item[i])) {
                    XtUnmanageChild(nonl_parm_item[i]);
                }
            }
        }
        
        XmToggleButtonSetState(nonl_autol_item, nonl_prefs.autoload, False);
        for (i = 0; i < 3; i++) {
	    XmToggleButtonSetState(nonl_load_item[i], False, False);
        }
        XmToggleButtonSetState(nonl_load_item[nonl_prefs.load], True, False);
        
        if (nonl_prefs.load == LOAD_FUNCTION) {
            XtSetSensitive(nonl_fload_rc, True);
        } else {
            XtSetSensitive(nonl_fload_rc, False);
        }
        
        sprintf(buf, "%g", nonl_prefs.start);
        xv_setstr(nonl_start_item, buf);
        sprintf(buf, "%g", nonl_prefs.stop);
        xv_setstr(nonl_stop_item, buf);
        sprintf(buf, "%d", nonl_prefs.npoints);
        xv_setstr(nonl_npts_item, buf);
    }

}
Esempio n. 9
0
void CLogMotif::activate_select_file( Widget w, CLog *clog, XmAnyCallbackStruct *data)
{
  XmString cstr;  
  char str[200];
  char *s;

  if ( !clog->filesel_loaded) {
    for ( int i = 0; i < (int) clog->clognav->file_list.size(); i++) {
      time_AtoAscii( &clog->clognav->file_list[i].time, time_eFormat_ComprDateAndTime, 
		     str, sizeof(str));
      str[17] = 0;
      strcat( str, "    ");
      s = strrchr( clog->clognav->file_list[i].name, '/');
      if ( s)
	strcat( str, s+1);
      else
	strcat( str, clog->clognav->file_list[i].name);

      cstr = XmStringCreateSimple( str);
      XmListAddItemUnselected( ((CLogMotif *)clog)->filesel_list_w, cstr, 0);
      XmStringFree(cstr);
    }
    clog->filesel_loaded = true;
  }
  XtManageChild( ((CLogMotif *)clog)->filesel_form);
}
Esempio n. 10
0
static void
UpdateGraph(WorkingData_t *Data)
{
Dimension width, height;
Widget title = XtNameToWidget(XtParent(Data->Da), "*Title");
XmString string;
char buf[1024];

	XtVaGetValues(Data->Da,
		XmNwidth, &width,
		XmNheight, &height,
		NULL);
	sprintf(buf, "%i%%", Data->percent);
	string = XmStringCreateSimple(buf);
	XtVaSetValues(title,
		XmNlabelString, string,
		NULL);
	XmStringFree(string);
	XFillRectangle(XtDisplay(Data->Da), XtWindow(Data->Da), Data->gc,
		0, 0,
		(width * Data->percent) / 100,
		height);
	XmUpdateDisplay(Data->Da);
	Data->Id = XtAppAddTimeOut(XtWidgetToApplicationContext(Data->Da),
			    1000, (XtTimerCallbackProc)UpdateGraph, Data);
}
Esempio n. 11
0
void pp_display_filter_acct_cb(Widget w, XtPointer *call_data, XmAnyCallbackStruct *client_data)
{
int i;
XmString temp;

  if (pp_main_poplist_shell == NULL)
  {
     create_pp_main_poplist_shell(product_packages_shell);
  }

  XmListDeleteAllItems (pp_main_poplist);
  XmListDeselectAllItems (pp_main_poplist);

  for (i = 0; i < num_pp_ext_ids_list; i++)
  {
    temp = XmStringCreateSimple (pp_ext_ids_list[i].description);
    XmListAddItem (pp_main_poplist, temp, 0);
    XmStringFree (temp);
  }

  /* Set the text field that will be populated when user selects
   * a value from the list.
   */
  XtVaSetValues (pp_main_poplist, XmNuserData, pp_filter_account_no_txt, NULL);

  position_poplist (w,pp_main_poplist_shell);

  XtManageChild (pp_main_poplist_form);
  XtPopup (pp_main_poplist_shell, XtGrabNone);

}
Esempio n. 12
0
static Widget CreateMenu(Widget parent,char *name,char *label,
    int mnemonic, Widget *cascade_btn)
{
    Widget
        menu_w,
        cascade_w;

    XmString
        xmstr;

    menu_w=XmCreatePulldownMenu(parent,name,NULL,0);       
    cascade_w=XtVaCreateWidget(name,     
        xmCascadeButtonWidgetClass, parent, 
        XmNlabelString, xmstr=XmStringCreateSimple(label),
        XmNsubMenuId, menu_w,
        NULL);
    XmStringFree(xmstr);

    if (mnemonic != 0) 
    {
        XtVaSetValues(cascade_w,
            XmNmnemonic,mnemonic,
            NULL);
    }
    XtManageChild(cascade_w);

    if (cascade_btn != NULL)
        *cascade_btn=cascade_w;

    return (menu_w);
}
Esempio n. 13
0
//
// create a LABEL + Edit line + an apply button
//
void
InvAnnotationEditor::createEditLine(Widget parent)
{
    Arg args[5];
    int i(0);

    Widget rc = XmCreateRowColumn(parent, (char *)"rc", NULL, 0);
    //    XtSetArg(args[i], XmNlabelString, descStr); i++;

    i = 0;
    XmString descStr = XmStringCreateSimple((char *)"enter annotation text:");
    XtSetArg(args[i], XmNlabelString, descStr);
    i++;
    Widget description = XmCreateLabel(rc, (char *)"description", args, 1);

    mTextField_ = XmCreateTextField(rc, (char *)"tf", NULL, 0);

    Widget applyBut = XmCreatePushButton(rc, (char *)"Apply", NULL, 0);

    XtAddCallback(applyBut, XmNactivateCallback, editApplyCB, (XtPointer) this);

    // manage all
    XtManageChild(rc);
    XtManageChild(description);
    XtManageChild(mTextField_);
    XtManageChild(applyBut);
}
//
// Set the correct title 'Open/Close Colormap...' 
//
void OpenColormapDialog::manage()
{
    XmString   xmstring;

    if (opening)
	xmstring = XmStringCreateSimple("Open Colormap...");
    else
	xmstring = XmStringCreateSimple("Save Colormap...");

    XtVaSetValues(this->fsb,
		  XmNdialogTitle, xmstring,
		  NULL);
    XmStringFree(xmstring);

    this->FileDialog::manage();
}
Esempio n. 15
0
static void pts_activate_proc(Widget w)
{
  Widget parent_w = XtParent(w);
  Widget mems_w = XtNameToWidget(parent_w, "mems_scale");
  Widget header_w = XtNameToWidget(parent_w, "header_menu");
  Widget pts_dlog = XtNameToWidget(parent_w, "*pts_dlog");
  int pts[8];
  int mems;
  struct descriptor_xd *header_xd = XmdsNidOptionMenuGetXd(header_w);
  static char header[7];
  static struct descriptor header_dsc = {sizeof(header), DTYPE_T, CLASS_S, header};
  int status = TdiText(header_xd, &header_dsc MDS_END_ARG);
  int i;
  XmScaleGetValue(mems_w, &mems);
  L8210HeaderToPTS(header, (char *)&mems, pts);
  for (i=0; i<8; i++) {
    char pts_str[10];
    char name_str[9];
    XmString lab;
    sprintf(pts_str, "%d", pts[i]);
    sprintf(name_str,"*.pts_%d",i);
    lab = XmStringCreateSimple(pts_str);
    XtVaSetValues(XtNameToWidget(pts_dlog,name_str), XmNlabelString, lab, NULL);
    XmStringFree(lab);
  }
  XtManageChild(pts_dlog);
}
Esempio n. 16
0
/* button callbacks */
void PosFileButCB (Widget w, XtPointer clientData, XtPointer callData)
/* File button hit - get info from a file */
{
  ImageDisplay *IDdata;
  XmString     wierdstring;
  Arg          wargs[5]; 

  IDdata = (ImageDisplay *)clientData;

  mark.posfilebox = (Widget) XmCreateFileSelectionDialog (w, "filebox", 
							  NULL, 0);
  XtAddCallback (mark.posfilebox, XmNokCallback, PosFileOKCB, clientData);
  XtAddCallback (mark.posfilebox, XmNcancelCallback, PosFileCancelCB, 
		 clientData);

/* set directory if it is defined */
  if (mark_dir) {
    wierdstring = XmStringCreateSimple (mark_dir->sp);
    XtSetArg (wargs[0], XmNdirectory, wierdstring);
    XtSetValues (mark.posfilebox, wargs, 1);
    XmStringFree(wierdstring);
  }
/* Shazam appear: */
  XtManageChild (mark.posfilebox);
  XtPopup (XtParent (mark.posfilebox), XtGrabNone);
/* all the action is in the callback routine */

/*  XtDestroyWidget (mark.dialog); */
/*  PositionBoxActive = 0;  mark as inactive */
} /* end PosFileButCB */
void ColormapAddCtlDialog::setStepper()
{
    double        step, min, max;
    ColormapNode* node;
    char          str[100];

    node = this->editor->getColormapNode();

    max = node->getMaximumValue();
    min = node->getMinimumValue();

    step = (max - min)/100;

#ifdef PASSDOUBLEVALUE
	XtArgVal dx_l1, dx_l2, dx_l3;
#endif

    XtVaSetValues(this->levelstepper,
		  XmNdMinimum, DoubleVal(min, dx_l1),
		  XmNdMaximum, DoubleVal(max, dx_l2),
		  XmNdValueStep, DoubleVal(step, dx_l3),
		  NULL);

    sprintf(str, "Data value(%g to %g):", min, max);
    XmString xmstr = XmStringCreateSimple(str);
    XtVaSetValues(this->levellabel, XmNlabelString, xmstr, NULL);
    XmStringFree(xmstr);
}
Esempio n. 18
0
char *UISelectObject (Widget widget,DBObjectLIST<DBObject> *objList,DBInt (*condFunc) (const DBObject *))

	{
	int i = 0;
	XmString *strings;
	DBObject *obj;

	if (objList->ItemNum () < 1) { UIMessage ((char *) "Empty List"); return (NULL); }
	if ((strings = (XmString *) calloc	(objList->ItemNum (),sizeof (XmString))) == NULL)
		{ CMmsgPrint (CMmsgSysError, "Memory Allocation Error in: %s %d",__FILE__,__LINE__); return (NULL); }

	if (condFunc == (UISelectCondFunc) NULL) condFunc = _UISelectObjectAll;
	for (obj = objList->First ();obj != NULL;obj = objList->Next ())
		if (((obj->Flags () & DBObjectFlagIdle) != DBObjectFlagIdle) && (*condFunc) (obj))
			strings [i++] = XmStringCreateSimple (obj->Name ());

	_UISelection = NULL;
	XtVaSetValues (widget,XmNlistItems, strings,XmNlistItemCount, i,NULL);
	XtManageChild (widget);

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

	for (;i > 0;--i) XmStringFree (strings [i - 1]);
	free (strings);
	return (_UISelection);
	}
void displayStatus::clear()
{

  XmString str = XmStringCreateSimple(" ");

  dpyLabel->setValues(XmNlabelString, (XtArgVal) str, NULL);
}
Esempio n. 20
0
XmString xGRregion_name(
REGOBJ *region,
int maxlen
)

{
	extern REGOBJ *regObj;

	char buf[90];
	XmString regionlabel;

	strcpy(buf, region->Regionname);
	if (region->indVater != NOVATER)
	{
		strcat(buf, TRENNER);
		strcat(buf, regObj[region->indVater].Regionname);
	}

	if (maxlen > 0) {
		xGRstringpos(buf, maxlen, XGRLEFT);
	}

	regionlabel = XmStringCreateSimple(buf);
	return(regionlabel);
}
void displayStatus::fill(char* first ...)
{
  char* status = new char[maxLength + 1];
  int currentLength = strlen(first);
  strcpy(status, first);

  va_list args;
  va_start(args, first);

  for(;;) {
    char* tempStr = va_arg(args, char*);
    if (tempStr==NULL) break;
    currentLength += strlen(tempStr);

    if (currentLength>maxLength) break;
    strcat(status, tempStr);
  }

  va_end(tempStr);
  if (!status) { clear(); return; }

  XmString str = XmStringCreateSimple(status);
  dpyLabel->setValues(XmNlabelString, (XtArgVal) str, NULL);

  XmStringFree(str);
}
Esempio n. 22
0
Widget XmdsCreateXdBoxOnOffButton(Widget parent,String name,ArgList args,Cardinal argcount)
{
  Widget w;
  Resources info = {0,0,1,0};
  XmdsSetSubvalues(&info,resources,XtNumber(resources),args,argcount);
  w = XmCreateRowColumn(parent,name,args,argcount);
  XtVaSetValues(w,XmNpacking,XmPACK_TIGHT,XmNorientation,XmHORIZONTAL,XmNspacing,0,XmNadjustMargin,0,NULL);
  {
    Widget oo_w;
    Widget xd_w;
    XmString blank = XmStringCreateSimple("");
    Arg arglist[] = {{XmdsNnid, 0},
		     {XmdsNnidOffset, 0},
		     {XmdsNputOnApply, 0},
		     {XmNlabelString, 0}};
    arglist[0].value = info.nid;
    arglist[1].value = info.nid_offset;
    arglist[2].value = info.put_on_apply;
    arglist[3].value = (long) blank;
    XtManageChild(oo_w = XmdsCreateOnOffToggleButton(w,"xmds_xdbox_on_off",arglist,XtNumber(arglist)));
    arglist[3].value = (long) info.label;
    XtManageChild(xd_w = XmdsCreateXdBoxDialogButton(w,"xmds_xdbox_dialog_button",arglist,XtNumber(arglist)));
    xd_w = XmdsXdBoxDialogButtonGetXdBox(xd_w);
    XtAddCallback(oo_w,XmNvalueChangedCallback,(XtCallbackProc)SetXdState,xd_w);
    XtAddCallback(xd_w,XmdsNapplyCallback,(XtCallbackProc)SetTbState,oo_w);
    XtAddCallback(xd_w,XmdsNokCallback,(XtCallbackProc)SetTbState,oo_w);
  }
  return w;
}
Esempio n. 23
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;
	}
Esempio n. 24
0
/*
** Add an item to an already established pull-down or pop-up menu, including
** mnemonics, accelerators and callbacks.
*/
Widget AddMenuItem(Widget parent, char *name, char *label,
			  char mnemonic, char *acc, char *accText,
			  XtCallbackProc callback, void *cbArg)
{
    Widget button;
    XmString st1, st2;
    
    button = XtVaCreateManagedWidget(name, xmPushButtonWidgetClass, parent, 
    	XmNlabelString, st1=XmStringCreateSimple(label),
    	XmNmnemonic, mnemonic,
    	XmNacceleratorText, st2=XmStringCreateSimple(accText),
    	XmNaccelerator, acc, NULL);
    XtAddCallback(button, XmNactivateCallback, callback, cbArg);
    XmStringFree(st1);
    XmStringFree(st2);
    return button;
}
Esempio n. 25
0
/* print message in UI window */
void UIMessage(char *message)
{
    if( !ui ){
        return;
    }
    XtVaSetValues(ui->message, XmNlabelString, XmStringCreateSimple(message),
                  NULL);
}
Esempio n. 26
0
/**************************************************************************
CreateMenus: This function generates the menu bar and the submenus.
**************************************************************************/
void
CreateMenus(Widget parent_of_menu_bar)
{
    XmString   file, help;
    Widget     menubar, FilePullDown, HelpPullDown;
    Widget     overview, quit, Help1;

    /* Create the menubar itself. */
    file = XmStringCreateSimple("File");
    help = XmStringCreateSimple("Help");

    menubar      = (Widget)XmCreateMenuBar(parent_of_menu_bar, "menubar",
                                           NULL, 0);
    FilePullDown = (Widget)XmCreatePulldownMenu(menubar, "FilePullDown",
                   NULL, 0);
    HelpPullDown = (Widget)XmCreatePulldownMenu(menubar, "HelpPullDown",
                   NULL, 0);

    /******************************FILE*********************************/
    XtVaCreateManagedWidget("File", xmCascadeButtonWidgetClass, menubar,
                            XmNlabelString, file,
                            XmNmnemonic, 'F',
                            XmNsubMenuId, FilePullDown,
                            NULL);
    quit = XtVaCreateManagedWidget("Quit", xmPushButtonGadgetClass,
                                   FilePullDown, NULL);
    XtAddCallback(quit, XmNactivateCallback, QuitCB, NULL);


    /******************************HELP*********************************/
    Help1 = XtVaCreateManagedWidget("Help", xmCascadeButtonWidgetClass,
                                    menubar,
                                    XmNlabelString, help,
                                    XmNmnemonic, 'H',
                                    XmNsubMenuId, HelpPullDown,
                                    NULL);
    XtVaSetValues(menubar, XmNmenuHelpWidget, Help1, NULL);
    overview = XtVaCreateManagedWidget("Overview", xmPushButtonGadgetClass,
                                       HelpPullDown, NULL);
    XtAddCallback(overview, XmNactivateCallback, HelpCB, (XtPointer)1);

    XmStringFree(file);
    XmStringFree(help);

    XtManageChild(menubar);
}
Esempio n. 27
0
void WVselMotif::list_add_item( char *str)
{
  XmString 	cstr;  

  cstr = XmStringCreateSimple( str);
  XmListAddItemUnselected( widgets.volumelist, cstr, 0);
  XmStringFree(cstr);	  
}
Esempio n. 28
0
void UIaddlist(char *line)
{
  XmString item = XmStringCreateSimple(line);

  XmListAddItem(AnimList, item, 0); /* add item to the end of the list */

  XmStringFree(item);
}
Esempio n. 29
0
void cycle_values (Widget w, XtPointer client_data, XtPointer call_data)
{
  Widget entry = (Widget) client_data;
  static char *orig_strings[NUM_VALUES] = {
    "1",
    "second in series",
    "third in series",
    "fourth in series",
    "fifth in series",
    "sixth in series",
    "the seventh in the series",
    "last in series"
    };

  static struct bitmap_data {
    char *bits;
    int width;
    int height;
  } orig_pixmap[] = 
    {
      {(char *) star_bits, star_width, star_height},
      {(char *) opendot_bits, opendot_width, opendot_height},
      {(char *) black_bits, black_width, black_height},
      {(char *) boxes_bits, boxes_width, boxes_height},
      {(char *) icon_bits, icon_width, icon_height},
      {(char *) xlogo16_bits, xlogo16_width, xlogo16_height},
      {(char *) xlogo32_bits, xlogo32_width, xlogo32_height},
      {(char *) wide_weave_bits, wide_weave_width, wide_weave_height},
    };

  static XmString strings[NUM_VALUES];
  static Pixmap pixmaps[NUM_VALUES];
  Arg args[5];
  int n;
  int i;
  static Boolean values_set = False;
  static int which_one = 0;

  if (!values_set)
    {
      values_set = True;
      for (i=0; i < NUM_VALUES; i++)
	{
	  strings[i] = XmStringCreateSimple(orig_strings[i]);
	  pixmaps[i] = makepixmap(w,orig_pixmap[i].bits,
				orig_pixmap[i].width,orig_pixmap[i].height);
	}
      /* gosh; remember to destroy these ! */
    }
  n = 0;
  XtSetArg(args[n], XmNlabelString, strings[which_one]); 	n++;
  XtSetArg(args[n], XmNlabelPixmap, pixmaps[which_one]); 	n++;
  XtSetValues (entry, args, n);

  which_one++;
  which_one %= NUM_VALUES;
}
Esempio n. 30
0
/***********************************************************************
 *                                                                     *
 *   Copy selected items from the left list to the right list.         *
 *                                                                     *
 ***********************************************************************/
static void copy_cb(Widget w, XtPointer cd, XmAnyCallbackStruct *cbs)
{
   int         icnt, pos, pcnt, *posl;
   XmString   *items;

   if (XmListGetSelectedPos(var2NtSList, &posl, &pcnt)) {
      pos = posl[pcnt-1] + 1;
      XtFree((char *)posl);
   } else
      pos = 0;
   XmListDeselectAllItems(var2NtSList);

   if (w == exprNtSText) {

      char     *expr = XmTextGetString(w);

      if (!strempty(expr)) {
         XmString xms = XmStringCreateSimple(expr);

         XmListAddItem(var2NtSList, xms, pos);

         XmStringFree(xms);
      }
      XtFree(expr);

      /*
       * ugly... I don't want to show the scanner after hitting the
       * KActivate in the text widget
       */
      no_scan = True;

   } else if (w == copyNtSButton) {

      XtVaGetValues(var1NtSList, XmNselectedItemCount, &icnt,
                                 XmNselectedItems,     &items,
                                 NULL);

      XmListAddItems(var2NtSList, items, icnt, pos);

   } else if (w == copyAllNtSButton) {

      XtVaGetValues(var1NtSList, XmNitemCount, &icnt,
                                 XmNitems,     &items,
                                 NULL);

      clear_selector_columns(2);
      XmListAddItems(var2NtSList, items, icnt, pos);

   } else if (w == var1NtSList) {

      XmListCallbackStruct *cbsl = (XmListCallbackStruct *) cbs;
      if (cbsl->event->type == ButtonRelease)
         XmListAddItem(var2NtSList, cbsl->item, pos);

   }
   XmListSelectPos(var2NtSList, pos, False);
}