Ejemplo n.º 1
0
static void
create_shell(Display *display,
             char *app_name,
             int app_argc,
             char **app_argv)
{
	Arg al[12];                    /* Arg List */
	int ac;           /* Arg Count */
	XmString *list_items;          /* For list items */
	int list_item;                 /* Index for list_items */
	/* XmFontList f1; */

	ac = 0;
	XtSetArg(al[ac], XmNallowShellResize, TRUE); ac++;
	XtSetArg(al[ac], XmNargc, app_argc); ac++;
	XtSetArg(al[ac], XmNargv, app_argv); ac++;
	shell = XtAppCreateShell ( app_name, "XApplication", applicationShellWidgetClass, display, al, ac );

	initialise_objects ( shell );
	
	ac = 0;
	XtSetArg(al[ac], XmNautoUnmanage, FALSE); ac++;
	XtSetArg(al[ac], XmNlabelFontList, f1); ac++;
	XtSetArg(al[ac], XmNheight, 400); ac++;
	form = XmCreateForm ( shell, "form", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNfontList, f1); ac++;
	XtSetArg(al[ac], XmNselectionPolicy, XmSINGLE_SELECT); ac++;
	XtSetArg(al[ac], XmNlistSizePolicy, XmRESIZE_IF_POSSIBLE); ac++;
	XtSetArg(al[ac], XmNitemCount, 5); ac++;
	list_items = (XmString *) XtMalloc ( sizeof (XmString) * 5 );
	list_items[0] = XmStringCreateLtoR("The", "large_italic");
	list_items[1] = XmStringCreateLtoR("Quick", "small_bold");
	/*list_items[2] = XmStringCreateLtoR("\033$BF|\033(B\033$BK\\\033(B", "japanese" );*/
	list_items[2] = XmStringCreateLtoR("F|  K\\", "japanese" );
	list_items[3] = XmStringCreateLtoR("Brown", "small_italic");
	list_items[4] = XmStringCreateLtoR("Fox", "large_bold");
	XtSetArg(al[ac], XmNitems, list_items); ac++;
	list1 = XmCreateScrolledList ( form, "list1", al, ac );
	list1_sw = XtParent ( list1 );

	for (list_item = 0; list_item < 5; list_item++ )
		XmStringFree (list_items [list_item]);
	XtFree ( (char *) list_items ); 
	da = XmCreateDrawingArea ( form, "da", al, 0 );

	ac = 0;
	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNbottomPosition, 65); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;

	XtSetValues ( list1_sw,al, ac );

	ac = 0;
	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNtopPosition, 65); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetValues ( da,al, ac );

	XtManageChild(list1);
	XtAddCallback (da, XmNexposeCallback, da_expose, list1);
	XtManageChild(da);
	XtManageChild ( form);
}
Ejemplo n.º 2
0
bool wxListBox::Create(wxWindow *parent, wxWindowID id,
                       const wxPoint& pos,
                       const wxSize& size,
                       int n, const wxString choices[],
                       long style,
                       const wxValidator& validator,
                       const wxString& name)
{
    if( !wxControl::CreateControl( parent, id, pos, size, style,
                                   validator, name ) )
        return false;

    m_noItems = (unsigned int)n;
    m_backgroundColour = * wxWHITE;

    Widget parentWidget = (Widget) parent->GetClientWidget();
    Display* dpy = XtDisplay(parentWidget);

    Arg args[4];
    int count = 0;
    XtSetArg( args[count], XmNlistSizePolicy, XmCONSTANT ); ++count;
    XtSetArg( args[count], XmNselectionPolicy,
              ( m_windowStyle & wxLB_MULTIPLE ) ? XmMULTIPLE_SELECT :
              ( m_windowStyle & wxLB_EXTENDED ) ? XmEXTENDED_SELECT :
                                                  XmBROWSE_SELECT );
    ++count;
    if( m_font.Ok() )
    {
        XtSetArg( args[count],
                  (String)wxFont::GetFontTag(), m_font.GetFontTypeC(dpy) );
        ++count;
    }
    if( m_windowStyle & wxLB_ALWAYS_SB )
    {
        XtSetArg( args[count], XmNscrollBarDisplayPolicy, XmSTATIC );
        ++count;
    }

    Widget listWidget =
        XmCreateScrolledList(parentWidget,
                             wxConstCast(name.c_str(), char), args, count);

    m_mainWidget = (WXWidget) listWidget;

    Set(n, choices);

    XtManageChild (listWidget);

    wxSize best = GetBestSize();
    if( size.x != -1 ) best.x = size.x;
    if( size.y != -1 ) best.y = size.y;

    XtAddCallback (listWidget,
                   XmNbrowseSelectionCallback,
                   (XtCallbackProc) wxListBoxCallback,
                   (XtPointer) this);
    XtAddCallback (listWidget,
                   XmNextendedSelectionCallback,
                   (XtCallbackProc) wxListBoxCallback,
                   (XtPointer) this);
    XtAddCallback (listWidget,
                   XmNmultipleSelectionCallback,
                   (XtCallbackProc) wxListBoxCallback,
                   (XtPointer) this);
    XtAddCallback (listWidget,
                   XmNdefaultActionCallback,
                   (XtCallbackProc) wxListBoxCallback,
                   (XtPointer) this);

    AttachWidget (parent, m_mainWidget, (WXWidget) NULL,
                  pos.x, pos.y, best.x, best.y);

    ChangeBackgroundColour();

    return true;
}
Ejemplo n.º 3
0
 void imoptmen(Widget iw_temp, void * data, void * call_data)
 { 
 char     cval[5];
 Widget   iw_marlefl, iw_martopl, iw_marxl, iw_maryl, iw_iskipl;
 Widget   iw_dum, iw_rowcol, iw_rowcol1, iw_rowcol2, iw_rowcol3;
 Widget   iw_pushc, iw_pusha, iw_dums, iw_rawsiz;

 if (iw_imoptmen <= (Widget)0)
    {   /* create 3-D montage menu widget first */

    iw_imoptmen = wid_dialog(iw_win,iw_imoptmen,
                             "image display options",20,20);
    iw_rowcol   = wid_rowcol(iw_imoptmen,'v',-1,-1);

    iw_rowcol1  = wid_rowcol(iw_rowcol,'h',-1,-1);
    /* create text box for marlef input ---------------------- marlef */
    sprintf(cval,"%4d",marlef);
    iw_marlef = wid_textboxb(iw_rowcol1,0, "MARGIN    LEFT:",cval,4);
    /* create text box for martop input ---------------------- martop */
    sprintf(cval,"%4d",martop);
    iw_martop = wid_textboxb(iw_rowcol1,0, " TOP:",cval,4);

    iw_rowcol2 = wid_rowcol(iw_rowcol,'h',-1,-1);
    /* create text box for marx input  ------------------------- marx */
    sprintf(cval,"%4d",marx);
    iw_marx = wid_textboxb(iw_rowcol2,0,   "MARGIN       X:",cval,4);
    /* create text box for mary input  ------------------------- mary */
    sprintf(cval,"%4d",mary);
    iw_mary = wid_textboxb(iw_rowcol2,0,   "   Y:",cval,4);

    /* create text box for iskip input  ----------------------- iskip */
    sprintf(cval,"%3d",iskip);
    iw_iskip = wid_textboxb(iw_rowcol,0,   "SIZE REDUCTION:",cval,4);

    /* create toggle box for movie ---------------------------- movie */
    iw_movieo = wid_togmen(iw_rowcol,0,"MONTAGE MOVIE ",movie,0,0);

    /* create toggle box for names ---------------------------- names */
    iw_names = wid_togmen (iw_rowcol,0,"SHOW FILE NAMES ",names,0,0);
 
    /* create toggle box newline ---------------------------- newline */
    iw_newline = wid_togmen(iw_rowcol,0,"START NEW LINE OF IMAGES ",
                             newline,0,0);

    /* create toggle box nuscrn ------------------------------ nuscrn */
    iw_nuscrn = wid_togmen (iw_rowcol,0,"START NEW SCREEN OF IMAGES",
                             nuscrn,0,0);

    /* create toggle box listfi ------------------------------ listfi */
    iw_listfi = wid_togmen(iw_rowcol,0,"LIST FILES IN FILE-SELECTOR",
                             listfi,0,0);

    /* create toggle box for saving x & y set location ------- keepxy */
    iw_keepxy = wid_togmen(iw_rowcol,0,"KEEP X & Y POSITION FOR MONTAGE",
                             keepxy,0,0);

    /* make a push button for changing raw image size  */
    iw_rawsiz = wid_pushg(iw_rowcol, 0, "SET RAW IMAGE SIZE  ",
                  get_imsiz,"0", 0,0);
 
    /* create accept boxes  ----------------------------------- apply */
    iw_pushc = (Widget) 0;
    iw_pusha = (Widget) 0;
    iw_dum   = wid_stdbut(iw_rowcol, iw_imoptmen, &iw_dums, &iw_pushc, &iw_pusha, 
                        "CA",fin_cb,fin_cb,imoptmen_buta, NULL);
    }

 XtManageChild(iw_imoptmen);
 }
Ejemplo n.º 4
0
int WNavMotif::prompt_dialog( char *title, char *text, char **value)
{
    Widget 	dialog;
    XmString	text_str;
    XmString	title_str;
    Arg		args[10];
    int		i;
    XEvent 	Event;

    text_str = XmStringCreateLocalized( wnav_dialog_convert_text(text));
    title_str = XmStringCreateLocalized( title);
    i = 0;
    XtSetArg( args[i], XmNselectionLabelString, text_str);
    i++;
    XtSetArg( args[i], XmNdialogTitle, title_str);
    i++;
    if ( dialog_width && dialog_height)
    {
        XtSetArg( args[i], XmNwidth, dialog_width);
        i++;
        XtSetArg( args[i], XmNheight, dialog_height);
        i++;
        XtSetArg( args[i], XmNx, dialog_x);
        i++;
        XtSetArg( args[i], XmNy, dialog_y);
        i++;
    }
//  XtSetArg( args[i], XmNautoUnmanage, False); i++;

    dialog = XmCreatePromptDialog( parent_wid, (char*) "Info", args, i);
    XmStringFree( text_str);
    XmStringFree( title_str);

    XtUnmanageChild( XmSelectionBoxGetChild( dialog, XmDIALOG_HELP_BUTTON));

    XtAddCallback( dialog, XmNokCallback, wnav_message_dialog_read, this);
    XtAddCallback( dialog, XmNcancelCallback, wnav_message_dialog_cancel, this);

    // Connect the window manager close-button to exit
    flow_AddCloseVMProtocolCb( XtParent(dialog),
                               (XtCallbackProc)wnav_message_dialog_cancel, this);

    XtManageChild( dialog);
    XtPopup( XtParent(dialog), XtGrabNone);

    dialog_ok = 0;
    dialog_cancel = 0;
    dialog_help = 0;

    for (;;)
    {
        XtAppNextEvent( XtWidgetToApplicationContext( dialog), &Event);
        XtDispatchEvent( &Event);
        if ( dialog_ok)
        {
            *value = dialog_value;
            XtDestroyWidget( dialog);
            return 1;
        }
        if ( dialog_cancel)
        {
            strcpy( dialog_value, "");
            *value = dialog_value;
            XtDestroyWidget( dialog);
            return 0;
        }
    }
}
Ejemplo n.º 5
0
/* ARGSUSED */
void vmenuCB ( Widget w, String clnt, XtPointer call )
/************************************************************************
 * vmenucb								*
 *									*
 * This program is the call back for the menu bar in the product review	*
 *									*
 * vmenucb  ( w, clnt, call )						*
 *									*
 * Input parameters:							*
 *  w		Widget		Widget causing the callback		*
 *  clnt	String		Passed in string related to the call	*
 *  call	XtPointer	Structure of widget information		*
 *									*
 * Output parameters:							*
 **									*
 * Log:									*
 * E.Wehner/EAi		6/96	Created					*
 ***********************************************************************/
{
/* 
 * Examine the client data.  Perform action based on the string
 * sent to this call back.
 */

     if (strcmp(clnt, "Quit" ) == 0)
    {
        XtManageChild(exit_dlg);
    }
    else
    {
        if (strcmp(clnt, "ClearScrn" ) == 0)
        {
            raster_up = 0;        /* set to don't display the raster anymore */
            XClearArea(XtDisplay(draw_area), XtWindow(draw_area), 0, 0, 0, 0, 
                             False);
        }
        else
        {
          if (strcmp(clnt, "Open" ) == 0)
          {
              XtManageChild(rastop_dlg);

          }
          else
          {
            if (strcmp(clnt, "sample1") == 0)
            {
              samp_factor = 1;
            }
            else
            {
              if (strcmp(clnt, "sample2") == 0)
              {
                samp_factor = 2;
              }
              else
              {
                if (strcmp(clnt, "sample3") == 0)
                {
                  samp_factor = 3;
                } 
                else
                {
                  if (strcmp(clnt, "sample4") == 0)
                  {
                    samp_factor = 4;
                  }
                  else
                  {
                    if (strcmp(clnt, "Fax_Open") == 0)
                    {
                      printing = FALSE;
                      XtManageChild(wheel_dlg);
                    }
		    else
                    {
                      if (strcmp(clnt, "Print") == 0)
                      {
                        printing = TRUE;
                        XtManageChild(wheel_dlg);
                        XtManageChild(size_box);
                        XtManageChild(size1);
                        XtManageChild(size2);
                      }
                      else
                      {
                          if (strcmp(clnt, "Fontsel" ) == 0)
                          {
                              XtManageChild(size_prompt_dlg);
                          }
                          else
                          {
                              if (strcmp(clnt, "Savefont" ) == 0)
                              {
                                  XtManageChild(fontsave_dlg);
                              }
                          }
                      }
                    }
                  }
                } 
              }
            }
          }
        }
    }
}
Ejemplo n.º 6
0
/* ARGSUSED */
void create_nonl_frame(Widget w, XtPointer client_data, XtPointer call_data)
{
    int i;
    Widget sw, fr, title_fr, fr1, fr3, rc, rc1, rc2, rc3, lab, fitbut[4], but1[2];
    Widget menubar, menupane, submenupane, cascade;
    set_wait_cursor();
    if (nonl_frame == NULL) {
	char *fitlabel[4];
	char *blabel[2];

	fitlabel[0] = "Load as is";
	fitlabel[1] = "Run 5 steps";
	fitlabel[2] = "Run 20 steps";
	fitlabel[3] = "Run 100 steps";
	
	blabel[0] = "Accept";
	blabel[1] = "Cancel";

	nonl_frame = XmCreateDialogShell(app_shell, "Non-linear curve fitting", NULL, 0);
	handle_close(nonl_frame);
	nonl_panel = XmCreateForm(nonl_frame, "nonl_frame_rc", NULL, 0);

        menubar = CreateMenuBar(nonl_panel, "nonlMenuBar", NULL);
        
        menupane = CreateMenu(menubar, "nonlFileMenu", "File", 'F', NULL, NULL);
        CreateMenuButton(menupane, "open", "Open...", 'O',
            (XtCallbackProc) create_openfit_popup, (XtPointer) NULL, NULL);
        CreateMenuButton(menupane, "save", "Save...", 'S',
            (XtCallbackProc) create_savefit_popup, (XtPointer) NULL, NULL);
        CreateMenuSeparator(menupane, "sep1");
        CreateMenuButton(menupane, "close", "Close", 'C',
    	    (XtCallbackProc) destroy_nonl_frame, (XtPointer) NONL_ACCEPT, NULL);

        menupane = CreateMenu(menubar, "nonlDataMenu", "Data", 'D', NULL, NULL);

        CreateMenuButton(menupane, "reset", "Reset", 'R',
    	    (XtCallbackProc) reset_nonl_frame, (XtPointer) NULL, 0);
        CreateMenuButton(menupane, "update", "Update", 'U',
    	    (XtCallbackProc) update_nonl_frame, (XtPointer) NULL, 0);

        menupane = CreateMenu(menubar, "nonlOptionsMenu", "Options", 'O', NULL, NULL);
   
        submenupane = CreateMenu(menupane, "nonlLoadMenu", 
    				"Load", 'L', NULL, NULL);
    
        nonl_load_item[0] = CreateMenuToggle(submenupane, "values", "Fitted values", 'v',
	    (XtCallbackProc) do_nonl_toggle, (XtPointer) 0, NULL);
        nonl_load_item[1] = CreateMenuToggle(submenupane, "residuals", "Residuals", 'R',
	    (XtCallbackProc) do_nonl_toggle, (XtPointer) 1, NULL);
        nonl_load_item[2] = CreateMenuToggle(submenupane, "function", "Function", 'F',
	    (XtCallbackProc) do_nonl_toggle, (XtPointer) 2, NULL);

        nonl_autol_item = CreateMenuToggle(menupane, "autoload", "Autoload", 'A',
	    (XtCallbackProc) NULL, (XtPointer) NULL, NULL);

        menupane = CreateMenu(menubar, "nonlHelpMenu", "Help", 'H', &cascade, NULL);
        XtVaSetValues(menubar, XmNmenuHelpWidget, cascade, NULL);

        CreateMenuButton(menupane, "onFit", "On fit", 'f',
            (XtCallbackProc) HelpCB, (XtPointer) "trans.html#nlcurve", 0);

        CreateMenuButton(menupane, "onContext", "On context", 'x',
            (XtCallbackProc) ContextHelpCB, (XtPointer) NULL, 0);
        
        XtManageChild(menubar);
	XtVaSetValues(menubar,
		      XmNtopAttachment, XmATTACH_FORM,
		      XmNleftAttachment, XmATTACH_FORM,
		      XmNrightAttachment, XmATTACH_FORM,
		      NULL);
        
        fr1 = XmCreateFrame(nonl_panel, "nonl_frame", NULL, 0);
        nonl_set_item  = CreateSetSelector(fr1, "Apply to set:",
                                    SET_SELECT_ACTIVE,
                                    FILTER_SELECT_NONE,
                                    GRAPH_SELECT_CURRENT,
                                    SELECTION_TYPE_SINGLE);
	
	XtManageChild(fr1);
	XtVaSetValues(fr1,
		      XmNtopAttachment, XmATTACH_WIDGET,
		      XmNtopWidget, menubar,
		      XmNleftAttachment, XmATTACH_FORM,
		      XmNrightAttachment, XmATTACH_FORM,
		      NULL);
		      
	fr = XmCreateFrame(nonl_panel, "nonl_frame", NULL, 0);
	rc = XmCreateRowColumn(fr, "nonl_rc", NULL, 0);
	
	title_fr = XmCreateFrame(rc, "nonl_title_frame", NULL, 0);
	XtVaSetValues(title_fr, XmNshadowType, XmSHADOW_ETCHED_OUT, NULL);
	nonl_title_item = XmCreateLabel(title_fr, nonl_opts.title, NULL, 0);
    	XtManageChild(nonl_title_item);
	XtManageChild(title_fr);
    	
	nonl_formula_item = (Widget) CreateTextItem2(rc, 35, "Formula:");
	rc1 = XmCreateRowColumn(rc, "nonl_rc", NULL, 0);
	XtVaSetValues(rc1, XmNorientation, XmHORIZONTAL, NULL);
	
	nonl_nparm_item = CreatePanelChoice(rc1,
				   "Number of parameters:",
				   12,
				   "0",
				   "1",
				   "2",
				   "3",
				   "4",
				   "5",
				   "6",
				   "7",
				   "8",
				   "9",
				  "10",
				   NULL, NULL);

	for (i = 0; i < MAXPARM + 1; i++) {
	    XtAddCallback(nonl_nparm_item[2 + i], XmNactivateCallback,
			(XtCallbackProc) do_nparm_toggle, (XtPointer) i);
	}
	
	nonl_tol_item = CreateTextItem2(rc1, 10, "Tolerance:");
	
	XtManageChild(rc1);
	
	sw = XtVaCreateManagedWidget("sw",
				     xmScrolledWindowWidgetClass, rc,
				     XmNheight, 180,
				     XmNscrollingPolicy, XmAUTOMATIC,
				     NULL);

	rc2 = XmCreateRowColumn(sw, "rc2", NULL, 0);


	for (i = 0; i < MAXPARM; i++) {
	    nonl_parm_item[i] = XmCreateRowColumn(rc2, "rc1", NULL, 0);
	    XtVaSetValues(nonl_parm_item[i], XmNorientation, XmHORIZONTAL, NULL);
	    sprintf(buf, "A%1d: ", i);
	    nonl_value_item[i] = CreateTextItem2(nonl_parm_item[i], 10, buf);

	    nonl_constr_item[i] = XmCreateToggleButton(nonl_parm_item[i], "Bounds:", NULL, 0);
	    XtAddCallback(nonl_constr_item[i], XmNvalueChangedCallback, 
	    	    	    (XtCallbackProc) do_constr_toggle, (XtPointer) i);
	    XtManageChild(nonl_constr_item[i]);

	    nonl_lowb_item[i] = CreateTextItem2(nonl_parm_item[i], 6, "");
	    
	    sprintf(buf, "< A%1d < ", i);
	    lab = XmCreateLabel(nonl_parm_item[i], buf, NULL, 0);
    	    XtManageChild(lab);

	    nonl_uppb_item[i] = CreateTextItem2(nonl_parm_item[i], 6, "");
	    XtManageChild(nonl_parm_item[i]);
	}

	XtManageChild(rc2);
	XtManageChild(rc);
	XtManageChild(fr);

        XtVaSetValues(fr,
                      XmNtopAttachment, XmATTACH_WIDGET,
                      XmNtopWidget, fr1,
                      XmNleftAttachment, XmATTACH_FORM,
                      XmNrightAttachment, XmATTACH_FORM,
                      NULL);
                      
	fr3 = XmCreateFrame(nonl_panel, "nonl_frame", NULL, 0);
	rc3 = XmCreateRowColumn(fr3, "rc3", NULL, 0);
	
	CreateCommandButtons(rc3, 4, fitbut, fitlabel);
	XtAddCallback(fitbut[0], XmNactivateCallback,
	     		   (XtCallbackProc) do_nonl_proc, (XtPointer)   (0));
	XtAddCallback(fitbut[1], XmNactivateCallback,
	     		   (XtCallbackProc) do_nonl_proc, (XtPointer)   (5));
	XtAddCallback(fitbut[2], XmNactivateCallback,
	     		   (XtCallbackProc) do_nonl_proc, (XtPointer)  (20));	     		   
	XtAddCallback(fitbut[3], XmNactivateCallback,
	     		   (XtCallbackProc) do_nonl_proc, (XtPointer) (100));
	
	XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, rc3, NULL);	
	
	nonl_fload_rc = XmCreateRowColumn(rc3, "nonl_fload_rc", NULL, 0);
	XtVaSetValues(nonl_fload_rc, XmNorientation, XmHORIZONTAL, NULL);
	nonl_start_item = CreateTextItem2(nonl_fload_rc, 6, "Start load at:");
	nonl_stop_item = CreateTextItem2(nonl_fload_rc, 6, "Stop load at:");
	nonl_npts_item = CreateTextItem2(nonl_fload_rc, 4, "# of points:");
	XtManageChild(nonl_fload_rc);
	XtSetSensitive(nonl_fload_rc, False);

	CreateCommandButtons(rc3, 2, but1, blabel);
	XtAddCallback(but1[0], XmNactivateCallback,
		(XtCallbackProc) destroy_nonl_frame, (XtPointer) NONL_ACCEPT);
	XtAddCallback(but1[1], XmNactivateCallback,
		(XtCallbackProc) destroy_nonl_frame, (XtPointer) NONL_CANCEL);

	XtManageChild(rc3);
	XtManageChild(fr3);
	XtVaSetValues(fr3,
	              XmNtopAttachment, XmATTACH_WIDGET,
                      XmNtopWidget, fr,
		      XmNleftAttachment, XmATTACH_FORM,
		      XmNrightAttachment, XmATTACH_FORM,
		      XmNbottomAttachment, XmATTACH_FORM,
		      NULL);

	XtManageChild(nonl_panel);
    }
    update_nonl_frame();
    
    XtRaise(nonl_frame);
    
    unset_wait_cursor();
}
Ejemplo n.º 7
0
int WNavMotif::confirm_dialog( char *title, char *text, int display_cancel,
                               int *cancel)
{
    Widget 	dialog;
    XmString	text_str;
    XmString	title_str;
    XmString	no_str;
    XmString	yes_str;
    XmString	cancel_str;
    Arg		args[14];
    int		i;
    XEvent 	Event;

    text_str = XmStringCreateLocalized( wnav_dialog_convert_text(text));
    title_str = XmStringCreateLocalized( title);
    no_str = XmStringCreateLocalized( (char*) "No");
    yes_str = XmStringCreateLocalized( (char*) "Yes");
    cancel_str = XmStringCreateLocalized( (char*) "Cancel");
    i = 0;
    XtSetArg( args[i], XmNmessageString, text_str);
    i++;
    XtSetArg( args[i], XmNdialogTitle, title_str);
    i++;
    XtSetArg( args[i], XmNcancelLabelString, no_str);
    i++;
    XtSetArg( args[i], XmNokLabelString, yes_str);
    i++;
    XtSetArg( args[i], XmNhelpLabelString, cancel_str);
    i++;
    XtSetArg( args[i], XmNdialogType, XmDIALOG_WARNING);
    i++;
    if ( dialog_width && dialog_height)
    {
        XtSetArg( args[i], XmNwidth, dialog_width);
        i++;
        XtSetArg( args[i], XmNheight, dialog_height);
        i++;
        XtSetArg( args[i], XmNx, dialog_x);
        i++;
        XtSetArg( args[i], XmNy, dialog_y);
        i++;
    }

    dialog = XmCreateInformationDialog( parent_wid, (char*) "Info", args, i);
    XmStringFree( text_str);
    XmStringFree( title_str);
    XmStringFree( no_str);
    XmStringFree( yes_str);
    XmStringFree( cancel_str);

    if ( !display_cancel)
        XtUnmanageChild( XmMessageBoxGetChild( dialog, XmDIALOG_HELP_BUTTON));

    XtAddCallback( dialog, XmNokCallback, wnav_message_dialog_ok, this);
    XtAddCallback( dialog, XmNcancelCallback, wnav_message_dialog_cancel, this);
    XtAddCallback( dialog, XmNhelpCallback, wnav_message_dialog_help, this);

    // Connect the window manager close-button to exit
    if ( !display_cancel)
        flow_AddCloseVMProtocolCb( XtParent(dialog),
                                   (XtCallbackProc)wnav_message_dialog_cancel, this);
    else
        flow_AddCloseVMProtocolCb( XtParent(dialog),
                                   (XtCallbackProc)wnav_message_dialog_help, this);

    XtManageChild( dialog);
    XtPopup( XtParent(dialog), XtGrabNone);

    dialog_ok = 0;
    dialog_cancel = 0;
    dialog_help = 0;

    for (;;)
    {
        XtAppNextEvent( XtWidgetToApplicationContext( dialog), &Event);
        XtDispatchEvent( &Event);
        if ( dialog_ok)
        {
            if ( display_cancel)
                *cancel = 0;
            return 1;
        }
        if ( dialog_cancel)
        {
            if ( display_cancel)
                *cancel = 0;
            return 0;
        }
        if ( dialog_help)
        {
            *cancel = 1;
            XtDestroyWidget( dialog);
            return 0;
        }
    }
}
Ejemplo n.º 8
0
void SymbolsCallback(Widget shell, void *userData)
{
  int n;
  Arg arg[10];
  Widget pane, w, subpane;
  char *textspit[]={
    "AND", "(AND ",
    "OR", "(OR ",
    "NOT", "(NOT ",
    "EXCEPT", "(EXCEPT ",
    ")", ")",
    NULL
  };
  char **p;

  pane = XmCreateForm(shell, "symbolsPane", NULL, 0);
  
  n = 0;
  XtSetArg(arg[n], XmNleftAttachment, XmATTACH_FORM); n++;
  XtSetArg(arg[n], XmNrightAttachment, XmATTACH_FORM); n++;
  XtSetArg(arg[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  XtSetArg(arg[n], XmNtraversalOn, FALSE); n++;
  w = XmCreatePushButton(pane, "applyButton", arg, n);
  XtAddCallback(w, XmNactivateCallback, (XtCallbackProc)Apply, NULL);
  XtManageChild(w);

  n = 0;
  XtSetArg(arg[n], XmNleftAttachment, XmATTACH_FORM); n++;
  XtSetArg(arg[n], XmNrightAttachment, XmATTACH_FORM); n++;
  XtSetArg(arg[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
  XtSetArg(arg[n], XmNbottomWidget, w); n++;
  XtSetArg(arg[n], XmNtraversalOn, FALSE); n++;
  w = XmCreatePushButton(pane, "clearButton", arg, n);
  XtAddCallback(w, XmNactivateCallback, (XtCallbackProc)ClearText, NULL);
  XtManageChild(w);

  n = 0;
  XtSetArg(arg[n], XmNleftAttachment, XmATTACH_FORM); n++;
  XtSetArg(arg[n], XmNrightAttachment, XmATTACH_FORM); n++;
  XtSetArg(arg[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
  XtSetArg(arg[n], XmNbottomWidget, w); n++;
  XtSetArg(arg[n], XmNorientation, XmHORIZONTAL); n++;
  subpane = XmCreateRowColumn(pane, "symbolsRowCol", arg, n);

  /* text spitters */
  n = 0;
  XtSetArg(arg[n], XmNtraversalOn, FALSE); n++;
  for(p=textspit;*p;p+=2) {
    w = XmCreatePushButton(subpane, p[0], arg, n);
    XtAddCallback(w, XmNactivateCallback, (XtCallbackProc)SpitText, p[1]);
    XtManageChild(w);
  }
  w = XmCreatePushButton(subpane, ")*", arg, n);
  XtAddCallback(w, XmNactivateCallback, (XtCallbackProc)CloseAll, NULL);
  XtManageChild(w);
  XtManageChild(subpane);

  if(symbolML) XtpmFreeML(symbolML);
  symbolML = XtpmCreateML(pane, "symbolML", 2, SymbolCallback, NULL);
  XtVaSetValues(symbolML->pane,
		XmNleftAttachment, XmATTACH_FORM,
		XmNrightAttachment, XmATTACH_FORM,
		XmNtopAttachment, XmATTACH_FORM,
		XmNbottomAttachment, XmATTACH_WIDGET,
		XmNbottomWidget, subpane,
		NULL);

  XtManageChild(pane);
}
Ejemplo n.º 9
0
/*+++++++++++++++++++++++++++++++++++++++*/
static Widget 
BuildI18nDlg(
      Widget shell )
{
    register int     i, n;
    Arg              args[MAX_ARGS];
    XmString         button_string[NUM_LABELS]; 
    XmString         string; 
    Widget           form;
    Widget           inputMethodForm;
    Widget           imStartModeForm;
    Widget           preeditTypeForm;
    int              count = 0;
    Widget           widgetList1[6];

    /* get i18n resource values  */

    /* Set up DialogBoxDialog button labels */
    button_string[0] = CMPSTR((String) _DtOkString);
    button_string[1] = CMPSTR((String) _DtCancelString);
    button_string[2] = CMPSTR((String) _DtHelpString);

    /* Create toplevel DialogBox */

    /* Initialize the i18n structure */
    i18n.pictLabel = NULL;
    i18n.systemDefault = NULL;
    i18n.inputMethodTB = NULL;
    i18n.serverHostLabel = NULL;
    i18n.serverHostCB = NULL;
    i18n.inputMethodLabel = NULL;
    i18n.inputMethodRC = NULL;
    i18n.imStartModeTB = NULL;
    i18n.imStartModeRC = NULL;
    i18n.askAtLoginTG = NULL;
    i18n.resumeCurrentImTG = NULL;
    i18n.preeditTypeTB = NULL;
    i18n.preeditTypeList = NULL;
    i18n.buttonMoveUp = NULL;
    i18n.buttonMoveDown = NULL;
    i18n.warnDialog = NULL;

    /* saveRestore
     * Note that save.poscnt has been initialized elsewhere.  
     * save.posArgs may contain information from restoreBeep().*/

    XtSetArg(save.posArgs[save.poscnt], XmNbuttonCount, NUM_LABELS);  
    save.poscnt++;
    XtSetArg(save.posArgs[save.poscnt], XmNbuttonLabelStrings, button_string);
    save.poscnt++;
    XtSetArg(save.posArgs[save.poscnt], XmNdefaultPosition, False);
    save.poscnt++;
    style.i18nDialog = 
        __DtCreateDialogBoxDialog(shell, "i18nDialog", save.posArgs, 
				  save.poscnt);
    XtAddCallback(style.i18nDialog, XmNhelpCallback,
            (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_I18N_DIALOG);

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

    widgetList1[0] = _DtDialogBoxGetButton(style.i18nDialog,2);
    n=0;
    XtSetArg(args[n], XmNautoUnmanage, False); n++;
    XtSetArg(args[n], XmNcancelButton, widgetList1[0]); n++;
    XtSetValues (style.i18nDialog, args, n);

    n=0;
    XtSetArg(args[n], XmNtitle, 
	 ((char *)GETMESSAGE(19, 1, "Style Manager - Internationalization")));
    n++;
    XtSetArg (args[n], XmNuseAsyncGeometry, True); n++;
    XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC); n++;
    XtSetValues (XtParent(style.i18nDialog), args, n);

    n = 0;
    XtSetArg(args[n], XmNallowOverlap, False); n++;
    XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
    form = XmCreateForm(style.i18nDialog, "i18nForm", args, n);

    n = 0;
    XtSetArg(args[n], XmNfillMode, XmFILL_SELF); n++;
    XtSetArg(args[n], XmNbehavior, XmICON_LABEL); n++;
    XtSetArg(args[n], XmNpixmapForeground, style.secBSCol); n++;
    XtSetArg(args[n], XmNpixmapBackground, style.secTSCol); n++;
    XtSetArg(args[n], XmNstring, NULL); n++;  
    XtSetArg(args[n], XmNshadowThickness, 0); n++;  
    XtSetArg(args[n], XmNimageName, I18N_ICON); n++;  
    XtSetArg(args[n], XmNtraversalOn, False); n++;  
    widgetList1[count++] = i18n.pictLabel =
	_DtCreateIcon(form, "i18npictLabel", args, n);

    n = 0;
    XtSetArg(args[n], XmNmarginHeight, LB_MARGIN_HEIGHT);  n++;
    XtSetArg(args[n], XmNmarginWidth, LB_MARGIN_WIDTH);  n++;
    string = CMPSTR(((char *)GETMESSAGE(19, 2, "Default")));
    XtSetArg(args[n], XmNlabelString, string); n++;
    widgetList1[count++] = i18n.systemDefault = 
        XmCreatePushButtonGadget(form, "systemDefault", args, n);
    XmStringFree(string);

    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 3, "Input Method"));
    XtSetArg(args[n], XmNtitleString, string);  n++;
    widgetList1[count++] = i18n.inputMethodTB =
        _DtCreateTitleBox(form, "inputMethodTB", args, n);
    XmStringFree(string);
    
    n = 0;
    XtSetArg(args[n], XmNallowOverlap, False); n++;
    XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
    inputMethodForm = 
        XmCreateForm(i18n.inputMethodTB, "inputMethodForm", args, n);

    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 4, "Input Method Start Mode"));
    XtSetArg(args[n], XmNtitleString, string);  n++;
    widgetList1[count++] = i18n.imStartModeTB =
        _DtCreateTitleBox(form, "imStartModeTB", args, n);
    XmStringFree(string);

    n = 0;
    XtSetArg(args[n], XmNallowOverlap, False); n++;
    XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
    imStartModeForm = 
        XmCreateForm(i18n.imStartModeTB, "imStartModeForm", args, n);

    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 5, "Preedit Type"));
    XtSetArg(args[n], XmNtitleString, string);  n++;
    widgetList1[count++] = i18n.preeditTypeTB =
        _DtCreateTitleBox(form, "preeditTypeTB", args, n);
    XmStringFree(string);

    n = 0;
    XtSetArg(args[n], XmNallowOverlap, False); n++;
    XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
    preeditTypeForm = 
        XmCreateForm(i18n.preeditTypeTB, "preeditTypeForm", args, n);

    /* Create widgets inside the inputMethodForm */
    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 6, "Server Host :"));
    XtSetArg(args[n], XmNlabelString, string); n++;
    i18n.serverHostLabel = 
	XmCreateLabelGadget(inputMethodForm, "serverHostLabel", args, n);

    n = 0;
    XtSetArg(args[n], XmNcomboBoxType, XmDROP_DOWN_COMBO_BOX); n++;
    i18n.serverHostCB =
  	(Widget) (intptr_t) XmCreateComboBox(inputMethodForm, "serverHostCB", args, n);

    XtAddCallback(XtNameToWidget(i18n.serverHostCB, "Text"),
		  XmNactivateCallback, ServerHostCB, NULL);
    XtAddCallback(XtNameToWidget(i18n.serverHostCB, "Text"),
		  XmNfocusCallback, TextFocusCB, NULL);
    XtAddCallback(XtNameToWidget(i18n.serverHostCB, "Text"),
		  XmNlosingFocusCallback, TextLosingFocusCB, NULL);
    

    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 7, "Input Method"));
    XtSetArg(args[n], XmNlabelString, string); n++;
    i18n.inputMethodLabel = 
	XmCreateLabelGadget(inputMethodForm, "inputMethodLabel", args, n);

    n = 0;
    XtSetArg(args[n], XmNmarginWidth, LB_MARGIN_WIDTH); n++;
    XtSetArg(args[n], XmNmarginHeight, LB_MARGIN_HEIGHT); n++;
    i18n.inputMethodRC = 
        XmCreateRadioBox(inputMethodForm, "inputMethodRC", args, n);


    /* Create widgets inside the imStartModeForm */
    n = 0;
    XtSetArg(args[n], XmNmarginWidth, 0); n++;
    XtSetArg(args[n], XmNmarginHeight, 0); n++;
    i18n.imStartModeRC = 
        XmCreateRadioBox(imStartModeForm, "imStartModeRC", args, n);

    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 8, "Ask at login"));
    XtSetArg(args[n], XmNlabelString, string); n++;
    i18n.askAtLoginTG = 
	XmCreateToggleButtonGadget(i18n.imStartModeRC, "askAtLoginTG", 
				   args, n);
    XmStringFree(string);

    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 9, "Resume Current Input Method"));
    XtSetArg(args[n], XmNlabelString, string); n++;
    i18n.resumeCurrentImTG = 
        XmCreateToggleButtonGadget(i18n.imStartModeRC, "resumeCurrentImTG", 
				   args, n);
    XmStringFree(string);

    /* Create widgets inside the preeditTypeForm */

    n = 0;
    XtSetArg(args[n], XmNselectionPolicy, XmBROWSE_SELECT); n++;
    i18n.preeditTypeList =
	(Widget) (intptr_t) XmCreateList(preeditTypeForm, "preeditTypeList", args, n);

    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 10, "Move Up"));
    XtSetArg(args[n], XmNlabelString, string); n++;
    XtSetArg(args[n], XmNsensitive, False); n++;
    i18n.buttonMoveUp =
	XmCreatePushButtonGadget(preeditTypeForm, "buttonMoveUp", args, n);
    XmStringFree(string);

    n = 0;
    string = CMPSTR((char *)GETMESSAGE(19, 11, "Move Down"));
    XtSetArg(args[n], XmNlabelString, string); n++;
    XtSetArg(args[n], XmNsensitive, False); n++;
    i18n.buttonMoveDown =
	XmCreatePushButtonGadget(preeditTypeForm, "buttonMoveDown", args, n);
    XmStringFree(string);

    XtAddCallback(style.i18nDialog, XmNmapCallback, FormLayoutCB, NULL);
    XtAddCallback(style.i18nDialog, XmNmapCallback, MapCB, shell);
    XtAddCallback(style.i18nDialog, XmNcallback, ButtonCB, NULL);
    XtAddCallback(i18n.systemDefault, XmNactivateCallback, 
		  SystemDefaultCB, NULL);
    XtAddCallback(i18n.preeditTypeList, XmNbrowseSelectionCallback, 
		  ListItemSelectCB, NULL);
    XtAddCallback(i18n.buttonMoveUp, XmNactivateCallback, 
		  MoveUpCB, NULL);
    XtAddCallback(i18n.buttonMoveDown, XmNactivateCallback, 
		  MoveDownCB, NULL);

    XtManageChild(form);
    XtManageChildren(widgetList1,count); 

    XtManageChild(inputMethodForm);
    XtManageChild(imStartModeForm);
    XtManageChild(preeditTypeForm);

    XtManageChild(i18n.serverHostLabel);
    XtManageChild(i18n.serverHostCB);
    XtManageChild(i18n.inputMethodLabel);
    XtManageChild(i18n.inputMethodRC);

    XtManageChild(i18n.imStartModeRC);
    XtManageChild(i18n.askAtLoginTG);
    XtManageChild(i18n.resumeCurrentImTG);

    XtManageChild(i18n.preeditTypeList);
    XtManageChild(i18n.buttonMoveUp);
    XtManageChild(i18n.buttonMoveDown);

    return(style.i18nDialog);
}
Ejemplo n.º 10
0
/*######################## popup_event_reason() #########################*/
void
popup_event_reason(int x_root, int y_root, int host_no)
{
   if (event_reason_shell != NULL)
   {
      destroy_event_reason();
   }

   if ((fsa[host_no].host_status & HOST_ERROR_ACKNOWLEDGED) ||
       (fsa[host_no].host_status & HOST_ERROR_OFFLINE) ||
       (fsa[host_no].host_status & HOST_ERROR_ACKNOWLEDGED_T) ||
       (fsa[host_no].host_status & HOST_ERROR_OFFLINE_T) ||
       ((fsa[host_no].host_status & HOST_ERROR_OFFLINE_STATIC) &&
        (fsa[host_no].error_counter > fsa[host_no].max_errors)))
   {
      char event_reason[MAX_USER_NAME_LENGTH + 2 + MAX_EVENT_REASON_LENGTH + 1];

      event_reason[0] = '\0';
      if (fsa[host_no].host_status & HOST_ERROR_OFFLINE_STATIC)
      {
         (void)strcpy(event_reason, STATIC_EVENT_REASON);
      }
      else
      {
         get_event_reason(event_reason, fsa[host_no].host_alias);
      }

      if (event_reason[0] != '\0')
      {
         Widget   event_reason_label,
                  form;
         XmString x_string;
         int      display_height,
                  display_width,
                  lines,
                  max_length,
                  over_hang,
                  str_length;
         char     *ptr;

         /* Lets determine how many lines we are able to display. */
         display_height = DisplayHeight(display, DefaultScreen(display));
         max_length = lines = 0;
         ptr = event_reason;

         while (*ptr != '\0')
         {
            str_length = 0;
            while ((*(ptr + str_length) != '\n') &&
                   (*(ptr + str_length) != '\0'))
            {
               str_length++;
            }
            if (*(ptr + str_length) == '\n')
            {
               str_length++;
            }
            lines++;
            if (str_length > max_length)
            {
               max_length = str_length;
            }
            ptr += str_length;
         }

         event_reason_shell = XtVaCreatePopupShell("event_reason_shell",
                                      topLevelShellWidgetClass, appshell,
                                      XtNoverrideRedirect,      True,
                                      XtNallowShellResize,      True,
                                      XtNmappedWhenManaged,     False,
                                      XtNsensitive,             True,
                                      XtNwidth,                 1,
                                      XtNheight,                1,
                                      XtNborderWidth,           0,
                                      NULL);
         XtManageChild(event_reason_shell);
         XtAddEventHandler(event_reason_shell,
                           ButtonPressMask | Button1MotionMask, False,
                           (XtEventHandler)er_input, NULL);
         form = XtVaCreateWidget("event_reason_box",
                                 xmFormWidgetClass, event_reason_shell, NULL);
         XtManageChild(form);

         display_width = DisplayWidth(display, DefaultScreen(display));
         over_hang = display_width - (x_root + (max_length * glyph_width));
         if (over_hang < 0)
         {
            x_root += over_hang;
         }
         over_hang = display_height - (y_root + (lines * glyph_height));
         if (over_hang < 0)
         {
            y_root += over_hang;
         }
         XMoveResizeWindow(display, XtWindow(event_reason_shell),
                           x_root, y_root, max_length * glyph_width,
                           lines * glyph_height);

         x_string = XmStringCreateLocalized(event_reason);
         event_reason_label = XtVaCreateWidget("event_reason_label",
                                     xmLabelWidgetClass, form,
                                     XmNfontList,        fontlist,
                                     XmNlabelString,     x_string,
                                     XtNbackground,      color_pool[WHITE],
                                     XtNforeground,      color_pool[BLACK],
                                     NULL);
         XtManageChild(event_reason_label);
         XmStringFree(x_string);
         XtAddEventHandler(event_reason_label,
                           ButtonPressMask | LeaveWindowMask, False,
                           (XtEventHandler)destroy_event_reason, NULL);
         XtPopup(event_reason_shell, XtGrabNone);
         XRaiseWindow(display, XtWindow(event_reason_shell));
      }
   }
   else
   {
      destroy_event_reason();
   }

   return;
}
Ejemplo n.º 11
0
/*
**  Functions to build and popup the postup reminder
*/
extern void
postup_show_proc(Calendar *c, CSA_reminder_reference *r) {
        int			start_hr, stop_hr;
	char			text[BUFSIZ];
	time_t			st, sp = 0;
	Lines			*lines, *l = NULL;
	Props			*p = (Props *)c->properties;
	Widget			pu_frame, pu_base_form, 
				pu_text_form, separator, 
				pu_form, button_form, pu_date,
				pu_range, pu_image, pu_close, line, last_line;
	Boolean			start_am, stop_am;
	XmString		xmstr;
	CSA_return_code		stat;
	DisplayType		dis_t = get_int_prop(p, CP_DEFAULTDISP);
	OrderingType		ord_t = get_int_prop(p, CP_DATEORDERING);
	SeparatorType		sep_t = get_int_prop(p, CP_DATESEPARATOR);
	Dtcm_appointment	*appt;
	char			*title;

	if (!c->postup)
		c->postup = XtAppCreateShell("calendar_postup", "Dtcm",
			xmDialogShellWidgetClass, c->xcontext->display,
			NULL, 0);

	/*
	**  Create the Motif objects
	*/
	title = XtNewString(catgets(c->DT_catd, 1, 839, "Calendar : Reminder"));
	pu_frame = XtVaCreatePopupShell("pu_frame",
		topLevelShellWidgetClass, c->postup,
		XmNtitle, title,
		XmNmwmFunctions, MWM_FUNC_MOVE | MWM_FUNC_CLOSE,
		XmNdeleteResponse,      XmDESTROY,
		NULL);
	XtFree(title);

	pu_base_form = XtVaCreateWidget("pu_base_form",
		xmFormWidgetClass, pu_frame,
		NULL);

	pu_text_form = XtVaCreateWidget("pu_test_form",
		xmFormWidgetClass, pu_base_form,
		XmNtopAttachment, XmATTACH_FORM,
		XmNleftAttachment, XmATTACH_FORM,
		XmNtopAttachment, XmATTACH_FORM,
		XmNleftOffset, 1,
		XmNrightOffset, 1,
		XmNtopOffset, 1,
		NULL);

	pu_image = XtVaCreateWidget("pu_image",
		xmLabelGadgetClass, pu_text_form,
		XmNleftAttachment, XmATTACH_FORM,
		XmNtopAttachment, XmATTACH_FORM,
		XmNtopOffset, 5,
		XmNlabelType, XmPIXMAP,
		XmNlabelPixmap, ((Props_pu *)c->properties_pu)->postup_pixmap,
		NULL);

	button_form = XtVaCreateWidget("pu_form",
		xmFormWidgetClass, pu_base_form,
		XmNbottomAttachment, XmATTACH_FORM,
		XmNbottomOffset, 2,
		XmNleftOffset, 1,
		XmNrightOffset, 1,
		XmNleftAttachment, XmATTACH_FORM,
		XmNrightAttachment, XmATTACH_FORM,
		XmNfractionBase, 3,
		NULL);

	xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 680, "Close"));
	pu_close = XtVaCreateManagedWidget("close", 
		xmPushButtonWidgetClass, button_form, 
                XmNtopAttachment, 	XmATTACH_FORM,
		XmNbottomAttachment, 	XmATTACH_FORM,
		XmNleftAttachment, 	XmATTACH_POSITION,
		XmNrightAttachment, 	XmATTACH_POSITION,
		XmNleftPosition,	1,
		XmNrightPosition,	2,
		XmNbottomOffset, 	1,
                XmNlabelString, 	xmstr,
                NULL);
	XmStringFree(xmstr);

	separator = XtVaCreateWidget("separator",
                xmSeparatorGadgetClass,
                pu_base_form,
                XmNleftAttachment,      XmATTACH_FORM,
                XmNrightAttachment,     XmATTACH_FORM,
                XmNbottomAttachment,   	XmATTACH_WIDGET,
                XmNbottomWidget,        button_form,
		XmNtopAttachment, XmATTACH_WIDGET,
		XmNtopWidget, pu_text_form,
		XmNtopOffset, 1,
                NULL);


	pu_form = XtVaCreateWidget("pu_form",
		xmFormWidgetClass, pu_text_form,
		XmNtopAttachment, XmATTACH_FORM,
		XmNtopOffset, 1,
		XmNleftAttachment, XmATTACH_WIDGET,
		XmNleftWidget, pu_image,
		XmNverticalSpacing, 10,
		NULL);

	pu_date = XtVaCreateWidget("pu_date",
		xmLabelGadgetClass, pu_form,
		XmNleftAttachment, XmATTACH_FORM,
		XmNtopAttachment, XmATTACH_FORM,
		NULL);

	pu_range = XtVaCreateWidget("pu_range",
		xmLabelGadgetClass, pu_form,
		XmNleftAttachment, XmATTACH_FORM,
		XmNtopAttachment, XmATTACH_WIDGET,
		XmNtopWidget, pu_date,
		XmNtopOffset, 8,
		NULL);

	XtAddCallback(pu_close, XmNactivateCallback, close_cb, pu_frame);

	appt = allocate_appt_struct(appt_read,
				    c->general->version,
				    CSA_ENTRY_ATTR_START_DATE_I,
				    CSA_ENTRY_ATTR_END_DATE_I,
				    CSA_ENTRY_ATTR_SUMMARY_I,
				    CSA_X_DT_ENTRY_ATTR_SHOWTIME_I,
				    NULL);
	stat = query_appt_struct(c->cal_handle, r->entry, appt);
	backend_err_msg(c->frame, c->calname, stat,
			((Props_pu *)c->properties_pu)->xm_error_pixmap);
	if (stat != CSA_SUCCESS) {
		free_appt_struct(&appt);
		return;
	}

	_csa_iso8601_to_tick(appt->time->value->item.date_time_value, &st);
	if (appt->end_time)
		_csa_iso8601_to_tick(appt->end_time->value->\
			item.date_time_value, &sp);
	l = lines = text_to_lines(appt->what->value->item.string_value, 5);
	last_line = 0;
	while (l) {
		xmstr = XmStringCreateLocalized(l->s);
		line = XtVaCreateWidget("text_line",
			xmLabelGadgetClass, pu_text_form,
			XmNlabelString, xmstr,
			XmNleftAttachment, XmATTACH_WIDGET,
			XmNleftWidget, pu_form,
			XmNleftOffset, 15,
			NULL);
		XmStringFree(xmstr);

		if (last_line)
			XtVaSetValues(line, 
				XmNtopAttachment, XmATTACH_WIDGET,
				XmNtopWidget, last_line,
				XmNtopOffset, 8,
				NULL);
		else
			XtVaSetValues(line, 
				XmNtopAttachment, XmATTACH_FORM,
				XmNtopOffset, 8,
				NULL);

		last_line = line;
		l = l->next;
	}
	if (lines)
		destroy_lines(lines);

	/*
	**  Now fill in the correct information
	*/
	set_date_in_widget(st, pu_date, ord_t, sep_t);

        if (!showtime_set(appt) || magic_time(st)) 
                text[0] = '\0';
	else {
		start_hr = hour(st);
		if (sp) stop_hr = hour(sp);
		if (dis_t == HOUR12) {
			start_am = adjust_hour(&start_hr);
			if (sp) {
				/* NL_COMMENT

				   Message 1087 : This message is used to form
				   the alarm string that appears in the
				   reminder popup.  In the C locale it would
				   look something like this:

				   ``From 11:00am to 1:00pm''

				   In the printf conversion string the $n are:

					$1 	-> start hour
					$2	-> start minute
					$3	-> am or pm
					$4	-> stop hour
					$5	-> stop minute
					$6	-> am or pm

				*/
			        char *am = XtNewString(catgets(c->DT_catd, 
							       1, 4, "am"));
			        char *pm = XtNewString(catgets(c->DT_catd, 
							       1, 3, "pm"));
				stop_am = adjust_hour(&stop_hr);
				sprintf(text, catgets(c->DT_catd, 1, 1087,
				   "From %1$2d:%2$02d%3$s to %4$2d:%5$02d%6$s"),
					start_hr, minute(st),
					(start_am) ? am : pm,
					stop_hr, minute(sp),
					(stop_am) ? am : pm
					);
				XtFree(am);
				XtFree(pm);
			} else {
				/* NL_COMMENT

				   Message 1088 : This message is used to form
				   the alarm string that appears in the
				   reminder popup.  It is used when an appt
				   does not have and ``end'' time.  In the 
				   C locale it would look something like this:

				   ``11:00am''

				   In the printf conversion string the $n are:

					$1 	-> start hour
					$2	-> start minute
					$3	-> am or pm

				*/
			        char *meridian = 
				  XtNewString ((start_am) ? 
					       catgets(c->DT_catd, 1, 4, "am"):
					       catgets(c->DT_catd, 1, 3, "pm"));
				
				sprintf(text, catgets(c->DT_catd, 1, 1088,
				   			"%1$2d:%2$02d%3$s"), 
					start_hr, minute(st), meridian
					);
				XtFree(meridian);
			}
		} else {
			if (sp) {
				/* NL_COMMENT

				   Message 1089 : This message is used to form
				   the alarm string that appears in the
				   reminder popup.  This string is used when
				   a user has asked that times be displayed
				   in 24 hour format.  In the C locale it 
				   would look something like this:

				   ``From 0100 to 1600''

				   In the printf conversion string the $n are:

					$1 	-> start hour
					$2	-> start minute
					$3	-> stop hour
					$4	-> stop minute

				*/
				sprintf(text, catgets(c->DT_catd, 1, 1089,
				   "From %1$02d%2$02d to %3$02d%4$02d"),
					start_hr, minute(st), stop_hr, 
					minute(sp));
			} else {
				/* NL_COMMENT

				   Message 1090 : This message is used to form
				   the alarm string that appears in the
				   reminder popup.  This string is used when
				   an appt does not have an end time and the
				   user has asked that times be displayed
				   in 24 hour format.  In the C locale it 
				   would look something like this:

				   ``1600''

				   In the printf conversion string the $n are:

					$1 	-> start hour
					$2	-> start minute

				*/
				sprintf(text, catgets(c->DT_catd, 1, 1090,
							"%1$02d%2$02d"), 
					start_hr, minute(st));
			}
		}
	}

	free_appt_struct(&appt);
	xmstr = XmStringCreateLocalized(text);
	XtVaSetValues(pu_range, XmNlabelString, xmstr,
		NULL);
	XmStringFree(xmstr);

	ManageChildren(pu_form);
	ManageChildren(pu_base_form);
	ManageChildren(pu_text_form);
	XtManageChild(pu_base_form);
	XtVaSetValues(button_form, XmNdefaultButton, pu_close, NULL);
        XtVaSetValues(button_form, XmNcancelButton, pu_close, NULL);
	XtPopup(pu_frame, XtGrabNone);
	DtWsmOccupyAllWorkspaces(c->xcontext->display, XtWindow(pu_frame));
}
Ejemplo n.º 12
0
int
main(int argc, char **argv)
{
    XtAppContext theApp;
    Widget shell, toplevel, menubar, filepane;
    Widget button, button1, button2, sep;
    Widget saveAsPane, button3, button4, button5;
    Widget button6, button7, editpane;
    Widget mb, com;
    Widget one, two, three;
    XmString xmstr;

    shell = XtVaAppInitialize(&theApp, "mainW", NULL, 0,
				 &argc, argv, NULL, NULL);

    toplevel = XmCreateMainWindow(shell, "MainWindow", NULL, 0);
    XtManageChild(toplevel);

    menubar = XmCreateMenuBar(toplevel,
			      "menuBar",
			      NULL,0);
    XtManageChild(menubar);

    filepane = XmCreatePulldownMenu(menubar,
				    "pane",
				    NULL,0);

    xmstr = XmStringCreateSimple("File");
    
    button = XtVaCreateManagedWidget("File",
				     xmCascadeButtonWidgetClass,
				     menubar,
				     XmNsubMenuId, filepane,
                                     XmNlabelString, xmstr,
				     NULL);

    editpane = XmCreatePulldownMenu(menubar,
				    "pane2",
				    NULL, 0);

    button6 = XtVaCreateManagedWidget("Edit",
				      xmCascadeButtonGadgetClass,
				      menubar,
				      XmNsubMenuId, editpane,
				      NULL);

    button7 = XtVaCreateManagedWidget("Cut",
				      xmPushButtonGadgetClass,
				      editpane,
				      NULL);

    button1 = XtVaCreateManagedWidget("Open",
				      xmPushButtonGadgetClass,
				      filepane,
				      NULL);

    sep = XtVaCreateManagedWidget("sep",
				  xmSeparatorGadgetClass,
                                  filepane,
                                  NULL);

    button2 = XtVaCreateManagedWidget("Close",
				      xmPushButtonWidgetClass,
				      filepane,
				      NULL);

    saveAsPane = XmCreatePulldownMenu(filepane,
				      "save_as",
				      NULL, 0);

    button3 = XtVaCreateManagedWidget("Save As",
				      xmCascadeButtonWidgetClass,
				      filepane,
				      XmNsubMenuId, saveAsPane,
				      NULL);

    button4 = XtVaCreateManagedWidget("MS Word",
				      xmPushButtonWidgetClass,
				      saveAsPane,
				      NULL);

    button5 = XtVaCreateManagedWidget("LaTeX",
				      xmPushButtonWidgetClass,
				      saveAsPane,
				      NULL);

    mb = XtVaCreateManagedWidget("mb", xmMessageBoxWidgetClass, toplevel, NULL);
    XtVaSetValues(toplevel, XmNmessageWindow, mb, NULL);

    com = XtVaCreateManagedWidget("com", xmCommandWidgetClass, toplevel, NULL);

    one = XtVaCreateManagedWidget("form", xmFormWidgetClass, toplevel,
				  NULL);

    two = XtVaCreateManagedWidget("two", xmPushButtonWidgetClass, one,
				  XmNtopAttachment, XmATTACH_FORM,
				  XmNbottomAttachment, XmATTACH_FORM,
				  XmNleftAttachment, XmATTACH_NONE,
				  XmNrightAttachment, XmATTACH_FORM,
				  NULL);

    three = XtVaCreateManagedWidget("three", xmPushButtonWidgetClass, one,
				    XmNtopAttachment, XmATTACH_FORM,
				    XmNbottomAttachment, XmATTACH_FORM,
				    XmNleftAttachment, XmATTACH_FORM,
				    XmNrightAttachment, XmATTACH_WIDGET,
				    XmNrightWidget, two,
				    NULL);

    XmMainWindowSetAreas(toplevel, menubar, com, NULL, NULL, one);

    XtRealizeWidget(shell);

/* toplevel should be replaced with to correct applicationShell */

{
    static XtWidgetGeometry Expected[] = {
   CWWidth | CWHeight            ,  508,  524,  212,  356, 0,0,0, /* MainWindow */
   CWWidth | CWHeight | CWX | CWY,    0,    0,  212,   31, 0,0,0, /* menuBar */
   CWWidth | CWHeight | CWX | CWY,    5,    5,   40,   21, 0,0,0, /* File */
   CWWidth | CWHeight | CWX | CWY,   45,    5,   40,   21, 0,0,0, /* Edit */
   CWWidth | CWHeight | CWX | CWY,    0,  269,  212,   87, 0,0,0, /* mb */
   CWWidth | CWHeight | CWX | CWY,    0,    0,    4,    4, 0,0,0, /* Symbol */
   CWWidth | CWHeight | CWX | CWY,   10,   10,  192,    4, 0,0,0, /* Message */
   CWWidth | CWHeight | CWX | CWY,    0,   24,  212,    2, 0,0,0, /* Separator */
   CWWidth | CWHeight | CWX | CWY,   10,   36,   64,   41, 0,0,0, /* OK */
   CWWidth | CWHeight | CWX | CWY,   74,   36,   64,   41, 0,0,0, /* Cancel */
   CWWidth | CWHeight | CWX | CWY,  138,   36,   64,   41, 0,0,0, /* Help */
   CWWidth | CWHeight | CWX | CWY,    0,   31,  212,  213, 0,0,0, /* com */
   CWWidth | CWHeight | CWX | CWY,   10,   10,  192,  135, 0,0,0, /* ItemsListSW */
   CWWidth | CWHeight | CWX | CWY,    0,    0,  192,  135, 0,0,0, /* ItemsList */
   CWWidth | CWHeight | CWX | CWY,   10,  155,  192,   17, 0,0,0, /* Selection */
   CWWidth | CWHeight | CWX | CWY,   10,  172,  192,   31, 0,0,0, /* Text */
   CWWidth | CWHeight | CWX | CWY,    0,  244,  212,   25, 0,0,0, /* form */
   CWWidth | CWHeight | CWX | CWY,  182,    0,   30,   25, 0,0,0, /* two */
   CWWidth | CWHeight | CWX | CWY,    0,    0,  182,   25, 0,0,0, /* three */ 
    };
    PrintDetails(shell,Expected);
};
  LessTifTestMainLoop(shell);

    exit(0);
}
Ejemplo n.º 13
0
char    *FontSel(Widget parent, int showPropFonts, const char *currFont,
            Pixel sampleFG, Pixel sampleBG)
{
    Widget          dialog, form, okButton, cancelButton;
    Widget          styleList, sizeList, fontName, fontList;
    Widget          sizeToggle, propFontToggle = NULL, dispField;
    Widget          nameLabel, sampleLabel;
    Arg             args[MAX_ARGS];
    int             n;
    XmString        tempStr;
    char            bigFont[MAX_FONT_NAME_LEN];
    xfselControlBlkType ctrlBlk;
    Display         *theDisplay;

    ctrlBlk.fontData    = XListFonts(XtDisplay(parent), 
                                     "-*-*-*-*-*-*-*-*-*-*-*-*-*-*", 
                                     MAX_NUM_FONTS, &ctrlBlk.numFonts);
    FindBigFont(&ctrlBlk, bigFont);
    ctrlBlk.oldFont = XLoadQueryFont(XtDisplay(parent), bigFont);
    ctrlBlk.oldFontList = XmFontListCreate(ctrlBlk.oldFont,
                                            XmSTRING_DEFAULT_CHARSET);
    ctrlBlk.sampleFG = sampleFG;
    ctrlBlk.sampleBG = sampleBG;

    dialog  = CreateDialogShell(parent, "Font Selector", args, 0);

    /*  Set up window sizes for form widget */

    n = 0;
    XtSetArg(args[n], XmNautoUnmanage, FALSE); n++;
    XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;

    /*  Create form popup dialog widget */

    form    = XtCreateWidget ("Font Selector", xmFormWidgetClass, dialog, 
                              args, n);

    /*  Create pushbutton widgets */

    n = 0;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
    XtSetArg(args[n], XmNbottomOffset, 4); n++;
    XtSetArg(args[n], XmNtopOffset, 1); n++;
    XtSetArg(args[n], XmNrightPosition, 45); n++;
    XtSetArg(args[n], XmNwidth, 110); n++;
    XtSetArg(args[n], XmNheight, 28); n++;
    XtSetArg(args[n], XmNshowAsDefault, TRUE); n++;
    okButton = XtCreateManagedWidget("OK", xmPushButtonWidgetClass, form,
                                      args, n);

    n = 0;
    XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
    XtSetArg(args[n], XmNtopWidget, okButton); n++;
    XtSetArg(args[n], XmNbottomWidget, okButton); n++;
    XtSetArg(args[n], XmNleftPosition, 55); n++;
    XtSetArg(args[n], XmNwidth, 110); n++;
    XtSetArg(args[n], XmNheight, 28); n++;
    cancelButton = XtCreateManagedWidget("Cancel", xmPushButtonWidgetClass,
                                         form, args, n);

    /*  create font name text widget and the corresponding label */

    n = 0; 
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++; 
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++; 
    XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++; 
    XtSetArg(args[n], XmNbottomWidget, okButton); n++; 
    XtSetArg(args[n], XmNleftPosition, 1); n++; 
    XtSetArg(args[n], XmNrightPosition, 99); n++; 
    XtSetArg(args[n], XmNeditable, True); n++;
    XtSetArg(args[n], XmNeditMode, XmSINGLE_LINE_EDIT); n++;
    XtSetArg(args[n], XmNmaxLength, MAX_FONT_NAME_LEN); n++;
    fontName = XtCreateManagedWidget("fontname", xmTextWidgetClass, form,
                                     args, n);
    RemapDeleteKey(fontName);   /* kludge to handle delete and BS */

    n = 0; 
    tempStr = XmStringCreate("Font Name:", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, tempStr); n++;
    XtSetArg(args[n], XmNmnemonic, 'N'); n++;
    XtSetArg(args[n], XmNuserData, fontName); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++; 
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++; 
    XtSetArg(args[n], XmNleftWidget, fontName); n++; 
    XtSetArg(args[n], XmNbottomWidget, fontName); n++;
    XtSetArg(args[n], XmNtopOffset, 1); n++;
    nameLabel = XtCreateManagedWidget("Font Name:", xmLabelWidgetClass,
                                      form, args, n);
    XmStringFree(tempStr);

    /*  create sample display text field widget */

    n = 0;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++; 
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++; 
    XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++; 
    XtSetArg(args[n], XmNrightPosition, 99); n++;
    XtSetArg(args[n], XmNbottomWidget, nameLabel); n++;
    XtSetArg(args[n], XmNleftPosition, 1); n++; 
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
    XtSetArg(args[n], XmNvalue, 
            "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789");
            n++;
    XtSetArg(args[n], XmNforeground, sampleFG); n++;
    XtSetArg(args[n], XmNbackground, sampleBG); n++;
    dispField = XtCreateManagedWidget(" ", xmTextFieldWidgetClass, form, 
                                       args, n);

    n = 0; 
    tempStr = XmStringCreate("Sample:", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, tempStr); n++;
    XtSetArg(args[n], XmNmnemonic, 'S'); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++; 
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++; 
    XtSetArg(args[n], XmNleftWidget, dispField); n++; 
    XtSetArg(args[n], XmNbottomWidget, dispField); n++;
    XtSetArg(args[n], XmNtopOffset, 1); n++;
    sampleLabel = XtCreateManagedWidget("Font Name:", xmLabelWidgetClass,
            form, args, n);
    XmStringFree(tempStr);

    /*  create toggle buttons */

    n = 0; 
    tempStr = XmStringCreate("Show Size in Points", 
                              XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, tempStr); n++;
    XtSetArg(args[n], XmNmnemonic, 'P'); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++; 
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++; 
    XtSetArg(args[n], XmNleftPosition, 2); n++; 
    XtSetArg(args[n], XmNtopOffset, 1); n++;
    XtSetArg(args[n], XmNbottomWidget, sampleLabel); n++;
    sizeToggle = XtCreateManagedWidget("sizetoggle", 
                      xmToggleButtonWidgetClass, form, args, n);
    XmStringFree(tempStr);

    if (showPropFonts != ONLY_FIXED)
    {
        n = 0; 
        tempStr = XmStringCreate("Show Proportional Width Fonts", 
                                 XmSTRING_DEFAULT_CHARSET);
        XtSetArg(args[n], XmNlabelString, tempStr); n++;
        XtSetArg(args[n], XmNmnemonic, 'W'); n++;
        XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++; 
        XtSetArg(args[n], XmNtopAttachment, 
                        XmATTACH_OPPOSITE_WIDGET); n++; 
        XtSetArg(args[n], XmNbottomAttachment, 
                        XmATTACH_OPPOSITE_WIDGET); n++; 
        XtSetArg(args[n], XmNrightPosition, 98); n++; 
        XtSetArg(args[n], XmNtopWidget, sizeToggle); n++;
        XtSetArg(args[n], XmNbottomWidget, sizeToggle); n++;
        XtSetArg(args[n], XmNtopOffset, 1); n++;
        propFontToggle = XtCreateManagedWidget("propfonttoggle", 
                            xmToggleButtonWidgetClass, form, args, n);
        XmStringFree(tempStr);
    }

    /*  create scroll list widgets */
    /*  "Font" list */

    n = 0;
    tempStr = XmStringCreate("Font:", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, tempStr); n++;
    XtSetArg(args[n], XmNmnemonic, 'F'); n++; 
    XtSetArg(args[n], XmNtopOffset, 2); n++;
    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
    XtSetArg(args[n], XmNleftPosition, 1); n++;
    nameLabel = XtCreateManagedWidget("Font:", xmLabelWidgetClass, form, 
                                      args, n);
    XmStringFree(tempStr);

    n = 0;
    XtSetArg(args[n], XmNvisibleItemCount, 15); n++;
    XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
    XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
    XtSetArg(args[n], XmNbottomWidget, sizeToggle); n++;
    XtSetArg(args[n], XmNtopWidget, nameLabel); n++;
    XtSetArg(args[n], XmNleftWidget, nameLabel); n++;
    XtSetArg(args[n], XmNrightPosition, 52); n++;
    fontList = XmCreateScrolledList(form, "fontlist", args, n);
    AddMouseWheelSupport(fontList);
    XtManageChild(fontList);
    XtVaSetValues(nameLabel, XmNuserData, fontList, NULL);

    /* "Style" list */

    n = 0;
    XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
    XtSetArg(args[n], XmNtopWidget, nameLabel); n++;
    XtSetArg(args[n], XmNleftOffset, 5); n++;
    XtSetArg(args[n], XmNleftWidget, XtParent(fontList)); n++;
    XtSetArg(args[n], XmNbottomWidget, XtParent(fontList)); n++;
    XtSetArg(args[n], XmNrightPosition, 85); n++;
    styleList = XmCreateScrolledList(form, "stylelist", args, n);
    AddMouseWheelSupport(styleList);
    XtManageChild(styleList);

    n = 0;
    tempStr = XmStringCreate("Style:", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNmnemonic, 'y'); n++; 
    XtSetArg(args[n], XmNuserData, styleList); n++;
    XtSetArg(args[n], XmNlabelString, tempStr); n++;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
    XtSetArg(args[n], XmNbottomWidget, XtParent(styleList)); n++;
    XtSetArg(args[n], XmNleftWidget, XtParent(styleList)); n++;
    XtCreateManagedWidget("Style:", xmLabelWidgetClass, form, args, n);
    XmStringFree(tempStr);

    /*  "Size" list */

    n = 0;
    XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
    XtSetArg(args[n], XmNtopWidget, nameLabel); n++;
    XtSetArg(args[n], XmNleftWidget, XtParent(styleList)); n++;
    XtSetArg(args[n], XmNbottomWidget, XtParent(fontList)); n++;
    XtSetArg(args[n], XmNleftOffset, 5); n++;
    XtSetArg(args[n], XmNrightPosition, 99); n++;
    sizeList = XmCreateScrolledList(form, "sizelist", args, n);
    AddMouseWheelSupport(sizeList);
    XtManageChild(sizeList);

    n = 0;
    tempStr = XmStringCreate("Size:", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, tempStr); n++;
    XtSetArg(args[n], XmNmnemonic, 'z'); n++; 
    XtSetArg(args[n], XmNuserData, sizeList); n++;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
    XtSetArg(args[n], XmNbottomWidget, XtParent(sizeList)); n++;
    XtSetArg(args[n], XmNleftWidget, XtParent(sizeList)); n++;
    XtCreateManagedWidget("Size:", xmLabelWidgetClass, form, args, n);
    XmStringFree(tempStr);

    /*  update form widgets cancel button */

    n = 0;
    XtSetArg(args[n], XmNcancelButton, cancelButton); n++;
    XtSetValues(form, args, n);


    /*  update application's control block structure */

    ctrlBlk.form            = form;
    ctrlBlk.okButton        = okButton;
    ctrlBlk.cancelButton    = cancelButton;
    ctrlBlk.fontList        = fontList;
    ctrlBlk.styleList       = styleList;
    ctrlBlk.sizeList        = sizeList;
    ctrlBlk.fontNameField   = fontName;
    ctrlBlk.sizeToggle      = sizeToggle;
    if (showPropFonts != ONLY_FIXED)
        ctrlBlk.propFontToggle  = propFontToggle;
    ctrlBlk.dispField       = dispField;
    ctrlBlk.exitFlag        = FALSE;
    ctrlBlk.destroyedFlag   = FALSE;
    ctrlBlk.showPropFonts   = showPropFonts;
    ctrlBlk.showSizeInPixels = TRUE;
    ctrlBlk.sel1            = NULL;
    ctrlBlk.sel2            = NULL;
    ctrlBlk.sel3            = NULL;
    ctrlBlk.fontName        = NULL;

    setupScrollLists(NONE, ctrlBlk);    /* update scroll lists */ 

    if (showPropFonts == PREF_PROP)
        XmToggleButtonSetState(propFontToggle, TRUE, FALSE); 
        
    /*  Register callback functions */

    if (showPropFonts != ONLY_FIXED)
        XtAddCallback(propFontToggle, XmNvalueChangedCallback, 
                (XtCallbackProc)propFontToggleAction, (char *)&ctrlBlk);
    XtAddCallback(sizeToggle, XmNvalueChangedCallback,
            (XtCallbackProc)sizeToggleAction, (char *)&ctrlBlk);
    XtAddCallback(fontList, XmNbrowseSelectionCallback,
            (XtCallbackProc)fontAction, (char *)&ctrlBlk);
    XtAddCallback(styleList, XmNbrowseSelectionCallback,
            (XtCallbackProc)styleAction, (char *)&ctrlBlk);
    XtAddCallback(sizeList, XmNbrowseSelectionCallback,
            (XtCallbackProc)sizeAction, (char *)&ctrlBlk);
    XtAddCallback(okButton, XmNactivateCallback,
            (XtCallbackProc)okAction, (char *)&ctrlBlk);
    XtAddCallback(cancelButton, XmNactivateCallback,
            (XtCallbackProc)cancelAction, (char *)&ctrlBlk);

    /* add event handler to setup input focus at start to scroll list */

    XtAddEventHandler(fontList, FocusChangeMask, FALSE,
            (XtEventHandler)setFocus, (char *)&ctrlBlk);
    XmProcessTraversal(fontList, XmTRAVERSE_CURRENT);

    /*  setup tabgroups */

    XmAddTabGroup(fontList);
    XmAddTabGroup(styleList);
    XmAddTabGroup(sizeList);
    XmAddTabGroup(sizeToggle);
    if (showPropFonts != ONLY_FIXED)
        XmAddTabGroup(propFontToggle);
    XmAddTabGroup(fontName);
    XmAddTabGroup(okButton);
    XmAddTabGroup(cancelButton);

    /* Make sure that we don't try to access the dialog if the user
       destroyed it (possibly indirectly, by destroying the parent). */
    XtAddCallback(dialog, XmNdestroyCallback,
            (XtCallbackProc)destroyCB, (char *)&ctrlBlk);
        
    /*  Link Motif Close option to cancel action */

    AddMotifCloseCallback(dialog, (XtCallbackProc)cancelAction, &ctrlBlk);

    /*  Handle dialog mnemonics  */

    AddDialogMnemonicHandler(form, FALSE);

    /*  Realize Widgets  */

    ManageDialogCenteredOnPointer(form);

    /* set up current font parameters */

    if (currFont[0] != '\0')
        startupFont(&ctrlBlk, currFont); 

    /* Make sure that we can still access the display in case the form
       gets destroyed */
    theDisplay = XtDisplay(form);

    /*  enter event loop */

    while (! ctrlBlk.exitFlag && ! ctrlBlk.destroyedFlag)
        XtAppProcessEvent(XtWidgetToApplicationContext(form), XtIMAll);

    if (! ctrlBlk.destroyedFlag) {
        /* Don't let the callback destroy the font name */
        XtRemoveCallback(dialog, XmNdestroyCallback,
                (XtCallbackProc)destroyCB, (char *)&ctrlBlk);
        XtDestroyWidget(dialog);
    }

    if (ctrlBlk.oldFont != NULL)
    {
        XFreeFont(theDisplay, ctrlBlk.oldFont);
        XmFontListFree(ctrlBlk.oldFontList);
    }

    return(ctrlBlk.fontName);
}
Ejemplo n.º 14
0
void
SetGridOptionMenuButtons ( KeyListType *kl )
{
/*
 * Dynamically set option menus according to FDF parameter values.
 */
	GuiScalarGridDialogType	*grd;
	ModelInfoType		*mdl;

	char			*keylist;
	char			**vcoords, **vectorsym, **label_frequency,
				**linetype;
	int			nkeys;
	int			verbose;

	grd = GetGuiScalarGridDialog();
	mdl = GetGuiModelInfo();
	verbose = GetVerboseLevel();

	if( verbose > VERBOSE_0 )
	    printf ( "SetGridOptionMenuButtons\n" );

/*
 *	Set option menu button and text field for vertical coordinate.
 */
	keylist   = GetConfigValue( "vcoordkeys" );
	vcoords  = SplitByDelimeter ( keylist, ",", &nkeys );
	XmTextSetString ( GetModelVCoordHSW ( mdl ), GetModelVCoord ( mdl ) );
	XtUnmanageChild ( GetModelVCoordOmHSW ( grd ) );
	SetDefaultOptionButton ( GetModelVCoordOmHSW ( grd ),
				 nkeys, GetModelVCoord ( mdl ), vcoords,
				 &(grd->vcoordpm), "vcoordkeys" );
	XtManageChild ( GetModelVCoordOmHSW ( grd ) );
	Free ( keylist );
	StringListFree ( nkeys, vcoords );

/*
 *	Set option menu button for vector symbols.
 */
	keylist   = GetConfigValue( "vectorkeys" );
	vectorsym = SplitByDelimeter ( keylist, ",", &nkeys );
	XtUnmanageChild ( GetVectorSymbolOmHSW( grd ) );
	SetDefaultOptionButton ( GetVectorSymbolOmHSW( grd ),
				 nkeys, GetVectorSymbolHS ( grd ), vectorsym,
				 &(grd->vector_sym_pm), "vectorkeys" );
	XtManageChild ( GetVectorSymbolOmHSW( grd ) );
	Free ( keylist );
	StringListFree ( nkeys, vectorsym );

/*
 *	Set option menu button for line type.
 */
	keylist   = GetConfigValue( "linetypekeys" );
	linetype = SplitByDelimeter ( keylist, ",", &nkeys );
	XtUnmanageChild ( GetLineTypeOmHSW ( grd ) );
	SetDefaultOptionButton ( GetLineTypeOmHSW ( grd ),
				 nkeys, GetLineTypeHS ( grd ), linetype,
				 &(grd->line_type_pm), "linetypekeys" );
	XtManageChild ( GetLineTypeOmHSW ( grd ) );
	Free ( keylist );
	StringListFree ( nkeys, linetype );

/*
 *	Set option menu button for line label frequency.
 */
	keylist   = GetConfigValue( "labelfreqkeys" );
	label_frequency = SplitByDelimeter ( keylist, ",", &nkeys );
	XtUnmanageChild ( GetLabelFrequencyOmHSW ( grd ) );
	SetDefaultOptionButton ( GetLabelFrequencyOmHSW ( grd ),
				 nkeys, GetLabelFrequencyHS ( grd ),
                                 label_frequency, &(grd->label_freq_pm),
                                 "labelfreqkeys" );
	XtManageChild ( GetLabelFrequencyOmHSW ( grd ) );
	Free ( keylist );
	StringListFree ( nkeys, label_frequency );
}
Ejemplo n.º 15
0
static void
insert_layerview_buttons (Widget menu)
{
  int i, s;
  LayerButtons *lb;

  num_layer_buttons++;
  s = num_layer_buttons * sizeof (LayerButtons);
  if (layer_button_list)
    layer_button_list = (LayerButtons *) realloc (layer_button_list, s);
  else
    layer_button_list = (LayerButtons *) malloc (s);
  lb = layer_button_list + num_layer_buttons - 1;

  for (i = 0; i < LB_NUM; i++)
    {
      static char namestr[] = "Label ";
      char *name = namestr;
      int accel_idx = i;
      Widget btn;
      name[5] = 'A' + i;
      switch (i)
	{
	case LB_SILK:
	  name = "Silk";
          accel_idx = max_copper_layer;
	  break;
	case LB_RATS:
	  name = "Rat Lines";
          accel_idx = max_copper_layer + 1;
	  break;
	case LB_PINS:
	  name = "Pins/Pads";
	  break;
	case LB_VIAS:
	  name = "Vias";
	  break;
	case LB_BACK:
	  name = "Far Side";
	  break;
	case LB_MASK:
	  name = "Solder Mask";
	  break;
	}
      n = 0;
      if (accel_idx < 9)
	{
	  char buf[20], av[30];
	  Resource *ar;
	  XmString as;
	  sprintf (buf, "Ctrl-%d", accel_idx + 1);
	  as = XmStringCreatePCB (buf);
	  stdarg (XmNacceleratorText, as);
	  ar = resource_create (0);
	  sprintf (av, "ToggleView(%d)", i + 1);
	  resource_add_val (ar, 0, strdup (av), 0);
	  resource_add_val (ar, 0, strdup (av), 0);
	  ar->flags |= FLAG_V;
	  sprintf (av, "Ctrl<Key>%d", accel_idx + 1);
	  note_accelerator (av, ar);
	  stdarg (XmNmnemonic, accel_idx + '1');
	}
      btn = XmCreateToggleButton (menu, name, args, n);
      XtManageChild (btn);
      XtAddCallback (btn, XmNvalueChangedCallback,
		     (XtCallbackProc) layer_button_callback, (XtPointer) (size_t) i);
      lb->w[i] = btn;

      if (i == LB_MASK)
	note_widget_flag (btn, XmNset, "showmask");
    }
  lb->is_pick = 0;
  LayersChanged (0, 0, 0, 0);
}
Ejemplo n.º 16
0
bool wxDialog::Create(wxWindow *parent, wxWindowID id,
                      const wxString& title,
                      const wxPoint& pos,
                      const wxSize& size,
                      long style,
                      const wxString& name)
{
    SetExtraStyle(GetExtraStyle() | wxTOPLEVEL_EX_DIALOG);

    if( !wxTopLevelWindow::Create( parent, id, title, pos, size, style,
                                   name ) )
        return false;

    m_modalShowing = false;
    m_eventLoop = NULL;

    m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
    m_foregroundColour = *wxBLACK;

    Widget dialogShell = (Widget) m_mainWidget;

    SetTitle( title );

    m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
    ChangeFont(false);

    // Can't remember what this was about... but I think it's necessary.
#if wxUSE_INVISIBLE_RESIZE
    if (pos.x > -1)
        XtVaSetValues(dialogShell, XmNx, pos.x,
        NULL);
    if (pos.y > -1)
        XtVaSetValues(dialogShell, XmNy, pos.y,
        NULL);

    if (size.x > -1)
        XtVaSetValues(dialogShell, XmNwidth, size.x, NULL);
    if (size.y > -1)
        XtVaSetValues(dialogShell, XmNheight, size.y, NULL);
#endif

    // Positioning of the dialog doesn't work properly unless the dialog
    // is managed, so we manage without mapping to the screen.
    // To show, we map the shell (actually it's parent).
#if !wxUSE_INVISIBLE_RESIZE
    Widget shell = XtParent(dialogShell) ;
    XtVaSetValues(shell, XmNmappedWhenManaged, False, NULL);
#endif

#if !wxUSE_INVISIBLE_RESIZE
    XtManageChild(dialogShell);
    SetSize(pos.x, pos.y, size.x, size.y);
#endif

    XtAddEventHandler(dialogShell,ExposureMask,False,
        wxUniversalRepaintProc, (XtPointer) this);

    ChangeBackgroundColour();

    return true;
}
Ejemplo n.º 17
0
static void
insert_layerpick_buttons (Widget menu)
{
  int i, s;
  LayerButtons *lb;

  num_layer_buttons++;
  s = num_layer_buttons * sizeof (LayerButtons);
  if (layer_button_list)
    layer_button_list = (LayerButtons *) realloc (layer_button_list, s);
  else
    layer_button_list = (LayerButtons *) malloc (s);
  lb = layer_button_list + num_layer_buttons - 1;

  for (i = 0; i < LB_NUMPICK; i++)
    {
      static char namestr[] = "Label ";
      char *name = namestr;
      int accel_idx = i;
      char buf[20], av[30];
      Widget btn;
      name[5] = 'A' + i;
      switch (i)
	{
	case LB_SILK:
	  name = "Silk";
          accel_idx = max_copper_layer;
	  strcpy (av, "SelectLayer(Silk)");
	  break;
	case LB_RATS:
	  name = "Rat Lines";
          accel_idx = max_copper_layer + 1;
          strcpy (av, "SelectLayer(Rats)");
          break;
        default:
          sprintf (av, "SelectLayer(%d)", i + 1);
          break;
	}
      n = 0;
      if (accel_idx < 9)
        {
	  Resource *ar;
	  XmString as;
	  ar = resource_create (0);
	  resource_add_val (ar, 0, strdup (av), 0);
	  resource_add_val (ar, 0, strdup (av), 0);
	  ar->flags |= FLAG_V;
	  sprintf (buf, "%d", i + 1);
	  as = XmStringCreatePCB (buf);
	  stdarg (XmNacceleratorText, as);
	  sprintf (av, "<Key>%d", accel_idx + 1);
	  note_accelerator (av, ar);
	  stdarg (XmNmnemonic, accel_idx + '1');
        }
      stdarg (XmNindicatorType, XmONE_OF_MANY);
      btn = XmCreateToggleButton (menu, name, args, n);
      XtManageChild (btn);
      XtAddCallback (btn, XmNvalueChangedCallback,
		     (XtCallbackProc) layerpick_button_callback,
		     (XtPointer) (size_t) i);
      lb->w[i] = btn;
    }
  lb->is_pick = 1;
  LayersChanged (0, 0, 0, 0);
}
Ejemplo n.º 18
0
Widget	CreateEdgeTracking2DControls(
  Widget	parent)
{
  Widget	form, label, form1, slider, frame, widget;

  /* create a parent form to hold all the tracking controls */
  form = XtVaCreateWidget("edge_tracking_controls_form", xmFormWidgetClass,
			  parent,
			  XmNtopAttachment,     XmATTACH_FORM,
			  XmNbottomAttachment,	XmATTACH_FORM,
			  XmNleftAttachment,    XmATTACH_FORM,
			  XmNrightAttachment,  	XmATTACH_FORM,
			  NULL);

  /* create frame, form and label for the tracking parameters */
  frame = XtVaCreateManagedWidget("tracking_frame1", xmFrameWidgetClass,
				  form,
				  XmNtopAttachment,     XmATTACH_FORM,
				  XmNleftAttachment,    XmATTACH_FORM,
				  XmNrightAttachment,  	XmATTACH_FORM,
				  NULL);

  form1 = XtVaCreateWidget("tracking_form1", xmFormWidgetClass,
			   frame,
			   XmNtopAttachment,	XmATTACH_FORM,
			   XmNbottomAttachment,	XmATTACH_FORM,
			   XmNleftAttachment,	XmATTACH_FORM,
			   XmNrightAttachment,	XmATTACH_FORM,
			   NULL);

  label = XtVaCreateManagedWidget("tracking_parameters", xmLabelWidgetClass,
				  frame,
				  XmNchildType,		XmFRAME_TITLE_CHILD,
				  XmNborderWidth,	0,
				  NULL);

  /* create sliders for the parameter values */
  slider = HGU_XmCreateHorizontalSlider("spacing", form1,
					5.0, 3.0, 20.0, 0,
					NULL, NULL);
  XtVaSetValues(slider,
		XmNtopAttachment,	XmATTACH_FORM,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		NULL);
  widget = slider;
  spacing_slider = slider;

  slider = HGU_XmCreateHorizontalSlider("range", form1,
					5.0, 3.0, 20.0, 0,
					NULL, NULL);
  XtVaSetValues(slider,
		XmNtopAttachment,	XmATTACH_WIDGET,
		XmNtopWidget,		widget,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		NULL);
  widget = slider;
  range_slider = slider;

  XtManageChild( form1 );

  /* create frame, form and label for the snake cost parameters */
  frame = XtVaCreateManagedWidget("tracking_frame2", xmFrameWidgetClass,
				  form,
				  XmNtopAttachment,     XmATTACH_WIDGET,
				  XmNtopWidget,		frame,
				  XmNleftAttachment,    XmATTACH_FORM,
				  XmNrightAttachment,  	XmATTACH_FORM,
				  NULL);

  form1 = XtVaCreateWidget("tracking_form2", xmFormWidgetClass,
			   frame,
			   XmNtopAttachment,	XmATTACH_FORM,
			   XmNbottomAttachment,	XmATTACH_FORM,
			   XmNleftAttachment,	XmATTACH_FORM,
			   XmNrightAttachment,	XmATTACH_FORM,
			   NULL);

  label = XtVaCreateManagedWidget("snake_cost_parameters", xmLabelWidgetClass,
				  frame,
				  XmNchildType,		XmFRAME_TITLE_CHILD,
				  XmNborderWidth,	0,
				  NULL);

  /* create sliders for the parameter values */
  slider = HGU_XmCreateHorizontalSlider("nu_dist", form1,
					0.5, 0.0, 5.0, 2,
					NULL, NULL);
  XtVaSetValues(slider,
		XmNtopAttachment,	XmATTACH_FORM,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		NULL);
  widget = slider;
  dist_slider = slider;

  slider = HGU_XmCreateHorizontalSlider("nu_alpha", form1,
					0.0, 0.0, 5.0, 2,
					NULL, NULL);
  XtVaSetValues(slider,
		XmNtopAttachment,	XmATTACH_WIDGET,
		XmNtopWidget,		widget,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		NULL);
  widget = slider;
  alpha_slider = slider;

  slider = HGU_XmCreateHorizontalSlider("nu_kappa", form1,
					0.1, 0.0, 10.0, 2,
					NULL, NULL);
  XtVaSetValues(slider,
		XmNtopAttachment,	XmATTACH_WIDGET,
		XmNtopWidget,		widget,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		NULL);
  widget = slider;
  kappa_slider = slider;

  XtManageChild( form1 );

  /* create frame, form and label for the image cost parameters */
  frame = XtVaCreateManagedWidget("tracking_frame3", xmFrameWidgetClass,
				  form,
				  XmNtopAttachment,     XmATTACH_WIDGET,
				  XmNtopWidget,		frame,
				  XmNleftAttachment,    XmATTACH_FORM,
				  XmNrightAttachment,  	XmATTACH_FORM,
				  NULL);

  form1 = XtVaCreateWidget("tracking_form3", xmFormWidgetClass,
			   frame,
			   XmNtopAttachment,	XmATTACH_FORM,
			   XmNbottomAttachment,	XmATTACH_FORM,
			   XmNleftAttachment,	XmATTACH_FORM,
			   XmNrightAttachment,	XmATTACH_FORM,
			   NULL);

  label = XtVaCreateManagedWidget("image_cost_parameters", xmLabelWidgetClass,
				  frame,
				  XmNchildType,		XmFRAME_TITLE_CHILD,
				  XmNborderWidth,	0,
				  NULL);

  /* create sliders for the parameter values */
  slider = HGU_XmCreateHorizontalSlider("size", form1,
					4.0, 0.0, 10.0, 1,
					NULL, NULL);
  XtVaSetValues(slider,
		XmNtopAttachment,	XmATTACH_FORM,
		XmNtopWidget,		widget,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		NULL);
  widget = slider;
  size_slider = slider;

  slider = HGU_XmCreateHorizontalSlider("nu_direction", form1,
					1.0, 0.0, 10.0, 2,
					NULL, NULL);
  XtVaSetValues(slider,
		XmNtopAttachment,	XmATTACH_WIDGET,
		XmNtopWidget,		widget,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		NULL);
  widget = slider;
  direction_slider = slider;

  slider = HGU_XmCreateHorizontalSlider("gradient", form1,
					0.1, 0.0, 1.0, 3,
					NULL, NULL);
  XtVaSetValues(slider,
		XmNtopAttachment,	XmATTACH_WIDGET,
		XmNtopWidget,		widget,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		NULL);
  widget = slider;
  gradient_slider = slider;

  XtManageChild( form1 );

  return( form );
}
Ejemplo n.º 19
0
int xtwitter_xaw_insert(void *ctx, twitter_status_t *status)
{
    twitter_t *twitter = ctx;
    static Widget status_paned = NULL;
    static Widget status_prev_paned = NULL;
    Widget status_lower_paned = NULL;

    int height, width;
    char image_name[PATH_MAX];
    char image_path[PATH_MAX];

    twitter_image_name(status, image_name);
    snprintf(image_path, PATH_MAX, "%s/%s", twitter->images_dir, image_name);
    image = imlib_load_image(image_path);

    pixmap = XCreatePixmap(XtDisplay(widget_shell),
                           XtWindow(widget_shell),
                           48, 48,
                           DefaultDepth(XtDisplay(widget_shell), 0));

    if(image){
		imlib_context_set_image(image);
		imlib_context_set_drawable(pixmap);
		imlib_render_image_on_drawable(0, 0);
    }

    XtVaGetValues(widget_tl_form, XtNwidth, &width, XtNheight, &height, NULL);
    width -= 20; // margine

    //XawFormDoLayout(widget_tl_form, False);

    status_prev_paned = status_paned;
    status_paned = XtVaCreateWidget(
        "status_paned",
        panedWidgetClass,
        widget_tl_form,
        XtNheight, 100,
        XtNwidth, width,
        XtNresizeToPreferred, True,
        XtNallowResize, True,
        XtNtop, (XtArgVal)XawChainTop,
        NULL);

    if(status_prev_paned!=NULL){
        XtVaSetValues(status_prev_paned,
                      XtNfromVert, (XtArgVal)status_paned,
                      NULL);
    }
    XtManageChild(status_paned);

    char *name = NULL;
    twitter_status_t *rt = (twitter_status_t *)status->rt;
    //static int count;
    if(rt){
        asprintf(&name, "@%s Retweeted by @%s (%s)",
                 rt->user_screen_name,
                 status->user_screen_name, status->user_name);
    }else{
        asprintf(&name, "@%s (%s)",
                 status->user_screen_name, status->user_name);
    }

    /* name_label = */
    XtVaCreateManagedWidget(
        "name_label",
        labelWidgetClass,
        status_paned,
        XtNlabel, name,
        XtNshowGrip, False,
        XtNjustify, XtJustifyLeft,
        XtNresizeToPreferred, True,
        //XtNallowResize, True,
        NULL);
    free(name);

    status_lower_paned = XtVaCreateManagedWidget(
        "status_lower_paned",
        panedWidgetClass,
        status_paned,
        XtNorientation, (XtArgVal)XtorientHorizontal,
        NULL);

    /* icon_label = */
    XtVaCreateManagedWidget(
        "icon_label",
        labelWidgetClass,
        status_lower_paned,
        XtNheight, 58,
        XtNwidth, 58,
        XtNmin, 58,
        XtNmax, 58,
        //XtNresizeToPreferred, True,
        XtNbitmap, pixmap,
        XtNshowGrip, False,
        NULL);

    char *text = strbrkdup(status->text, 50);
    /* status_text = */
    XtVaCreateManagedWidget(
        "status_text",
        labelWidgetClass,
        status_lower_paned,
        XtNlabel, text,
        XtNshowGrip, False,
        XtNjustify, XtJustifyLeft,
        XtNresizeToPreferred, True,
        //XtNallowResize, True,
        NULL);

/*
    status_text = XtVaCreateManagedWidget(
        "status_text",
        asciiTextWidgetClass,
        status_lower_paned,
        //status_paned,
        XtNstring, (XtArgVal)status->text,
        XtNeditType, XawtextRead,
        XtNwrap, XawtextWrapWord,
        XtNdisplayCaret, False,
        //XtNfromVert, name_label,
        //XtNwidth, width - 10,
        //XtNheight, 65,
        NULL);
*/

    //XtVaGetValues(status_text, XtNheight, &height, XtNwidth, &width, NULL);
    //printf("width, height: %d, %d\n", width, height);
    //XawFormDoLayout(widget_tl_form, True);
    XFlush(XtDisplay(widget_shell));
    return 0;
}
Widget CChangeJavaFunctionPermissionsAction::GetAttributesArea(Widget parent, symbolPtr* pSym) {
	XmString labelStr;
	
	string result;
	string isClassFinalStr;
	string command;

	setWait(true);

	// get current attributes of the entity
	string id = prepareQuery(CEntityInfo::etag(pSym));
	command = string("printformat \"1 %s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\" public protected package_prot private abstract final static native;print ") + id;
	CEntityInfo::exec(command,result);
	CQueryResult Attributes; 
	Attributes.parse(result); 	
	TRecord* pRecord = *Attributes.getStartRecord();
	Boolean bPublic = *(*pRecord)[1]=="1";
	Boolean bProtected = *(*pRecord)[2]=="1";
	Boolean bPackage = *(*pRecord)[3]=="1";
	Boolean bPrivate = *(*pRecord)[4]=="1";

	// check to see if the class the function belongs to is final.
	// if so, then set final to true, and prohibit deselecting it
	command = string("final [ GetClassOf ") + id + string(" ] ");
	CEntityInfo::exec("source_dis impacts.dis", isClassFinalStr);
	CEntityInfo::exec(command, isClassFinalStr);
	
	Boolean bAbstract = *(*pRecord)[5]=="1";
	Boolean bFinal = *(*pRecord)[6]=="1";
	if (isClassFinalStr.compare("1\n") == 0) {
		bFinal = true;
		CChangeJavaFunctionPermissionsAction::isClassFinal = true;
	} else {
		CChangeJavaFunctionPermissionsAction::isClassFinal = false;
	}
	Boolean bStatic = *(*pRecord)[7]=="1";
	Boolean bNative = *(*pRecord)[8]=="1";

	Widget fullArea = XtVaCreateWidget("area",
			xmRowColumnWidgetClass, parent,
			XmNwidth, 290,
			NULL);
	

	Widget border = XtVaCreateManagedWidget("etchedBorder",
			xmFrameWidgetClass, fullArea,
			XmNshadowType, XmSHADOW_ETCHED_IN,
			NULL);
	Widget permissionsArea = XmCreateRadioBox(border,"permisArea",NULL,0);
	m_publicInd = XtVaCreateManagedWidget("Public",
			xmToggleButtonGadgetClass,permissionsArea,
			NULL);
	XmToggleButtonGadgetSetState(m_publicInd,bPublic,true);
	XtAddCallback(m_publicInd,XmNvalueChangedCallback,OnPermissionChanged,this);
	m_protectedInd = XtVaCreateManagedWidget("Protected",
			xmToggleButtonGadgetClass,permissionsArea,
			NULL);
	XmToggleButtonGadgetSetState(m_protectedInd,bProtected,true);
	XtAddCallback(m_protectedInd,XmNvalueChangedCallback,OnPermissionChanged,this);
	m_packageInd = XtVaCreateManagedWidget("\"Package\"",
			xmToggleButtonGadgetClass,permissionsArea,
			NULL);
	XmToggleButtonGadgetSetState(m_packageInd,bPackage,true);
	XtAddCallback(m_packageInd,XmNvalueChangedCallback,OnPermissionChanged,this);
	m_privateInd = XtVaCreateManagedWidget("Private",
			xmToggleButtonGadgetClass,permissionsArea,
			NULL);
	XmToggleButtonGadgetSetState(m_privateInd,bPrivate,true);
	XtAddCallback(m_privateInd,XmNvalueChangedCallback,OnPermissionChanged,this);

	m_abstractInd = XtVaCreateManagedWidget("Abstract",
			xmToggleButtonGadgetClass,fullArea,
			NULL);
	XmToggleButtonGadgetSetState(m_abstractInd,bAbstract,true);
	XtAddCallback(m_abstractInd,XmNvalueChangedCallback,OnPermissionChanged,this);

	m_staticInd = XtVaCreateManagedWidget("Static",
			xmToggleButtonGadgetClass,fullArea,
			NULL);
	XmToggleButtonGadgetSetState(m_staticInd,bStatic,true);
	XtAddCallback(m_staticInd,XmNvalueChangedCallback,OnPermissionChanged,this);

	m_finalInd = XtVaCreateManagedWidget("Final",
			xmToggleButtonGadgetClass,fullArea,
			NULL);
	XmToggleButtonGadgetSetState(m_finalInd,bFinal,true);
	XtAddCallback(m_finalInd,XmNvalueChangedCallback,OnPermissionChanged,this);

	m_nativeInd = XtVaCreateManagedWidget("Native",
			xmToggleButtonGadgetClass,fullArea,
			NULL);
	XmToggleButtonGadgetSetState(m_nativeInd,bNative,true);
	XtAddCallback(m_nativeInd,XmNvalueChangedCallback,OnPermissionChanged,this);

	XtManageChild(permissionsArea);

	setWait(false);
		
	return fullArea;	
}
Ejemplo n.º 21
0
int WNavMotif::continue_dialog( char *title, char *text)
{
    Widget 	dialog;
    XmString	text_str;
    XmString	title_str;
    XmString	continue_str;
    XmString	quit_str;
    Arg		args[10];
    int		i;
    XEvent 	Event;

    text_str = XmStringCreateLocalized( wnav_dialog_convert_text(text));
    title_str = XmStringCreateLocalized( title);
    continue_str = XmStringCreateLocalized( (char*) "Continue");
    quit_str = XmStringCreateLocalized( (char*) "Quit");
    i = 0;
    XtSetArg( args[i], XmNmessageString, text_str);
    i++;
    XtSetArg( args[i], XmNdialogTitle, title_str);
    i++;
    XtSetArg( args[i], XmNcancelLabelString, quit_str);
    i++;
    XtSetArg( args[i], XmNokLabelString, continue_str);
    i++;
    XtSetArg( args[i], XmNdialogType, XmDIALOG_WARNING);
    i++;
    if ( dialog_width && dialog_height)
    {
        XtSetArg( args[i], XmNwidth, dialog_width);
        i++;
        XtSetArg( args[i], XmNheight, dialog_height);
        i++;
        XtSetArg( args[i], XmNx, dialog_x);
        i++;
        XtSetArg( args[i], XmNy, dialog_y);
        i++;
    }

    dialog = XmCreateInformationDialog( parent_wid, (char*) "Info", args, i);
    XmStringFree( text_str);
    XmStringFree( title_str);
    XmStringFree( quit_str);
    XmStringFree( continue_str);

    XtUnmanageChild( XmMessageBoxGetChild( dialog, XmDIALOG_HELP_BUTTON));

    XtAddCallback( dialog, XmNokCallback, wnav_message_dialog_ok, this);
    XtAddCallback( dialog, XmNcancelCallback, wnav_message_dialog_cancel, this);

    flow_AddCloseVMProtocolCb( XtParent(dialog),
                               (XtCallbackProc)wnav_message_dialog_cancel, this);

    XtManageChild( dialog);
    XtPopup( XtParent(dialog), XtGrabNone);

    dialog_ok = 0;
    dialog_cancel = 0;
    dialog_help = 0;

    for (;;)
    {
        XtAppNextEvent( XtWidgetToApplicationContext( dialog), &Event);
        XtDispatchEvent( &Event);
        if ( dialog_ok)
            return 1;
        if ( dialog_cancel)
            return 0;
    }
}
Ejemplo n.º 22
0
void
xaw_pop_instance (widget_instance *instance, Boolean up)
{
  Widget widget = instance->widget;

  if (up)
    {
      if (XtIsSubclass (widget, dialogWidgetClass))
	{
	  /* For dialogs, we need to call XtPopup on the parent instead
	     of calling XtManageChild on the widget.
	     Also we need to hack the shell's WM_PROTOCOLS to get it to
	     understand what the close box is supposed to do!!
	   */
	  Display *dpy = XtDisplay (widget);
	  Widget shell = XtParent (widget);
	  Atom props [2];
	  int i = 0;
	  props [i++] = XInternAtom (dpy, "WM_DELETE_WINDOW", False);
	  XChangeProperty (dpy, XtWindow (shell),
			   XInternAtom (dpy, "WM_PROTOCOLS", False),
			   XA_ATOM, 32, PropModeAppend,
			   (unsigned char *) props, i);

	  /* Center the widget in its parent.  Why isn't this kind of crap
	     done automatically?  I thought toolkits were supposed to make
	     life easier?
	   */
	  {
	    unsigned int x, y, w, h;
	    Widget topmost = instance->parent;
	    Arg args[2];

	    w = shell->core.width;
	    h = shell->core.height;
	    while (topmost->core.parent && XtIsRealized (topmost->core.parent))
	      topmost = topmost->core.parent;
	    if (topmost->core.width < w) x = topmost->core.x;
	    else x = topmost->core.x + ((topmost->core.width - w) / 2);
	    if (topmost->core.height < h) y = topmost->core.y;
	    else y = topmost->core.y + ((topmost->core.height - h) / 2);
	    /* Using XtMoveWidget caused the widget to come
	       out in the wrong place with vtwm.
	       Question of virtual vs real coords, perhaps.  */
	    XtSetArg (args[0], XtNx, x);
	    XtSetArg (args[1], XtNy, y);
	    XtSetValues (shell, args, 2);
	  }

	  /* Finally, pop it up. */
	  XtPopup (shell, XtGrabNonexclusive);
	}
      else
	XtManageChild (widget);
    }
  else
    {
      if (XtIsSubclass (widget, dialogWidgetClass))
	XtUnmanageChild (XtParent (widget));
      else
	XtUnmanageChild (widget);
    }
}
Ejemplo n.º 23
0
bool wxTextCtrl::Create(wxWindow *parent,
                        wxWindowID id,
                        const wxString& value,
                        const wxPoint& pos,
                        const wxSize& size,
                        long style,
                        const wxValidator& validator,
                        const wxString& name)
{
    if( !CreateControl( parent, id, pos, size, style, validator, name ) )
        return false;
    PreCreation();

    m_tempCallbackStruct = NULL;
    m_modified = false;
    m_processedDefault = false;

    Widget parentWidget = (Widget) parent->GetClientWidget();

    Bool wantHorizScroll = (m_windowStyle & wxHSCROLL) != 0 ? True : False;
    // If we don't have horizontal scrollbars, we want word wrap.
    // OpenMotif 2.1 crashes if wantWordWrap is True in Japanese
    // locale (and probably other multibyte locales). The check might be
    // more precise
#if wxCHECK_LESSTIF() || wxCHECK_MOTIF_VERSION( 2, 2 )
    Bool wantWordWrap = wantHorizScroll == True ? False : True;
#else
    Bool wantWordWrap = False;
#endif

    if (m_windowStyle & wxTE_MULTILINE)
    {
        Arg args[8];
        int count = 0;
        XtSetArg (args[count], XmNscrollHorizontal, wantHorizScroll); ++count;
        if( m_font.IsOk() )
            XtSetArg (args[count], (String) wxFont::GetFontTag(),
                      m_font.GetFontType( XtDisplay(parentWidget) ) ); ++count;
        XtSetArg (args[count], XmNwordWrap, wantWordWrap); ++count;
        XtSetArg (args[count], XmNvalue, (const char*)value.mb_str()); ++count;
        XtSetArg (args[count], XmNeditable,
                  style & wxTE_READONLY ? False : True); ++count;
        XtSetArg (args[count], XmNeditMode, XmMULTI_LINE_EDIT ); ++count;

        m_mainWidget =
            (WXWidget) XmCreateScrolledText(parentWidget,
                                            name.char_str(),
                                            args, count);

        XtManageChild ((Widget) m_mainWidget);
    }
    else
    {
        m_mainWidget = (WXWidget)XtVaCreateManagedWidget
                                 (
                                  name.mb_str(),
                                  xmTextWidgetClass,
                                  parentWidget,
                                  wxFont::GetFontTag(), m_font.GetFontType( XtDisplay(parentWidget) ),
                                  XmNvalue, (const char*)value.mb_str(),
                                  XmNeditable, (style & wxTE_READONLY) ?
                                      False : True,
                                  NULL
                                 );

#if 0
        // TODO: Is this relevant? What does it do?
        int noCols = 2;
        if (!value.empty() && (value.length() > (unsigned int) noCols))
            noCols = value.length();
        XtVaSetValues((Widget) m_mainWidget,
                      XmNcolumns, noCols,
                      NULL);
#endif
    }

    // remove border if asked for
    if ( style & wxNO_BORDER )
    {
        XtVaSetValues((Widget)m_mainWidget,
                      XmNshadowThickness, 0,
                      NULL);
    }

    // install callbacks
    XtAddCallback((Widget) m_mainWidget, XmNvalueChangedCallback, (XtCallbackProc)wxTextWindowChangedProc, (XtPointer)this);

    XtAddCallback((Widget) m_mainWidget, XmNmodifyVerifyCallback, (XtCallbackProc)wxTextWindowModifyProc, (XtPointer)this);

    XtAddCallback((Widget) m_mainWidget, XmNactivateCallback, (XtCallbackProc)wxTextWindowActivateProc, (XtPointer)this);

    XtAddCallback((Widget) m_mainWidget, XmNfocusCallback, (XtCallbackProc)wxTextWindowGainFocusProc, (XtPointer)this);

    XtAddCallback((Widget) m_mainWidget, XmNlosingFocusCallback, (XtCallbackProc)wxTextWindowLoseFocusProc, (XtPointer)this);

    PostCreation();
    AttachWidget (parent, m_mainWidget, (WXWidget) NULL,
                  pos.x, pos.y, size.x, size.y);

    return true;
}
Ejemplo n.º 24
0
int main(int argc, char **argv)
{
    XtAppContext	app;
    Widget	top, mb, form, fc, fp, quit, s, om, mp, w;
    int		i;
    Arg		arg;
    XmString	xms;

    XtSetLanguageProc(NULL, NULL, NULL);

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

    form = XtVaCreateManagedWidget("form", xmFormWidgetClass, toplevel,
                                   XmNwidth,		500,
                                   XmNheight,		300,
                                   XmNresizePolicy,	XmRESIZE_NONE,
                                   NULL);

    mb  = XtVaCreateManagedWidget("mb", xmRowColumnWidgetClass, form,
                                  XmNrowColumnType,	XmMENU_BAR,
                                  XmNtopAttachment,	XmATTACH_FORM,
                                  XmNleftAttachment,	XmATTACH_FORM,
                                  XmNrightAttachment,	XmATTACH_FORM,
                                  XmNbottomAttachment,	XmATTACH_NONE,
                                  NULL);

    fp = XmCreatePulldownMenu(mb, "file pulldown", NULL, 0);
    fc = XtVaCreateManagedWidget("File", xmCascadeButtonWidgetClass, mb,
                                 XmNsubMenuId,	fp,
                                 NULL);

    quit = XtVaCreateManagedWidget("Quit", xmPushButtonWidgetClass, fp,
                                   NULL);
    XtAddCallback(quit, XmNactivateCallback, Quit, NULL);

    /* Panel of scales */
    top = mb;
    for (i=0; i<XtNumber(list); i++) {
        xms = XmStringCreateSimple(list[i].name);
        s = XtVaCreateManagedWidget(list[i].name, xmScaleWidgetClass, form,
                                    XmNorientation,		XmHORIZONTAL,
                                    XmNminimum,		list[i].min,
                                    XmNmaximum,		list[i].max,
                                    XmNvalue,		list[i].initial,
                                    XmNtopAttachment,	XmATTACH_WIDGET,
                                    XmNtopWidget,		top,
                                    XmNleftAttachment,	XmATTACH_FORM,
                                    XmNrightAttachment,	XmATTACH_POSITION,
                                    XmNrightPosition,	25,
                                    XmNbottomAttachment,	XmATTACH_NONE,
                                    XmNtitleString,		xms,
                                    XmNshowValue,		True,
                                    NULL);
        XmStringFree(xms);
        top = s;
        XtAddCallback(s, XmNvalueChangedCallback, Change, (XtPointer)i);
    }

    /* Option menu for placement */
    mp = XmCreatePulldownMenu(form, "option pane", NULL, 0);

    xms = XmStringCreateSimple("Placement");
    XtSetArg(arg, XmNlabelString, xms);
    om = XmCreateOptionMenu(form, "option", &arg, 1);
    XmStringFree(xms);

    XtVaSetValues(om,
                  XmNsubMenuId,		mp,
                  XmNtopAttachment,	XmATTACH_WIDGET,
                  XmNtopWidget,		top,
                  XmNleftAttachment,	XmATTACH_FORM,
                  XmNrightAttachment,	XmATTACH_POSITION,
                  XmNrightPosition,	25,
                  XmNbottomAttachment,	XmATTACH_NONE,
                  NULL);
    XtManageChild(om);

    w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
                                XtVaTypedArg, XmNlabelString, XmRString, "TOP_RIGHT", 10,
                                NULL);
    XtAddCallback(w, XmNactivateCallback,
                  ChangePlacement, (XtPointer)XmTOP_RIGHT);
    w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
                                XtVaTypedArg, XmNlabelString, XmRString, "BOTTOM_RIGHT", 12,
                                NULL);
    XtAddCallback(w, XmNactivateCallback,
                  ChangePlacement, (XtPointer)XmBOTTOM_RIGHT);

    XtVaSetValues(om, XmNmenuHistory, w, NULL);

    w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
                                XtVaTypedArg, XmNlabelString, XmRString, "BOTTOM_LEFT", 11,
                                NULL);
    XtAddCallback(w, XmNactivateCallback,
                  ChangePlacement, (XtPointer)XmBOTTOM_LEFT);
    w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
                                XtVaTypedArg, XmNlabelString, XmRString, "TOP_LEFT", 9,
                                NULL);
    XtAddCallback(w, XmNactivateCallback,
                  ChangePlacement, (XtPointer)XmTOP_LEFT);

    /* Create the SW */
    sw  = XtVaCreateManagedWidget("sw", xmScrolledWindowWidgetClass, form,
                                  XmNscrollingPolicy,	XmAUTOMATIC,
                                  XmNtopAttachment,	XmATTACH_WIDGET,
                                  XmNtopWidget,		mb,
                                  XmNleftAttachment,	XmATTACH_POSITION,
                                  XmNleftPosition,	25,
                                  XmNrightAttachment,	XmATTACH_NONE,
                                  XmNbottomAttachment,	XmATTACH_NONE,
                                  XmNwidth,		100,
                                  XmNheight,		100,
                                  NULL);

    ab = XtVaCreateManagedWidget("ab", xmArrowButtonWidgetClass, sw,
                                 XmNwidth,	300,
                                 XmNheight,	300,
                                 NULL);
    XtAddCallback(ab,XmNactivateCallback,cb,0);

    XtRealizeWidget(toplevel);



    {
        static XtWidgetGeometry Expected[] = {
            CWWidth | CWHeight            ,  508,  524,  500,  300, 0,0,0, /* form */
            CWWidth | CWHeight | CWX | CWY,    0,    0,  500,   31, 0,0,0, /* mb */
            CWWidth | CWHeight | CWX | CWY,    5,    5,   40,   21, 0,0,0, /* File */
            CWWidth | CWHeight | CWX | CWY,    0,   31,  125,   56, 0,0,0, /* width */
            CWWidth | CWHeight | CWX | CWY,    0,   35,   34,   17, 0,0,0, /* Title */
            CWWidth | CWHeight | CWX | CWY,    0,   16,  125,   19, 0,0,0, /* Scrollbar */
            CWWidth | CWHeight | CWX | CWY,    0,   87,  125,   56, 0,0,0, /* height */
            CWWidth | CWHeight | CWX | CWY,    0,   35,   40,   17, 0,0,0, /* Title */
            CWWidth | CWHeight | CWX | CWY,    0,   16,  125,   19, 0,0,0, /* Scrollbar */
            CWWidth | CWHeight | CWX | CWY,    0,  143,  125,   56, 0,0,0, /* spacing */
            CWWidth | CWHeight | CWX | CWY,    0,   35,   46,   17, 0,0,0, /* Title */
            CWWidth | CWHeight | CWX | CWY,    0,   16,  125,   19, 0,0,0, /* Scrollbar */
            CWWidth | CWHeight | CWX | CWY,    0,  199,  125,   56, 0,0,0, /* shadowThickness */
            CWWidth | CWHeight | CWX | CWY,    0,   35,   94,   17, 0,0,0, /* Title */
            CWWidth | CWHeight | CWX | CWY,    0,   16,  125,   19, 0,0,0, /* Scrollbar */
            CWWidth | CWHeight | CWX | CWY,    0,  255,  125,   31, 0,0,0, /* option */
            CWWidth | CWHeight | CWX | CWY,    3,    3,   58,   25, 0,0,0, /* OptionLabel */
            CWWidth | CWHeight | CWX | CWY,   64,    3,  109,   25, 0,0,0, /* OptionButton */
            CWWidth | CWHeight | CWX | CWY,  125,   31,  100,  100, 0,0,0, /* sw */
            CWWidth | CWHeight | CWX | CWY,    4,    4,   69,   69, 0,0,0, /* ScrolledWindowClipWindow */
            CWWidth | CWHeight | CWX | CWY,    0,    0,  300,  300, 0,0,0, /* ab */
            CWWidth | CWHeight | CWX | CWY,   81,    0,   19,   77, 0,0,0, /* VertScrollBar */
            CWWidth | CWHeight | CWX | CWY,    0,   81,   77,   19, 0,0,0, /* HorScrollBar */
        };
        PrintDetails(toplevel,Expected);
    };
    LessTifTestMainLoop(toplevel);

    exit(0);
}
Ejemplo n.º 25
0
UI2DView::UI2DView() : DBObject("Noname 2DView", sizeof(UI2DView)) {
    char name[DBStringLength];
    Widget menuBar, scrolledWindow, radioBox;
    Widget button;
    static Pixmap iconPixmap = (Pixmap) NULL, meshPixmap = (Pixmap) NULL;
    static Pixmap fullPixmap = (Pixmap) NULL, extentPixmap = (Pixmap) NULL;
    static Pixmap capturePixmap = (Pixmap) NULL, redrawPixmap = (Pixmap) NULL;
    static Pixmap zoomPixmap = (Pixmap) NULL, panePixmap = (Pixmap) NULL, userPixmap = (Pixmap) NULL;
    Pixel foreground, background;
    XWindowAttributes xwa;
    XSetWindowAttributes xswa;
    Atom deleteWindowAtom = XmInternAtom(XtDisplay(UITopLevel()), (char *) "WM_DELETE_WINDOW", FALSE);

    _UI2DViewLIST.Add(this);
    sprintf(name, "2DView:%2d", RowID());
    Name(name);
    Image = (XImage *) NULL;
    DrawRegion = FullRegion = NULL;
    MaxVertexNumVAR = 0;
    PointARR = (XPoint *) NULL;
    RequiredEXT = (UIDataset())->Extent();
    DShell = XtVaCreatePopupShell("UI2DView", xmDialogShellWidgetClass, UITopLevel(),
                                  XmNkeyboardFocusPolicy, XmPOINTER,
                                  XmNtitle, Name(),
                                  XmNtransient, false,
                                  XmNminWidth, 600,
                                  XmNminHeight, 450,
                                  NULL);
    XmAddWMProtocolCallback (DShell, deleteWindowAtom, (XtCallbackProc) _UI2DViewDeleteCBK, (XtPointer) this);
    MainFormW = XtVaCreateManagedWidget("UI2DViewForm", xmFormWidgetClass, DShell,
                                        XmNdialogStyle, XmDIALOG_WORK_AREA,
                                        XmNshadowThickness, 0,
                                        XmNwidth, 600,
                                        XmNheight, 450,
                                        NULL);
    menuBar = XtVaCreateManagedWidget("UI2DViewMenuBar", xmRowColumnWidgetClass, MainFormW,
                                      XmNtopAttachment, XmATTACH_FORM,
                                      XmNtopOffset, 2,
                                      XmNleftAttachment, XmATTACH_FORM,
                                      XmNleftOffset, 2,
                                      XmNrightAttachment, XmATTACH_FORM,
                                      XmNrightOffset, 2,
                                      XmNorientation, XmHORIZONTAL,
                                      XmNrowColumnType, XmWORK_AREA,
                                      NULL);
    XtVaGetValues(MainFormW, XmNforeground, &foreground, XmNbackground, &background, NULL);

    iconPixmap = iconPixmap == (Pixmap) NULL ?
                 XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAAS2Dview.bmp", foreground, background) : iconPixmap;
    XtVaSetValues(DShell, XmNiconPixmap, iconPixmap, NULL);

    fullPixmap = fullPixmap == (Pixmap) NULL ?
                 XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAASfull.bmp", foreground, background) : fullPixmap;
    extentPixmap = extentPixmap == (Pixmap) NULL ?
                   XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAASextent.bmp", foreground, background)
                   : extentPixmap;
    capturePixmap = capturePixmap == (Pixmap) NULL ?
                    XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAAScapture.bmp", foreground, background)
                    : capturePixmap;
    redrawPixmap = redrawPixmap == (Pixmap) NULL ?
                   XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAASredraw.bmp", foreground, background)
                   : redrawPixmap;
    zoomPixmap = zoomPixmap == (Pixmap) NULL ?
                 XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAASzoom.bmp", foreground, background) : zoomPixmap;
    panePixmap = panePixmap == (Pixmap) NULL ?
                 XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAASpane.bmp", foreground, background) : panePixmap;
    userPixmap = userPixmap == (Pixmap) NULL ?
                 XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAASuser.bmp", foreground, background) : userPixmap;
    meshPixmap = meshPixmap == (Pixmap) NULL ?
                 XmGetPixmap(XtScreen(UITopLevel()), (char *) "GHAASmesh.bmp", foreground, background) : meshPixmap;

    button = XtVaCreateManagedWidget("UI2DViewRedrawButton", xmPushButtonGadgetClass, menuBar,
                                     XmNlabelType, XmPIXMAP,
                                     XmNlabelPixmap, redrawPixmap,
                                     NULL);
    XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) _UI2DViewRedrawCBK, this);
    button = XtVaCreateManagedWidget("UI2DViewFullButton", xmPushButtonGadgetClass, menuBar,
                                     XmNlabelType, XmPIXMAP,
                                     XmNlabelPixmap, fullPixmap,
                                     NULL);
    XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) _UI2DViewFullActivateCBK, this);
    button = XtVaCreateManagedWidget("UI2DViewExtentButton", xmPushButtonGadgetClass, menuBar,
                                     XmNlabelType, XmPIXMAP,
                                     XmNlabelPixmap, extentPixmap,
                                     NULL);
    XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) _UI2DViewExtentActivateCBK, this);
    button = XtVaCreateManagedWidget("UI2DViewCaptureButton", xmPushButtonGadgetClass, menuBar,
                                     XmNlabelType, XmPIXMAP,
                                     XmNlabelPixmap, capturePixmap,
                                     NULL);
    radioBox = XtVaCreateManagedWidget("UI2DViewRadioBox", xmRowColumnWidgetClass, menuBar,
                                       XmNorientation, XmHORIZONTAL,
                                       XmNpacking, XmPACK_COLUMN,
                                       XmNisHomogeneous, true,
                                       XmNentryClass, xmToggleButtonGadgetClass,
                                       XmNradioBehavior, true,
                                       NULL);
    ZoomToggle = XtVaCreateManagedWidget("UI2DViewZoomToggle", xmToggleButtonGadgetClass, radioBox,
                                         XmNlabelType, XmPIXMAP,
                                         XmNlabelPixmap, zoomPixmap,
                                         XmNshadowThickness, 0,
                                         XmNset, true,
                                         NULL);
    XtAddCallback(ZoomToggle, XmNvalueChangedCallback, (XtCallbackProc) _UI2DViewZoomToggleValueCBK, this);
    PaneToggle = XtVaCreateManagedWidget("UI2DViewPaneToggle", xmToggleButtonGadgetClass, radioBox,
                                         XmNlabelType, XmPIXMAP,
                                         XmNlabelPixmap, panePixmap,
                                         XmNshadowThickness, 0,
                                         NULL);
    XtAddCallback(PaneToggle, XmNvalueChangedCallback, (XtCallbackProc) _UI2DViewPaneToggleValueCBK, this);
    UserToggle = XtVaCreateWidget("UI2DViewUserToggle", xmToggleButtonGadgetClass, radioBox,
                                  XmNlabelType, XmPIXMAP,
                                  XmNlabelPixmap, userPixmap,
                                  XmNmappedWhenManaged, false,
                                  XmNshadowThickness, 0,
                                  NULL);
    XtAddCallback(UserToggle, XmNvalueChangedCallback, (XtCallbackProc) _UI2DViewUserToggleValueCBK, this);
    if (_UI2DViewUserFunction != (UI2DViewUserFunction) NULL) XtManageChild(UserToggle);
    MeshOptionW = XtVaCreateManagedWidget("UI2DViewMeshOption", xmToggleButtonGadgetClass, menuBar,
                                          XmNlabelType, XmPIXMAP,
                                          XmNlabelPixmap, meshPixmap,
                                          XmNshadowThickness, 0,
                                          NULL);
    XtAddCallback(MeshOptionW, XmNvalueChangedCallback, (XtCallbackProc) _UI2DViewMeshOptionCBK, this);
    XtVaSetValues(menuBar, XmNmenuHelpWidget, MeshOptionW, NULL);

    ScaleW = XtVaCreateManagedWidget("UI2DViewScale", xmScaleWidgetClass, MainFormW,
                                     XmNtopAttachment, XmATTACH_WIDGET,
                                     XmNtopWidget, menuBar,
                                     XmNleftAttachment, XmATTACH_FORM,
                                     XmNleftOffset, 2,
                                     XmNbottomAttachment, XmATTACH_FORM,
                                     XmNbottomOffset, 18,
                                     XmNorientation, XmVERTICAL,
                                     XmNwidth, 16,
                                     NULL);
    XtAddCallback(ScaleW, XmNvalueChangedCallback, (XtCallbackProc) _UI2DViewScaleValueChangedCBK, this);
    scrolledWindow = XtVaCreateManagedWidget("UI2DViewScrolledWindow", xmScrolledWindowWidgetClass, MainFormW,
                     XmNtopAttachment, XmATTACH_WIDGET,
                     XmNtopWidget, menuBar,
                     XmNtopOffset, 2,
                     XmNleftAttachment, XmATTACH_WIDGET,
                     XmNleftWidget, ScaleW,
                     XmNleftOffset, 3,
                     XmNrightAttachment, XmATTACH_FORM,
                     XmNrightOffset, 3,
                     XmNbottomAttachment, XmATTACH_FORM,
                     XmNbottomOffset, 3,
                     XmNspacing, 2,
                     NULL);
    HorScrollBarW = XtVaCreateManagedWidget("UI2DViewHorScrollBar", xmScrollBarWidgetClass, scrolledWindow,
                                            XmNsliderSize, 100,
                                            XmNorientation, XmHORIZONTAL,
                                            XmNheight, 16,
                                            NULL);
    XtAddCallback(HorScrollBarW, XmNvalueChangedCallback, (XtCallbackProc) _UI2DViewHorScrollBarValueChangedCBK, this);
    VerScrollBarW = XtVaCreateManagedWidget("UI2DViewVerScrollBar", xmScrollBarWidgetClass, scrolledWindow,
                                            XmNsliderSize, 100,
                                            XmNorientation, XmVERTICAL,
                                            XmNwidth, 16,
                                            NULL);
    XtAddCallback(VerScrollBarW, XmNvalueChangedCallback, (XtCallbackProc) _UI2DViewVerScrollBarValueChangedCBK, this);
    DrawingAreaW = XtVaCreateManagedWidget("UI2DViewDrawingArea", xmDrawingAreaWidgetClass, scrolledWindow,
                                           XmNuserData, this,
                                           XmNbackground, UIColor(UIColorStandard, 0),
                                           NULL);
    XtAddCallback(DrawingAreaW, XmNresizeCallback, (XtCallbackProc) _UI2DViewResizeCBK, this);
    XtAddEventHandler(DrawingAreaW,
                      EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
                      false, (XtEventHandler) _UI2DViewPointerEHR, this);
    XmScrolledWindowSetAreas(scrolledWindow, HorScrollBarW, VerScrollBarW, DrawingAreaW);

    _UI2DViewViewCursor =
        _UI2DViewViewCursor != (Cursor) NULL ? _UI2DViewViewCursor : XCreateFontCursor(XtDisplay(DrawingAreaW),
                XC_top_left_arrow),
        _UI2DViewUserCursor = _UI2DViewUserCursor != (Cursor) NULL ? _UI2DViewUserCursor : XCreateFontCursor(
                                  XtDisplay(DrawingAreaW), XC_crosshair);
    RegenCursor = XCreateFontCursor(XtDisplay(DrawingAreaW), XC_watch);
    ActiveCursor = xswa.cursor = _UI2DViewViewCursor;
    XChangeWindowAttributes(XtDisplay(DrawingAreaW), XtWindow(DrawingAreaW), CWCursor, &xswa);

    XGetWindowAttributes(XtDisplay(DrawingAreaW), XtWindow(DrawingAreaW), &xwa);
    Background = xwa.backing_pixel;
    xswa.backing_store = Always;
    XChangeWindowAttributes(XtDisplay(DrawingAreaW), XtWindow(DrawingAreaW), CWBackingStore, &xswa);
    InputMode(ZOOM_MODE);
    Size();
    Set();
}
Ejemplo n.º 26
0
static void
add_resource_to_menu (Widget menu, Resource * node, XtCallbackProc callback)
{
  int i, j;
  char *v;
  Widget sub, btn;
  Resource *r;

  for (i = 0; i < node->c; i++)
    switch (resource_type (node->v[i]))
      {
      case 101:		/* named subnode */
	n = 0;
	stdarg (XmNtearOffModel, XmTEAR_OFF_ENABLED);
	sub = XmCreatePulldownMenu (menu, node->v[i].name, args, n);
	XtSetValues (sub, args, n);
	n = 0;
	stdarg (XmNsubMenuId, sub);
	btn = XmCreateCascadeButton (menu, node->v[i].name, args, n);
	XtManageChild (btn);
	add_resource_to_menu (sub, node->v[i].subres, callback);
	break;

      case 1:			/* unnamed subres */
	n = 0;
#if 0
	if ((v = resource_value (node->v[i].subres, "fg")))
	  {
	    do_color (v, XmNforeground);
	  }
	if ((v = resource_value (node->v[i].subres, "bg")))
	  {
	    do_color (v, XmNbackground);
	  }
	if ((v = resource_value (node->v[i].subres, "font")))
	  {
	    XFontStruct *fs = XLoadQueryFont (display, v);
	    if (fs)
	      {
		XmFontList fl =
		  XmFontListCreate (fs, XmSTRING_DEFAULT_CHARSET);
		stdarg (XmNfontList, fl);
	      }
	  }
#endif
	if ((v = resource_value (node->v[i].subres, "m")))
	  {
	    stdarg (XmNmnemonic, v);
	  }
	if ((r = resource_subres (node->v[i].subres, "a")))
	  {
	    XmString as = XmStringCreatePCB (r->v[0].value);
	    stdarg (XmNacceleratorText, as);
	    //stdarg(XmNaccelerator, r->v[1].value);
	    note_accelerator (r->v[1].value, node->v[i].subres);
	  }
	v = "button";
	for (j = 0; j < node->v[i].subres->c; j++)
	  if (resource_type (node->v[i].subres->v[j]) == 10)
	    {
	      v = node->v[i].subres->v[j].value;
	      break;
	    }
	stdarg (XmNlabelString, XmStringCreatePCB (v));
	if (node->v[i].subres->flags & FLAG_S)
	  {
	    int nn = n;
	    stdarg (XmNtearOffModel, XmTEAR_OFF_ENABLED);
	    sub = XmCreatePulldownMenu (menu, v, args + nn, n - nn);
	    n = nn;
	    stdarg (XmNsubMenuId, sub);
	    btn = XmCreateCascadeButton (menu, "menubutton", args, n);
	    XtManageChild (btn);
	    add_resource_to_menu (sub, node->v[i].subres, callback);
	  }
	else
	  {
	    Resource *radio = resource_subres (node->v[i].subres, "radio");
	    char *checked = resource_value (node->v[i].subres, "checked");
	    char *label = resource_value (node->v[i].subres, "sensitive");
	    if (radio)
	      {
		ToggleItem *ti = (ToggleItem *) malloc (sizeof (ToggleItem));
		ti->next = toggle_items;
		ti->group = radio->v[0].value;
		ti->item = radio->v[1].value;
		ti->callback = callback;
		ti->node = node->v[i].subres;
		toggle_items = ti;

		if (resource_value (node->v[i].subres, "set"))
		  {
		    stdarg (XmNset, True);
		  }
		stdarg (XmNindicatorType, XmONE_OF_MANY);
		btn = XmCreateToggleButton (menu, "menubutton", args, n);
		ti->w = btn;
		XtAddCallback (btn, XmNvalueChangedCallback,
			       (XtCallbackProc) radio_callback,
			       (XtPointer) ti);
	      }
	    else if (checked)
	      {
		if (strchr (checked, ','))
		  stdarg (XmNindicatorType, XmONE_OF_MANY);
		else
		  stdarg (XmNindicatorType, XmN_OF_MANY);
		btn = XmCreateToggleButton (menu, "menubutton", args, n);
		XtAddCallback (btn, XmNvalueChangedCallback,
			       callback, (XtPointer) node->v[i].subres);
	      }
	    else if (label && strcmp (label, "false") == 0)
	      {
		stdarg (XmNalignment, XmALIGNMENT_BEGINNING);
		btn = XmCreateLabel (menu, "menulabel", args, n);
	      }
	    else
	      {
		btn = XmCreatePushButton (menu, "menubutton", args, n);
		XtAddCallback (btn, XmNactivateCallback,
			       callback, (XtPointer) node->v[i].subres);
	      }

	    for (j = 0; j < node->v[i].subres->c; j++)
	      switch (resource_type (node->v[i].subres->v[j]))
		{
		case 110:	/* named value = X resource */
		  {
		    char *n = node->v[i].subres->v[j].name;
		    if (strcmp (n, "fg") == 0)
		      n = "foreground";
		    if (strcmp (n, "bg") == 0)
		      n = "background";
		    if (strcmp (n, "m") == 0
			|| strcmp (n, "a") == 0
			|| strcmp (n, "sensitive") == 0)
		      break;
		    if (strcmp (n, "checked") == 0)
		      {
			note_widget_flag (btn, XmNset,
					  node->v[i].subres->v[j].value);
			break;
		      }
		    if (strcmp (n, "active") == 0)
		      {
			note_widget_flag (btn, XmNsensitive,
					  node->v[i].subres->v[j].value);
			break;
		      }
		    XtVaSetValues (btn, XtVaTypedArg,
				   n,
				   XtRString,
				   node->v[i].subres->v[j].value,
				   strlen (node->v[i].subres->v[j].value) + 1,
				   NULL);
		  }
		  break;
		}

	    XtManageChild (btn);
	  }
	break;

      case 10:			/* unnamed value */
	n = 0;
	if (node->v[i].value[0] == '@')
	  {
	    if (strcmp (node->v[i].value, "@layerview") == 0)
	      insert_layerview_buttons (menu);
	    if (strcmp (node->v[i].value, "@layerpick") == 0)
	      insert_layerpick_buttons (menu);
	    if (strcmp (node->v[i].value, "@routestyles") == 0)
	      lesstif_insert_style_buttons (menu);
	  }
	else if (strcmp (node->v[i].value, "-") == 0)
	  {
	    btn = XmCreateSeparator (menu, "sep", args, n);
	    XtManageChild (btn);
	  }
	else if (i > 0)
	  {
	    btn = XmCreatePushButton (menu, node->v[i].value, args, n);
	    XtManageChild (btn);
	  }
	break;
      }
}
Ejemplo n.º 27
0
/* Create the Xt client widgets
*  */
static void
xt_client_create ( XtClient* xtclient , 
                   Window embedderid, 
                   int height, 
                   int width ) 
{
  int           n;
  Arg           args[6];
  Widget        child_widget;
  Widget        top_widget;

#ifdef DEBUG_XTBIN
  printf("xt_client_create() \n");
#endif
  top_widget = XtAppCreateShell("drawingArea", "Wrapper", 
                                applicationShellWidgetClass, 
                                xtclient->xtdisplay, 
                                NULL, 0);
  xtclient->top_widget = top_widget;

  /* set size of Xt window */
  n = 0;
  XtSetArg(args[n], XtNheight,   height);n++;
  XtSetArg(args[n], XtNwidth,    width);n++;
  XtSetValues(top_widget, args, n);

  child_widget = XtVaCreateWidget("form", 
                                  compositeWidgetClass, 
                                  top_widget, NULL);

  n = 0;
  XtSetArg(args[n], XtNheight,   height);n++;
  XtSetArg(args[n], XtNwidth,    width);n++;
  XtSetArg(args[n], XtNvisual,   xtclient->xtvisual ); n++;
  XtSetArg(args[n], XtNdepth,    xtclient->xtdepth ); n++;
  XtSetArg(args[n], XtNcolormap, xtclient->xtcolormap ); n++;
  XtSetArg(args[n], XtNborderWidth, 0); n++;
  XtSetValues(child_widget, args, n);

  XSync(xtclient->xtdisplay, FALSE);
  xtclient->oldwindow = top_widget->core.window;
  top_widget->core.window = embedderid;

  /* this little trick seems to finish initializing the widget */
#if XlibSpecificationRelease >= 6
  XtRegisterDrawable(xtclient->xtdisplay, 
                     embedderid,
                     top_widget);
#else
  _XtRegisterWindow( embedderid,
                     top_widget);
#endif
  XtRealizeWidget(child_widget);

  /* listen to all Xt events */
  XSelectInput(xtclient->xtdisplay, 
               XtWindow(top_widget), 
               0x0FFFFF);
  xt_client_set_info (child_widget, 0);

  XtManageChild(child_widget);
  xtclient->child_widget = child_widget;

  /* set the event handler */
  XtAddEventHandler(child_widget,
                    0x0FFFFF & ~ResizeRedirectMask,
                    TRUE, 
                    (XtEventHandler)xt_client_event_handler, xtclient);
  XtAddEventHandler(child_widget, 
                    SubstructureNotifyMask | ButtonReleaseMask, 
                    TRUE, 
                    (XtEventHandler)xt_client_focus_listener, 
                    xtclient);
  XSync(xtclient->xtdisplay, FALSE);
}
Ejemplo n.º 28
0
static int
LayersChanged (int argc, char **argv, Coord x, Coord y)
{
  int l, i, set;
  char *name;
  int current_layer;

  if (!layer_button_list)
    return 0;
  if (PCB && PCB->Data)
    {
      DataType *d = PCB->Data;
      for (i = 0; i < MAX_LAYER; i++)
	fg_colors[i] = lesstif_parse_color (d->Layer[i].Color);
      fg_colors[LB_SILK] = lesstif_parse_color (PCB->ElementColor);
      fg_colors[LB_RATS] = lesstif_parse_color (PCB->RatColor);
      fg_colors[LB_PINS] = lesstif_parse_color (PCB->PinColor);
      fg_colors[LB_VIAS] = lesstif_parse_color (PCB->ViaColor);
      fg_colors[LB_BACK] =
	lesstif_parse_color (PCB->InvisibleObjectsColor);
      fg_colors[LB_MASK] = lesstif_parse_color (PCB->MaskColor);
      bg_color = lesstif_parse_color (Settings.BackgroundColor);
    }
  else
    {
      for (i = 0; i < MAX_LAYER; i++)
	fg_colors[i] = lesstif_parse_color (Settings.LayerColor[i]);
      fg_colors[LB_SILK] = lesstif_parse_color (Settings.ElementColor);
      fg_colors[LB_RATS] = lesstif_parse_color (Settings.RatColor);
      fg_colors[LB_PINS] = lesstif_parse_color (Settings.PinColor);
      fg_colors[LB_VIAS] = lesstif_parse_color (Settings.ViaColor);
      fg_colors[LB_BACK] =
	lesstif_parse_color (Settings.InvisibleObjectsColor);
      fg_colors[LB_MASK] = lesstif_parse_color (Settings.MaskColor);
      bg_color = lesstif_parse_color (Settings.BackgroundColor);
    }

  if (PCB->RatDraw)
    current_layer = LB_RATS;
  else if (PCB->SilkActive)
    current_layer = LB_SILK;
  else
    current_layer = LayerStack[0];

  for (l = 0; l < num_layer_buttons; l++)
    {
      LayerButtons *lb = layer_button_list + l;
      for (i = 0; i < (lb->is_pick ? LB_NUMPICK : LB_NUM); i++)
	{
	  switch (i)
	    {
	    case LB_SILK:
	      set = PCB->ElementOn;
	      break;
	    case LB_RATS:
	      set = PCB->RatOn;
	      break;
	    case LB_PINS:
	      set = PCB->PinOn;
	      break;
	    case LB_VIAS:
	      set = PCB->ViaOn;
	      break;
	    case LB_BACK:
	      set = PCB->InvisibleObjectsOn;
	      break;
	    case LB_MASK:
	      set = TEST_FLAG (SHOWMASKFLAG, PCB);
	      break;
	    default:		/* layers */
	      set = PCB->Data->Layer[i].On;
	      break;
	    }

	  n = 0;
	  if (i < MAX_LAYER && PCB->Data->Layer[i].Name)
	    {
	      XmString s = XmStringCreatePCB (PCB->Data->Layer[i].Name);
	      stdarg (XmNlabelString, s);
	    }
	  if (!lb->is_pick)
	    {
	      if (set)
		{
		  stdarg (XmNforeground, bg_color);
		  stdarg (XmNbackground, fg_colors[i]);
		}
	      else
		{
		  stdarg (XmNforeground, fg_colors[i]);
		  stdarg (XmNbackground, bg_color);
		}
	      stdarg (XmNset, set);
	    }
	  else
	    {
	      stdarg (XmNforeground, bg_color);
	      stdarg (XmNbackground, fg_colors[i]);
	      stdarg (XmNset, current_layer == i ? True : False);
	    }
	  XtSetValues (lb->w[i], args, n);

	  if (i >= max_copper_layer && i < MAX_LAYER)
	    XtUnmanageChild(lb->w[i]);
	  else
	    XtManageChild(lb->w[i]);
	}
    }
  if (lesstif_m_layer)
    {
      switch (current_layer)
	{
	case LB_RATS:
	  name = "Rats";
	  break;
	case LB_SILK:
	  name = "Silk";
	  break;
	default:
	  name = PCB->Data->Layer[current_layer].Name;
	  break;
	}
      n = 0;
      stdarg (XmNbackground, fg_colors[current_layer]);
      stdarg (XmNforeground, bg_color);
      stdarg (XmNlabelString, XmStringCreatePCB (name));
      XtSetValues (lesstif_m_layer, args, n);
    }

  lesstif_update_layer_groups ();

  return 0;
}
Ejemplo n.º 29
0
/* ARGSUSED */
void show_textCb ( Widget w, XtPointer clnt, 
					XmDrawingAreaCallbackStruct *call )
/********************************************************************************
*										*
**										*
*										*	
* T. Piper/SAIC          1/02   Freed xfle, xmfl, & text_font as necessary	*
* T. Piper/SAIC		 2/02	Added 2nd argument, XtPointer client_data	*
*										*
********************************************************************************/
{
static Widget textpane, textform, textdialog_cancel, textbutton_form, textdialog_save;
XmString tstr;
XmFontList xmfl;
XmFontListEntry xfle;
Arg args[10];
Cardinal argcnt;

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

if( ! text_dialog)
   {
   text_dialog = XmCreateBulletinBoardDialog(toplevel, "textdialog_panel", NULL, 0);

   tstr = XmStringCreateLocalized( "Sounding Text" );
   XtVaSetValues( text_dialog, XmNdialogTitle, tstr, NULL);
   XmStringFree(tstr);

   textpane = XtVaCreateManagedWidget("text_pane",
                                xmPanedWindowWidgetClass,
                                text_dialog,
                                XmNsashWidth, 1,
                                XmNsashHeight, 1,
                                NULL);


   textform = XtVaCreateWidget("textform", xmFormWidgetClass,
                                textpane, XmNwidth, 650, XmNheight, 800,
                                XmNfractionBase, 10, NULL );
   argcnt = 0;
   XtSetArg(args[argcnt],XmNscrollBarDisplayPolicy,XmAS_NEEDED); argcnt++;
   XtSetArg(args[argcnt],XmNscrollingPolicy,XmAUTOMATIC); argcnt++;
   XtSetArg(args[argcnt],XmNheight,800); argcnt++;
   XtSetArg(args[argcnt],XmNwidth,650); argcnt++;
   textfield = XmCreateScrolledText(textform,"textform_text",
				args, argcnt);
   if ( text_font ) XFreeFont ( XtDisplay(toplevel), text_font );
   text_font = XLoadQueryFont(XtDisplay(toplevel),"-adobe-courier-bold-r-normal--14-100-100-100-m-90-iso8859-1");
   xfle = XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG, XmFONT_IS_FONT, (XtPointer)text_font );
   xmfl = XmFontListAppendEntry(NULL, xfle);
   XtFree ( (XtPointer)xfle );
   XtVaSetValues(textfield, XmNeditMode, XmMULTI_LINE_EDIT,
                                XmNeditable, False,
				XmNfontList, xmfl,
                                NULL );
   XmFontListFree ( xmfl );
   XtManageChild ( textfield );
   XtManageChild ( textform );

   textbutton_form = XtVaCreateWidget("textbuttonform", xmFormWidgetClass,
                                textpane, XmNwidth, 650, XmNfractionBase, 10, NULL );

   textdialog_save = XtVaCreateManagedWidget ("SAVE",
                        xmPushButtonWidgetClass, textbutton_form,
                        XmNleftAttachment, XmATTACH_POSITION,
                        XmNleftPosition, 3,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNrightAttachment, XmATTACH_POSITION,
                        XmNrightPosition, 5,
                        NULL );
   XtAddCallback(textdialog_save, XmNactivateCallback,
                        (XtCallbackProc)textdialog_save_cb, NULL);

   textdialog_cancel = XtVaCreateManagedWidget ("CLOSE",
                        xmPushButtonWidgetClass, textbutton_form,
                        XmNleftAttachment, XmATTACH_POSITION,
                        XmNleftPosition, 5,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNrightAttachment, XmATTACH_POSITION,
                        XmNrightPosition, 7,
                        NULL );
   XtAddCallback(textdialog_cancel, XmNactivateCallback,
                        (XtCallbackProc)textdialog_cancel_cb, NULL);

   XtManageChild ( textbutton_form );

   XtManageChild ( textpane );
   XtManageChild ( text_dialog );
   
   }
else
   XtManageChild ( text_dialog );

update_text_values();

}
Ejemplo n.º 30
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);

}