Beispiel #1
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);
}
Beispiel #2
0
void create_bill_cycle_shell (Widget parent)
{
	Widget children[24];      /* Children to manage */
	Arg al[64];                    /* Arg List */
	register int ac = 0;           /* Arg Count */
	Widget widget4 = (Widget)NULL;
	Widget widget5 = (Widget)NULL;
	Widget widget23 = (Widget)NULL;
	Widget widget49 = (Widget)NULL;

	XtSetArg(al[ac], XmNwidth, 522); ac++;
	XtSetArg(al[ac], XmNtitle, "Arbor BILL_CYCLE"); ac++;
	XtSetArg(al[ac], XmNiconName, "BILL_CYCLE"); ac++;
	bill_cycle_shell = XtCreatePopupShell ( "bill_cycle_shell", topLevelShellWidgetClass, parent, al, ac );
	ac = 0;
/* begin pre-creation code */

XtVaSetValues(bill_cycle_shell, XmNiconPixmap, abp_icon, NULL) ;

/* end pre-creation code */

	XtSetArg(al[ac], XmNwidth, 522); ac++;
	bill_cycle_form = XmCreateForm ( bill_cycle_shell, "bill_cycle_form", al, ac );
	ac = 0;
	bill_cycle_summ_form = XmCreateForm ( bill_cycle_form, "bill_cycle_summ_form", al, ac );
	bill_cycle_list_label = XmCreateLabel ( bill_cycle_summ_form, "bill_cycle_list_label", al, ac );
	XtSetArg(al[ac], XmNvisibleItemCount, 7); ac++;
	bill_cycle_summlist = XmCreateScrolledList ( bill_cycle_summ_form, "bill_cycle_summlist", al, ac );
	ac = 0;
	widget4 = XtParent ( bill_cycle_summlist );

	XtSetArg(al[ac], XmNhorizontalScrollBar, &widget5 ); ac++;
	XtGetValues(widget4, al, ac );
	ac = 0;
	bill_cycle_list_label2 = XmCreateLabel ( bill_cycle_summ_form, "bill_cycle_list_label2", al, ac );
	bill_cycle_button_form = XmCreateForm ( bill_cycle_form, "bill_cycle_button_form", al, ac );
	bill_cycle_save_btn = XmCreatePushButton ( bill_cycle_button_form, "bill_cycle_save_btn", al, ac );
	bill_cycle_clear_btn = XmCreatePushButton ( bill_cycle_button_form, "bill_cycle_clear_btn", al, ac );
	bill_cycle_update_btn = XmCreatePushButton ( bill_cycle_button_form, "bill_cycle_update_btn", al, ac );
	bill_cycle_close_btn = XmCreatePushButton ( bill_cycle_button_form, "bill_cycle_close_btn", al, ac );
	bill_cycle_delete_btn = XmCreatePushButton ( bill_cycle_button_form, "bill_cycle_delete_btn", al, ac );
	bill_cycle_scripts_btn = XmCreatePushButton ( bill_cycle_button_form, "bill_cycle_scripts_btn", al, ac );
	XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
	bill_cycle_tgl_form = XmCreateForm ( bill_cycle_form, "bill_cycle_tgl_form", al, ac );
	ac = 0;
	bill_cycle_edit_mode_label = XmCreateLabel ( bill_cycle_tgl_form, "bill_cycle_edit_mode_label", al, ac );
	XtSetArg(al[ac], XmNnumColumns, 4); ac++;
	XtSetArg(al[ac], XmNpacking, XmPACK_TIGHT); ac++;
	bill_cycle_toggle_btn = XmCreateRadioBox ( bill_cycle_tgl_form, "bill_cycle_toggle_btn", al, ac );
	ac = 0;
	bill_cycle_create_toggle = XmCreateToggleButtonGadget ( bill_cycle_toggle_btn, "bill_cycle_create_toggle", al, ac );
	bill_cycle_modify_toggle = XmCreateToggleButtonGadget ( bill_cycle_toggle_btn, "bill_cycle_modify_toggle", al, ac );
	bill_cycle_delete_toggle = XmCreateToggleButtonGadget ( bill_cycle_toggle_btn, "bill_cycle_delete_toggle", al, ac );
	bill_cycle_view_toggle = XmCreateToggleButtonGadget ( bill_cycle_toggle_btn, "bill_cycle_view_toggle", al, ac );
	widget23 = XmCreateForm ( bill_cycle_form, "widget23", al, ac );
	XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
	bill_cycle_detailform = XmCreateForm ( widget23, "bill_cycle_detailform", al, ac );
	ac = 0;
	bill_cycle_bill_period_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_bill_period_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 3); ac++;
	bill_cycle_bill_period_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_bill_period_text", al, ac );
	ac = 0;
	bill_cycle_billing_frequency_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_billing_frequency_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 4); ac++;
	bill_cycle_billing_frequency_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_billing_frequency_text", al, ac );
	ac = 0;
	bill_cycle_ppdd_date_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_ppdd_date_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 8); ac++;
	bill_cycle_ppdd_date_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_ppdd_date_text", al, ac );
	ac = 0;
	bill_cycle_next_ppdd_date_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_next_ppdd_date_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 5); ac++;
	bill_cycle_ppdd_time_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_ppdd_time_text", al, ac );
	ac = 0;
	bill_cycle_ppdd_time_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_ppdd_time_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 8); ac++;
	bill_cycle_next_ppdd_date_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_next_ppdd_date_text", al, ac );
	ac = 0;
	bill_cycle_statement_date_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_statement_date_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 5); ac++;
	bill_cycle_next_ppdd_time_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_next_ppdd_time_text", al, ac );
	ac = 0;
	bill_cycle_next_ppdd_time_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_next_ppdd_time_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 5); ac++;
	bill_cycle_statement_time_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_statement_time_text", al, ac );
	ac = 0;
	bill_cycle_cutoff_date_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_cutoff_date_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 8); ac++;
	bill_cycle_statement_date_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_statement_date_text", al, ac );
	ac = 0;
	bill_cycle_statement_time_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_statement_time_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 8); ac++;
	bill_cycle_cutoff_date_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_cutoff_date_text", al, ac );
	ac = 0;
	bill_cycle_prep_delay_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_prep_delay_label", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 5); ac++;
	bill_cycle_cutoff_time_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_cutoff_time_text", al, ac );
	ac = 0;
	bill_cycle_cutoff_time_label = XmCreateLabel ( bill_cycle_detailform, "bill_cycle_cutoff_time_label", al, ac );
	bill_cycle_prep_delay_text = XmCreateText ( bill_cycle_detailform, "bill_cycle_prep_delay_text", al, ac );
	bill_cycle_bill_period_btn = XmCreatePushButton ( bill_cycle_detailform, "bill_cycle_bill_period_btn", al, ac );
	bill_cycle_billing_frequency_btn = XmCreatePushButton ( bill_cycle_detailform, "bill_cycle_billing_frequency_btn", al, ac );
	widget49 = XmCreateLabel ( widget23, "mps_detail_label", al, ac );

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 50); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomWidget, widget23); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 4); ac++;
	XtSetValues ( bill_cycle_summ_form,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetValues ( bill_cycle_button_form,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 8); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -48); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -432); ac++;
	XtSetValues ( bill_cycle_tgl_form,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomWidget, bill_cycle_button_form); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 0); ac++;
	XtSetValues ( widget23,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -24); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -704); ac++;
	XtSetValues ( bill_cycle_list_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 42); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 0); ac++;
	XtSetValues ( widget4,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 24); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetValues ( bill_cycle_list_label2,al, ac );
	ac = 0;
	XtAddCallback (bill_cycle_summlist, XmNsingleSelectionCallback, bill_cycle_summlist_cb,NULL);
	XtManageChild(bill_cycle_summlist);
	children[ac++] = bill_cycle_list_label;
	children[ac++] = bill_cycle_list_label2;
	XtManageChildren(children, ac);
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNleftPosition, 8); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNrightPosition, 23); ac++;
	XtSetValues ( bill_cycle_save_btn,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNleftPosition, 31); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNrightPosition, 46); ac++;
	XtSetValues ( bill_cycle_clear_btn,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNleftPosition, 8); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNrightPosition, 23); ac++;
	XtSetValues ( bill_cycle_update_btn,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNleftPosition, 77); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNrightPosition, 92); ac++;
	XtSetValues ( bill_cycle_close_btn,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNleftPosition, 8); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNrightPosition, 23); ac++;
	XtSetValues ( bill_cycle_delete_btn,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNleftPosition, 54); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNrightPosition, 69); ac++;
	XtSetValues ( bill_cycle_scripts_btn,al, ac );
	ac = 0;
	XtAddCallback (bill_cycle_save_btn, XmNactivateCallback, bill_cycle_save_btn_cb,NULL);
	XtAddCallback (bill_cycle_clear_btn, XmNactivateCallback, bill_cycle_clear_btn_cb,NULL);
	XtAddCallback (bill_cycle_update_btn, XmNactivateCallback, bill_cycle_update_btn_cb,NULL);
	XtAddCallback (bill_cycle_close_btn, XmNactivateCallback, bill_cycle_close_btn_cb,NULL);
	XtAddCallback (bill_cycle_delete_btn, XmNactivateCallback, bill_cycle_delete_btn_cb,bill_cycle_shell);
	XtAddCallback (bill_cycle_scripts_btn, XmNactivateCallback, bill_cycle_scripts_btn_cb,bill_cycle_shell);
	children[ac++] = bill_cycle_save_btn;
	children[ac++] = bill_cycle_clear_btn;
	children[ac++] = bill_cycle_update_btn;
	children[ac++] = bill_cycle_close_btn;
	children[ac++] = bill_cycle_delete_btn;
	children[ac++] = bill_cycle_scripts_btn;
	XtManageChildren(children, ac);
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -36); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -92); ac++;
	XtSetValues ( bill_cycle_edit_mode_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -36); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 92); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -424); ac++;
	XtSetValues ( bill_cycle_toggle_btn,al, ac );
	ac = 0;
	XtAddCallback (bill_cycle_create_toggle, XmNarmCallback, bill_cycle_create_toggle_cb,NULL);
	XtAddCallback (bill_cycle_modify_toggle, XmNarmCallback, bill_cycle_modify_toggle_cb,NULL);
	XtAddCallback (bill_cycle_delete_toggle, XmNarmCallback, bill_cycle_delete_toggle_cb,NULL);
	XtAddCallback (bill_cycle_view_toggle, XmNarmCallback, bill_cycle_view_toggle_cb,NULL);
	children[ac++] = bill_cycle_create_toggle;
	children[ac++] = bill_cycle_modify_toggle;
	children[ac++] = bill_cycle_delete_toggle;
	children[ac++] = bill_cycle_view_toggle;
	XtManageChildren(children, ac);
	ac = 0;
	children[ac++] = bill_cycle_edit_mode_label;
	children[ac++] = bill_cycle_toggle_btn;
	XtManageChildren(children, ac);
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 28); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -180); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 4); ac++;
	XtSetValues ( bill_cycle_detailform,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( widget49,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -28); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 20); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -148); ac++;
	XtSetValues ( bill_cycle_bill_period_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -28); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 148); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -204); ac++;
	XtSetValues ( bill_cycle_bill_period_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -28); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 244); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -356); ac++;
	XtSetValues ( bill_cycle_billing_frequency_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -28); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 356); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -420); ac++;
	XtSetValues ( bill_cycle_billing_frequency_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 28); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -52); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -148); ac++;
	XtSetValues ( bill_cycle_ppdd_date_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 28); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -52); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 148); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -240); ac++;
	XtSetValues ( bill_cycle_ppdd_date_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 52); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -76); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -148); ac++;
	XtSetValues ( bill_cycle_next_ppdd_date_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 28); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -52); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 356); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -440); ac++;
	XtSetValues ( bill_cycle_ppdd_time_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 28); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -52); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 300); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -356); ac++;
	XtSetValues ( bill_cycle_ppdd_time_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 52); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -76); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 148); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -240); ac++;
	XtSetValues ( bill_cycle_next_ppdd_date_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 76); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -100); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -148); ac++;
	XtSetValues ( bill_cycle_statement_date_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 52); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -76); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 356); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -440); ac++;
	XtSetValues ( bill_cycle_next_ppdd_time_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 52); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -76); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 300); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -356); ac++;
	XtSetValues ( bill_cycle_next_ppdd_time_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 76); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -100); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 356); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -440); ac++;
	XtSetValues ( bill_cycle_statement_time_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 100); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -124); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -148); ac++;
	XtSetValues ( bill_cycle_cutoff_date_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 76); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -100); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 148); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -240); ac++;
	XtSetValues ( bill_cycle_statement_date_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 76); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -100); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 300); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -356); ac++;
	XtSetValues ( bill_cycle_statement_time_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 100); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -124); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 148); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -240); ac++;
	XtSetValues ( bill_cycle_cutoff_date_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 124); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -148); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 4); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -148); ac++;
	XtSetValues ( bill_cycle_prep_delay_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 100); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -124); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 356); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -440); ac++;
	XtSetValues ( bill_cycle_cutoff_time_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 100); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -124); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 300); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -356); ac++;
	XtSetValues ( bill_cycle_cutoff_time_label,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 124); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -148); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 148); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -232); ac++;
	XtSetValues ( bill_cycle_prep_delay_text,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -28); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 204); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -228); ac++;
	XtSetValues ( bill_cycle_bill_period_btn,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 4); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, -28); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 420); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_OPPOSITE_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, -444); ac++;
	XtSetValues ( bill_cycle_billing_frequency_btn,al, ac );
	ac = 0;
	children[ac++] = bill_cycle_bill_period_label;
	children[ac++] = bill_cycle_bill_period_text;
	children[ac++] = bill_cycle_billing_frequency_label;
	children[ac++] = bill_cycle_billing_frequency_text;
	children[ac++] = bill_cycle_ppdd_date_label;
	children[ac++] = bill_cycle_ppdd_date_text;
	children[ac++] = bill_cycle_next_ppdd_date_label;
	children[ac++] = bill_cycle_ppdd_time_text;
	children[ac++] = bill_cycle_ppdd_time_label;
	children[ac++] = bill_cycle_next_ppdd_date_text;
	children[ac++] = bill_cycle_statement_date_label;
	children[ac++] = bill_cycle_next_ppdd_time_text;
	children[ac++] = bill_cycle_next_ppdd_time_label;
	children[ac++] = bill_cycle_statement_time_text;
	children[ac++] = bill_cycle_cutoff_date_label;
	children[ac++] = bill_cycle_statement_date_text;
	children[ac++] = bill_cycle_statement_time_label;
	children[ac++] = bill_cycle_cutoff_date_text;
	children[ac++] = bill_cycle_prep_delay_label;
	children[ac++] = bill_cycle_cutoff_time_text;
	children[ac++] = bill_cycle_cutoff_time_label;
	children[ac++] = bill_cycle_prep_delay_text;
	children[ac++] = bill_cycle_bill_period_btn;
	children[ac++] = bill_cycle_billing_frequency_btn;
	XtManageChildren(children, ac);
	ac = 0;
	children[ac++] = bill_cycle_detailform;
	children[ac++] = widget49;
	XtManageChildren(children, ac);
	ac = 0;
	children[ac++] = bill_cycle_summ_form;
	children[ac++] = bill_cycle_button_form;
	children[ac++] = bill_cycle_tgl_form;
	children[ac++] = widget23;
	XtManageChildren(children, ac);
	ac = 0;
	XtManageChild ( bill_cycle_form);
}
Beispiel #3
0
int main(int argc, char *argv[])
{
    Arg             al[20];
    int             ac;
    int             canvaswidth, canvasheight;

    /* read command line options */
    if (Read_options (argc, argv) != 0)
	exit (-1);

    /* create the toplevel shell */
    toplevel = XtAppInitialize(&context, "", NULL, 0,
			       &argc, argv, NULL, NULL, 0);

    CS_error((void (*) ()) printf);

    printf("We serve line %d\n", Cur_link_ind);

    SIM_init (In_lb, Out_lb);

    /* default window size. */
    ac = 0;
    canvaswidth = 400;
    canvasheight = 700;
    XtSetArg(al[ac], XmNheight, canvaswidth);
    ac++;
    XtSetArg(al[ac], XmNwidth, canvasheight);
    ac++;
    XtSetValues(toplevel, al, ac);

    /* create a form widget. */
    ac = 0;
    form = XmCreateForm(toplevel, "form", al, ac);
    XtManageChild(form);

    /* create a menu bar and attach it to the form. */
    ac = 0;
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM);
    ac++;
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM);
    ac++;
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM);
    ac++;
    menu_bar = XmCreateMenuBar(form, "menu_bar", al, ac);
    XtManageChild(menu_bar);

    /* create a textshow widget and attach it to the form. */
    ac = 0;
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET);
    ac++;
    XtSetArg(al[ac], XmNtopWidget, menu_bar);
    ac++;
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM);
    ac++;
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION);
    ac++;
    XtSetArg(al[ac], XmNleftPosition, 0);
    ac++;
    XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_POSITION);
    ac++;
    XtSetArg(al[ac], XmNbottomPosition, 93);
    ac++;
    XtSetArg(al[ac], XmNeditMode, XmMULTI_LINE_EDIT);
    ac++;
    textshow = XmCreateScrolledText(form, "text", al, ac);
    XtManageChild(textshow);
    XmTextSetEditable(textshow, False);

    Create_menus(menu_bar); 

    XtAppAddTimeOut(context,
		    950,
		    (XtTimerCallbackProc) timer_callback,
		    (XtPointer) NULL);

    XtRealizeWidget(toplevel);
    XtAppMainLoop(context);

    return (0);
}
Beispiel #4
0
void Jump_location(/*@unused@*/ Widget w, /*@unused@*/ XtPointer clientData, /*@unused@*/ XtPointer callData) {
    static Widget  pane,form, button_ok, button_add, button_delete, button_cancel, locdata, location_name;
    int n;
    Arg al[50];           /* Arg List */
    unsigned int ac = 0;           /* Arg Count */
    Atom delw;
    char location_db_path[MAX_VALUE];

    get_user_base_dir("data/locations_db.dat", location_db_path, 
                      sizeof(location_db_path));

    if(!location_dialog) {

begin_critical_section(&location_dialog_lock, "location_gui.c:Jump_location" );

        location_dialog = XtVaCreatePopupShell(langcode("JMLPO00001"),
                xmDialogShellWidgetClass,
                appshell,
                XmNdeleteResponse,XmDESTROY,
                XmNdefaultPosition, FALSE,
                XmNresize, FALSE,
                XmNfontList, fontlist1,
                NULL);

        pane = XtVaCreateWidget("Jump_location pane",
                xmPanedWindowWidgetClass,
                location_dialog,
                MY_FOREGROUND_COLOR,
                MY_BACKGROUND_COLOR,
                NULL);

        form =  XtVaCreateWidget("Jump_location form",
                xmFormWidgetClass,
                pane,
                XmNfractionBase, 5,
                XmNautoUnmanage, FALSE,
                XmNshadowThickness, 1,
                MY_FOREGROUND_COLOR,
                MY_BACKGROUND_COLOR,
                NULL);

        /*set args for color */
        ac=0;
        XtSetArg(al[ac], XmNvisibleItemCount, 11); ac++;
        XtSetArg(al[ac], XmNtraversalOn, TRUE); ac++;
        XtSetArg(al[ac], XmNshadowThickness, 3); ac++;
        XtSetArg(al[ac], XmNbackground, colors[0x0ff]); ac++;
        XtSetArg(al[ac], XmNselectionPolicy, XmSINGLE_SELECT); ac++;
        XtSetArg(al[ac], XmNscrollBarPlacement, XmBOTTOM_RIGHT); ac++;
        XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
        XtSetArg(al[ac], XmNtopOffset, 5); ac++;
        XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
        XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
        XtSetArg(al[ac], XmNrightOffset, 5); ac++;
        XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
        XtSetArg(al[ac], XmNleftOffset, 5); ac++;
        XtSetArg(al[ac], XmNforeground, MY_FG_COLOR); ac++;
        XtSetArg(al[ac], XmNbackground, MY_BG_COLOR); ac++;
        XtSetArg(al[ac], XmNfontList, fontlist1); ac++;
 
        location_list = XmCreateScrolledList(form,
                "Jump_location list",
                al,
                ac);

        n=1;
        clear_sort_file(location_db_path);
        jump_sort();
        sort_list(location_db_path,200,location_list,&n);

        locdata = XtVaCreateManagedWidget(langcode("JMLPO00003"),
                xmLabelWidgetClass, 
                form,
                XmNtopAttachment, XmATTACH_WIDGET,
                XmNtopWidget, XtParent(location_list),
                XmNtopOffset, 10,
                XmNbottomAttachment, XmATTACH_NONE,
                XmNleftAttachment, XmATTACH_FORM,
                XmNleftOffset, 5,
                XmNrightAttachment, XmATTACH_NONE,
                MY_FOREGROUND_COLOR,
                MY_BACKGROUND_COLOR,
                XmNfontList, fontlist1,
                NULL);

        location_name = XtVaCreateManagedWidget("Jump_location Location_name", 
                xmTextFieldWidgetClass, 
                form,
                XmNeditable,   TRUE,
                XmNcursorPositionVisible, TRUE,
                XmNsensitive, TRUE,
                XmNshadowThickness,      1,
                XmNcolumns,21,
                XmNwidth,((21*7)+2),
                XmNbackground, colors[0x0f],
                XmNtopAttachment,XmATTACH_WIDGET,
                XmNtopWidget, XtParent(location_list),
                XmNtopOffset, 5,
                XmNbottomAttachment,XmATTACH_NONE,
                XmNleftAttachment, XmATTACH_WIDGET,
                XmNleftWidget,locdata,
                XmNrightAttachment,XmATTACH_FORM,
                XmNrightOffset, 5,
                XmNfontList, fontlist1,
                NULL);

        button_ok = XtVaCreateManagedWidget(langcode("JMLPO00002"),
                xmPushButtonGadgetClass, 
                form,
                XmNtopAttachment, XmATTACH_WIDGET,
                XmNtopWidget, locdata,
                XmNtopOffset,15,
                XmNbottomAttachment, XmATTACH_FORM,
                XmNbottomOffset,5,
                XmNleftAttachment, XmATTACH_POSITION,
                XmNleftPosition, 0,
                XmNleftOffset, 3,
                XmNrightAttachment, XmATTACH_POSITION,
                XmNrightPosition, 1,
                XmNnavigationType, XmTAB_GROUP,
                XmNfontList, fontlist1,
                NULL);

        button_add = XtVaCreateManagedWidget(langcode("UNIOP00007"),
                xmPushButtonGadgetClass, 
                form,
                XmNtopAttachment, XmATTACH_WIDGET,
                XmNtopWidget, locdata,
                XmNtopOffset,15,
                XmNbottomAttachment, XmATTACH_FORM,
                XmNbottomOffset,5,
                XmNleftAttachment, XmATTACH_POSITION,
                XmNleftPosition, 1,
                XmNrightAttachment, XmATTACH_POSITION,
                XmNrightPosition, 2,
                XmNnavigationType, XmTAB_GROUP,
                XmNfontList, fontlist1,
                NULL);

        button_delete = XtVaCreateManagedWidget(langcode("UNIOP00008"),
                xmPushButtonGadgetClass, 
                form,
                XmNtopAttachment, XmATTACH_WIDGET,
                XmNtopWidget, locdata,
                XmNtopOffset,15,
                XmNbottomAttachment, XmATTACH_FORM,
                XmNbottomOffset,5,
                XmNleftAttachment, XmATTACH_POSITION,
                XmNleftPosition, 2,
                XmNrightAttachment, XmATTACH_POSITION,
                XmNrightPosition, 3,
                XmNnavigationType, XmTAB_GROUP,
                XmNfontList, fontlist1,
                NULL);

        button_cancel = XtVaCreateManagedWidget(langcode("UNIOP00003"),
                xmPushButtonGadgetClass, 
                form,
                XmNtopAttachment, XmATTACH_WIDGET,
                XmNtopWidget, locdata,
                XmNtopOffset,15,
                XmNbottomAttachment, XmATTACH_FORM,
                XmNbottomOffset,5,
                XmNleftAttachment, XmATTACH_POSITION,
                XmNleftPosition, 4,
                XmNrightAttachment, XmATTACH_POSITION,
                XmNrightPosition, 5,
                XmNrightOffset, 3,
                XmNnavigationType, XmTAB_GROUP,
                XmNfontList, fontlist1,
                NULL);

        XtAddCallback(button_cancel, XmNactivateCallback, location_destroy_shell, location_dialog);
        XtAddCallback(button_ok, XmNactivateCallback, location_view, NULL);
        XtAddCallback(button_add, XmNactivateCallback, location_add, location_name);
        XtAddCallback(button_delete, XmNactivateCallback, location_delete, NULL);

        pos_dialog(location_dialog);

        delw = XmInternAtom(XtDisplay(location_dialog),"WM_DELETE_WINDOW", FALSE);
        XmAddWMProtocolCallback(location_dialog, delw, location_destroy_shell, (XtPointer)location_dialog);

        XtManageChild(form);
        XtManageChild(location_list);
        XtVaSetValues(location_list, XmNbackground, colors[0x0f], NULL);
        XtManageChild(pane);

end_critical_section(&location_dialog_lock, "location_gui.c:location_destroy_shell" );

        XtPopup(location_dialog,XtGrabNone);
        fix_dialog_size(location_dialog);

        // Move focus to the Close button.  This appears to highlight the
        // button fine, but we're not able to hit the <Enter> key to
        // have that default function happen.  Note:  We _can_ hit the
        // <SPACE> key, and that activates the option.
//        XmUpdateDisplay(location_dialog);
        XmProcessTraversal(button_cancel, XmTRAVERSE_CURRENT);

    } else {
        XtPopup(location_dialog,XtGrabNone);
        (void)XRaiseWindow(XtDisplay(location_dialog), XtWindow(location_dialog));
    }
}
GeCurveMotif::GeCurveMotif( void 	*gc_parent_ctx, 
			    Widget 	parent_widget,
			    char	*curve_name,
			    char  *filename,
			    GeCurveData *curve_data,
			    int   pos_right,
			    int gc_width,
			    int gc_height,
			    unsigned int gc_options) :
  GeCurve( gc_parent_ctx, curve_name, filename, curve_data, pos_right, 
	   gc_width, gc_height, gc_options)
{
  char		uid_filename[120] = {"xtt_curve.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  Widget	ge_curve_widget;
  char		name[] = "PwR GeCurve";

  static MrmRegisterArg	reglist[] = {
        {(char*) "gec_ctx", 0 },
	{(char*) "gec_activate_exit",(caddr_t)activate_exit },
	{(char*) "gec_activate_configure",(caddr_t)activate_configure },
	{(char*) "gec_activate_print",(caddr_t)activate_print },
	{(char*) "gec_activate_zoomin",(caddr_t)activate_zoomin },
	{(char*) "gec_activate_zoomout",(caddr_t)activate_zoomout },
	{(char*) "gec_activate_zoomreset",(caddr_t)activate_zoomreset },
	{(char*) "gec_activate_background",(caddr_t)activate_background },
	{(char*) "gec_activate_showname",(caddr_t)activate_showname },
	{(char*) "gec_activate_filledcurves",(caddr_t)activate_filledcurves },
	{(char*) "gec_activate_xlimits",(caddr_t)activate_xlimits },
	{(char*) "gec_activate_help",(caddr_t)activate_help },
	{(char*) "gec_create_pane",(caddr_t)create_pane },
	{(char*) "gec_create_growform",(caddr_t)create_growform },
	{(char*) "gec_create_nameform",(caddr_t)create_nameform },
	{(char*) "gec_create_curveform",(caddr_t)create_curveform },
	{(char*) "gec_create_minmax_textmin",(caddr_t)create_minmax_textmin },
	{(char*) "gec_create_minmax_textmax",(caddr_t)create_minmax_textmax },
	{(char*) "gec_activate_minmax_ok",(caddr_t)activate_minmax_ok }
	};

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

  Lng::get_uid( uid_filename, uid_filename);

  // Motif
  MrmInitialize();

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

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

  toplevel = XtCreatePopupShell(title, 
		topLevelShellWidgetClass, parent_widget, args, 0);

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

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

  MrmRegisterNames(reglist, reglist_num);

  sts = MrmFetchWidgetOverride( s_DRMh, (char*) "ge_curve_window", toplevel,
			name, NULL, 0, &ge_curve_widget, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch %s\n", name);

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

  MrmCloseHierarchy(s_DRMh);

  if ( gc_width == 0)
    gc_width = 800;
  if ( gc_height == 0)
    gc_height = 600;

  i = 0;
  XtSetArg(args[i],XmNwidth,gc_width);i++;
  XtSetArg(args[i],XmNheight,gc_height);i++;
  XtSetArg(args[i], XmNdeleteResponse, XmDO_NOTHING);i++;
  XtSetValues( toplevel ,args,i);
      
  XtManageChild( ge_curve_widget);

  Widget w;
  grownames_main_widget = ScrolledGrowCreate( nameform_widget, 
		(char*) "GeCurveNames", NULL,
		0, init_grownames_cb, this, &w);
  i = 0;
  XtSetArg(args[i],XmNwidth,200);i++;
  XtSetValues( grownames_main_widget, args,i);

  XtManageChild( grownames_main_widget);

  growaxis_main_widget = GrowCreate( axisform_widget, 
		(char*) "GeCurveAxis", NULL,
		0, init_growaxis_cb, this);
  i = 0;
  XtSetArg(args[i],XmNwidth,200);i++;
  XtSetValues( growaxis_main_widget, args,i);

  XtManageChild( growaxis_main_widget);

  growcurve_main_widget = CurveCreate( curveform_widget, 
		(char*) "GeCurve", NULL,
		0, init_growcurve_cb, this);
  XtManageChild( growcurve_main_widget);

  i = 0;
  XtSetArg(args[i],XmNwidth,200);i++;
  XtSetArg(args[i],XmNheight,200);i++;
  XtSetArg(args[i],XmNpaneMinimum,75);i++;
  XtSetArg(args[i],XmNpaneMaximum,100);i++;
  nav_widget = CurveCreateNav( pane_widget, (char*) "navigator",
        args, i, growcurve_main_widget);
  XtManageChild( nav_widget);

  XtPopup( toplevel, XtGrabNone);
  XtRealizeWidget( toplevel);

  wow = new CoWowMotif( toplevel);

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

}
Beispiel #6
0
void
AutoDragSliderValue(
        int location,
        int XCoord,
        int YCoord,
        int mask,
        int XButton )
{
    int 		x, y, widget_class_code, n;
    int			maximum, minimum, value;
    Boolean		invalid = False;
    XisObjectRecord 	*object;
    Widget		widget, tmp_widget;
    CompositeWidget 	cw;
    XmScrollBarWidget   sb_widget;
    Boolean		IsScale = False;
    Arg			args[5];
    short 		s_x1, s_y1, s_width1, s_height1;
    short 		s_x2, s_y2, s_width2, s_height2;
    short		change_x, change_y;
    int 		value1, value2, slider_size, slidersize;

    xisGetPointerLocation(&x,&y);
    object = xisFindObjectAtLocation(x, y);

    widget = (Widget) object->id.widget;
    if (widget == NULL)
	AutoError(_AutoMessages[SCRMSG18]);

    tmp_widget = XtParent(widget);
    widget_class_code  = mvsGetClassCode(tmp_widget);

    if (widget_class_code == mvsXmScaleWidgetClass) {
	widget = tmp_widget;
	IsScale = True;
    }

    widget_class_code  = mvsGetClassCode(widget);
    if (widget_class_code != mvsXmScaleWidgetClass)
	if (widget_class_code != mvsXmScrollBarWidgetClass) {
		AutoMessage(_AutoMessages[SCRMSG19]);
		return;
	}

    n = 0;
    XtSetArg(args[n], XmNvalue, &value);				n++;
    XtSetArg(args[n], XmNminimum, &minimum);				n++;
    XtSetArg(args[n], XmNmaximum, &maximum);				n++;
    XtSetArg(args[n], XmNsliderSize, &slidersize);		n++;
    XtGetValues(widget, args, n);

    if (! IsScale && XCoord == AUTOMAX)
	XCoord = maximum - slidersize;
    else
	if (! IsScale && XCoord != AUTOMIN)
		XCoord = (int) (((maximum - slidersize) * XCoord) / 100);

    if (XCoord == AUTOMAX && IsScale)
	XCoord = maximum;

    if (XCoord == AUTOMIN)
	XCoord = minimum;

    /* We know that the second composite child is the Scrollbar child */

    if (IsScale) {
    	cw = (CompositeWidget) widget;
    	sb_widget = (XmScrollBarWidget) cw->composite.children[SCROLLBAR_CHILD];

    	widget_class_code  = mvsGetClassCode((Widget) sb_widget);
    	if (widget_class_code != mvsXmScrollBarWidgetClass)
		AutoError(_AutoMessages[SCRMSG20]);
		     

    	CalcScrollBarData((XmScaleWidget)widget, value, &value1, &slider_size);
    	CalcScrollBarData((XmScaleWidget)widget, XCoord, &value2, &slider_size);

    	CalcSliderRect(sb_widget, &s_x1, &s_y1, &s_width1, &s_height1, value1);
    	CalcSliderRect(sb_widget, &s_x2, &s_y2, &s_width2, &s_height2, value2);
    }
    else {
	CalcSliderRect((XmScrollBarWidget)widget, &s_x1, &s_y1, 
			&s_width1, &s_height1, value);
    	CalcSliderRect((XmScrollBarWidget)widget, &s_x2, &s_y2, 
			&s_width2, &s_height2, XCoord);
    }

    change_x = abs(s_x2 - s_x1);
    change_y = abs(s_y2 - s_y1);

    switch(location) {
   	case DOWN:     	x = 0;
			y = change_y;
			break;
	case UP:	x = 0;
			y = -change_y;
			break;
	case RIGHT:     y = 0;
			x = change_x;
			break;
      	case LEFT:      y = 0;
			x = -change_x;
			break;
	default:        invalid = True;
			AutoMessage(_AutoMessages[SCRMSG3]);
			break;
    }

    if (!invalid) {
	xisPressMouseButton(mask, XButton);
	xisMovePointerRelative(x, y);
	xisReleaseMouseButton(mask, XButton);
    }

}
Beispiel #7
0
Widget
ui_build_menu(
	Widget		parent,
	int		menu_type,
	int		num_columns,
	char		*menu_title,
	char		*menu_name,
	MenuItem	*menu_items
)
{
    Widget	menu,
   		cascade,
		widget;
    Arg		args[4];
    int 	i;
    XmString	xmlabel;
    int		n = 0;

    if (num_columns > 1)
    {
    	XtSetArg(args[n], XmNpacking, XmPACK_COLUMN);    n++;
    	XtSetArg(args[n], XmNnumColumns, num_columns);   n++;
    }
    if (menu_type == XmMENU_PULLDOWN)
	menu = XmCreatePulldownMenu(parent, "pulldown_menu", args, n);
    else
    {
	XtSetArg(args[n], XmNwhichButton, AB_BMenu); n++;
        menu = XmCreatePopupMenu(parent, "popup_menu", args, n);
    }

    if (menu_type == XmMENU_PULLDOWN)
    {
        cascade = XtVaCreateManagedWidget(menu_name,
			xmCascadeButtonWidgetClass, parent,
			XmNsubMenuId,	menu,
			NULL);

	if (menu_title)
        {
	    xmlabel = XmStringCreateLocalized(menu_title);
	    XtVaSetValues(cascade, XmNlabelString, xmlabel, NULL);
	    XmStringFree(xmlabel);
	}
    }

    for (i = 0; menu_items[i].label != NULL; i++)
    {
        if (menu_items[i].subitems)
	{
	    widget = ui_build_menu(menu, XmMENU_PULLDOWN, 
				       menu_items[i].num_columns,
			               menu_items[i].label, 
				       menu_items[i].name,
				       (MenuItem *)menu_items[i].subitems);

	    XtVaSetValues(widget, XmNuserData, (XtArgVal)menu_items[i].user_data, NULL);
	}
	else
	{
	    widget = XtVaCreateManagedWidget(menu_items[i].name,
			         *menu_items[i].wclass, 
				  menu, 
                                  XmNuserData,    (XtArgVal)menu_items[i].user_data,
				  NULL);

	    if (menu_items[i].label != NULL)
	    {
		xmlabel = XmStringCreateLocalized(menu_items[i].label);
	  	XtVaSetValues(widget, XmNlabelString, xmlabel, NULL);
	    	XmStringFree(xmlabel);
	    }
	
	    /* If label is glyph type, then change type and call
	     * routine to set glyph.
	     */
	    if (menu_items[i].label_type == AB_LABEL_GLYPH)
	    {
        	XtVaSetValues(widget, XmNlabelType, XmPIXMAP, NULL);
		dtb_set_label_from_bitmap_data(widget,
				menu_items[i].pixwidth,
				menu_items[i].pixheight,
				menu_items[i].bits);

	    }
	}

	if (menu_items[i].active == FALSE)
	    XtSetSensitive(widget, FALSE);
 	else if (menu_items[i].callback != NULL)
	    XtAddCallback(widget, XmNactivateCallback, 
				menu_items[i].callback, 
				menu_items[i].client_data);
   }

   if (menu_type == XmMENU_POPUP)
	return menu;
   else
	return cascade;
}
Beispiel #8
0
void
WmPanelistShow (Widget w)

{
   SwitchData * switch_data;
   Dimension switch_rc_height;   
   Dimension switch_button_height;   

   Dimension width = XtWidth(panel.shell);
   Dimension height = XtHeight(panel.shell);
   Position x = XtX(panel.shell);
   Position y = XtY(panel.shell);
   Dimension screen_width;

   Display * display;

   CompositeWidget  cw;
   Widget         * widget_list;
   DtWmHints        vHints;

   String    shell_geometry = NULL;
   char      geometry_buffer[32];

   XSizeHints   hints;
   long	        supplied;

   int i;
   Arg al[20];
   int ac;
   


   /*  Find the switch data for later processing  */
   
   switch_data = NULL;
   
   for (i = 0; i < panel.box_data_count; i++)
   {
      if (panel.box_data[i]->switch_data != NULL)
      {
         switch_data = panel.box_data[i]->switch_data;
         break;
      }
   }


   /*  Realize the shell so that it is sized properly for later  */
   /*  positioning and child repositioning.                      */

   XtRealizeWidget (panel.shell);


   /*  See if a geometry has been set.  */
   
   ac = 0;
   XtSetArg (al[ac], XmNgeometry, &shell_geometry);  ac++;
   XtGetValues (panel.shell, al, ac);


   /*  If the shell has no default geometry, construct a default    */
   /*  which will center the panel along the bottom of the display  */

   width = XtWidth (panel.shell);
   screen_width = WidthOfScreen (XtScreen (panel.shell));
   display = XtDisplay (panel.shell);

   if (shell_geometry == NULL)
   {
      Position  x;
      char      geometry_buffer[32];

      if (panel.element_values[PANEL_GEOMETRY].string_value != NULL)
      {
         shell_geometry = panel.element_values[PANEL_GEOMETRY].parsed_value;
      }
      else
      {
         x = (screen_width > width) ? (Position)(screen_width - width) / 2 : 0;
         sprintf (geometry_buffer, "+%d-0", x);
         shell_geometry = geometry_buffer;
      }
      
      XtSetArg (al[0], XmNgeometry, shell_geometry);
      XtSetValues (panel.shell, al, 1);
   }


   /*  Adjust the positions of the buttons within the switch  */
   /*  so that they are spaced nicely.                        */

   if (switch_data != NULL)
   {
      UpdateSwitchGeometry (switch_data->box_data);


      /*  Reposition or adjust the front panel if it is either off  */
      /*  the right edge of the screen or larger than the screen    */

      if (width > screen_width)
      {
         Arg al[1];

         while (width > screen_width && 
                panel.switch_row_count < switch_data->switch_count)
         {	    
            panel.switch_row_count++;

            XtSetArg (al[0], XmNnumColumns, panel.switch_row_count);
            XtSetValues (switch_data->rc, al, 1);

            width = XtWidth (panel.shell);
         }
      }
   }

   SetGeometry (panel.shell, shell_geometry, &x, &y);
   WorkspaceAdjustPanelPosition (x, y, XtWidth (panel.shell),
                                 XtHeight (panel.shell));


   /* Set hints to avoid interactive placement */

   if (XGetWMNormalHints(display, XtWindow(panel.shell),
                         &hints, &supplied) != 0)
   {
      hints.flags |= USPosition|USSize;
      XSetWMNormalHints(display, XtWindow(panel.shell), &hints);
   }


   /*  Set the shells icon and title for when it is minimized  */
   
   if (switch_data != NULL)
   {
      int current_workspace = switch_data->active_switch;

      XtSetArg (al[0], XmNiconName, switch_data->switch_names[current_workspace]);
      XtSetArg (al[1], XmNtitle, switch_data->switch_names[current_workspace]);
      XtSetValues (panel.shell, al, 2);
   }


   /*  Set panel's window manager hints.  */

   vHints.flags = DtWM_HINTS_BEHAVIORS;
   vHints.behaviors = DtWM_BEHAVIOR_PANEL;
   _DtWsmSetDtWmHints (XtDisplay(panel.shell), XtWindow (panel.shell), &vHints);


   /*  Set the subpanel's transientShell to update transientFor and  */
   /*  Set the subpanel hints.                                       */

   vHints.behaviors |= DtWM_BEHAVIOR_SUBPANEL;
   vHints.flags |= DtWM_HINTS_ATTACH_WINDOW;
   vHints.attachWindow = XtWindow (panel.shell);

   for (i = 0, widget_list = M_PopupList (panel.shell); 
        i < M_NumPopups (panel.shell); i++)
   {
      cw = (CompositeWidget) widget_list[i];

      ac = 0;
      XtSetArg (al[ac], XmNtransientFor, NULL);  ac++;
      XtSetValues ((Widget) cw, al, ac);

      ac = 0;
      XtSetArg (al[ac], XmNtransientFor, panel.shell);  ac++;
      XtSetValues ((Widget) cw, al, ac);

      if (M_NumChildren (cw) > 0)
      {
         XtRealizeWidget ((M_Children (cw))[0]);
         _DtWsmSetDtWmHints (XtDisplay (panel.shell), 
                             XtWindow (widget_list[i]), &vHints);
      }
   }


   /*  Set the push recall list and count into the window manager's  */
   /*  screen global data.                                           */
   
   PushRecallSetData ();


   /*  Set up the callback ot the workspace management API for  */
   /*  catching changes in workspace configuration.             */
      
   DtWsmAddWorkspaceModifiedCallback(panel.shell,
                                     WorkspaceModifyCB, (XtPointer)switch_data);


   /*  Get the front panel displayed  */

   XtSetMappedWhenManaged (panel.shell, True);
   XtPopup (panel.shell, XtGrabNone);


   /*  Restore the session information  */

   SessionRestoreData ();


   /*  Set up the window and geometry information for the embedded clients  */

   for (i = 0; i < panel.embedded_client_count; i++)
      EmbeddedClientSetGeometry (&(((WmFpEmbeddedClientList) panel.embedded_client_list)[i]));


   /*  Set the embedded client list and count into the window manager's  */
   /*  screen global data.                                               */

   EmbeddedClientSetData ();
}
Beispiel #9
0
static PlotWindowInfo *new_decoration(const string& name)
{
    PlotWindowInfo *plot = 0;

    // Check whether we can reuse an existing decoration
    for (int i = 0; i < plot_infos.size(); i++)
    {
	PlotWindowInfo *info = (PlotWindowInfo *)plot_infos[i];
	if (info->plotter == 0)
	{
	    // Shell is unused - use this one
	    plot = info;
	    break;
	}
    }

    if (plot == 0)
    {
	plot = new PlotWindowInfo;

	// Create decoration windows
	Arg args[10];
	Cardinal arg = 0;
	XtSetArg(args[arg], XmNallowShellResize, True);       arg++;
	XtSetArg(args[arg], XmNdeleteResponse, XmDO_NOTHING); arg++;

	// Mark shell as `used'
	XtSetArg(args[arg], XmNuserData, XtPointer(True)); arg++;
	plot->shell = verify(XtCreateWidget("plot", topLevelShellWidgetClass,
					    find_shell(), args, arg));

	AddDeleteWindowCallback(plot->shell, CancelPlotCB, XtPointer(plot));

	arg = 0;
	Widget main_window = XmCreateMainWindow(plot->shell, 
						XMST("main_window"), 
						args, arg);
	XtManageChild(main_window);

	MMcreateMenuBar(main_window, "menubar", menubar);
	MMaddCallbacks(file_menu,    XtPointer(plot));
	MMaddCallbacks(simple_edit_menu);
	MMaddCallbacks(view_menu,    XtPointer(plot));
	MMaddCallbacks(plot_menu,    XtPointer(plot));
	MMaddCallbacks(scale_menu,   XtPointer(plot));
	MMaddCallbacks(contour_menu, XtPointer(plot));
	MMaddCallbacks(simple_help_menu);
	MMaddHelpCallback(menubar, ImmediateHelpCB);

	arg = 0;
	XtSetArg(args[arg], XmNscrollingPolicy, XmAPPLICATION_DEFINED); arg++;
	XtSetArg(args[arg], XmNvisualPolicy,    XmVARIABLE);            arg++;
	Widget scroll = 
	    XmCreateScrolledWindow(main_window, XMST("scroll"), args, arg);
	XtManageChild(scroll);

	// Create work window
	Widget work;
	string plot_term_type = downcase(app_data.plot_term_type);
	if (plot_term_type.contains("xlib", 0))
	{
	    // xlib type - create plot area to draw plot commands
	    arg = 0;
	    work = XmCreateDrawingArea(scroll, 
				       XMST(PLOT_AREA_NAME), args, arg);
	    XtManageChild(work);

	    plot->area = 
		new PlotArea(work, make_font(app_data, FixedWidthDDDFont));
	    XtVaSetValues(work, XmNuserData, XtPointer(plot->area), 
			  XtPointer(0));
	}
	else if (plot_term_type.contains("x11", 0))
	{
	    // x11 type - swallow Gnuplot window
	    arg = 0;
	    work = plot->swallower = 
		XtCreateManagedWidget(SWALLOWER_NAME, swallowerWidgetClass, 
				      scroll, args, arg);
	}
	else
	{
	    // Unknown terminal type
	    post_error("Unknown plot terminal type " + 
		       quote(app_data.plot_term_type),
		       "unknown_plot_term_type_error");
	    return 0;
	}

	// Create scroll bars
	const int slider_size = 20;

	arg = 0;
	XtSetArg(args[arg], XmNorientation, XmHORIZONTAL);      arg++;
	XtSetArg(args[arg], XmNminimum,     0);                 arg++;
	XtSetArg(args[arg], XmNmaximum,     360 + slider_size); arg++;
	plot->hsb = XmCreateScrollBar(scroll, XMST("hsb"), args, arg);
	XtManageChild(plot->hsb);

	arg = 0;
	XtSetArg(args[arg], XmNorientation, XmVERTICAL);        arg++;
	XtSetArg(args[arg], XmNminimum,     0);                 arg++;
	XtSetArg(args[arg], XmNmaximum,     180 + slider_size); arg++;
	plot->vsb = XmCreateScrollBar(scroll, XMST("vsb"), args, arg);
	XtManageChild(plot->vsb);

	XtAddCallback(plot->hsb, XmNvalueChangedCallback,
		      SetViewCB, XtPointer(plot));
	XtAddCallback(plot->vsb, XmNvalueChangedCallback,
		      SetViewCB, XtPointer(plot));

#if 0
	XtAddCallback(plot->hsb, XmNdragCallback, SetViewCB, XtPointer(plot));
	XtAddCallback(plot->vsb, XmNdragCallback, SetViewCB, XtPointer(plot));
#endif

	XmScrolledWindowSetAreas(scroll, plot->hsb, plot->vsb, work);

	Delay::register_shell(plot->shell);
	InstallButtonTips(plot->shell);

	plot_infos += plot;
    }

    string title = DDD_NAME ": " + name;
    XtVaSetValues(plot->shell,
		  XmNtitle, title.chars(),
		  XmNiconName, title.chars(),
		  XtPointer(0));

    if (plot->swallower != 0)
    {
	XtRemoveAllCallbacks(plot->swallower, XtNwindowCreatedCallback);
	XtAddCallback(plot->swallower, XtNwindowCreatedCallback,
		      SwallowCB, XtPointer(plot));

	XtRemoveAllCallbacks(plot->swallower, XtNwindowGoneCallback);
	XtAddCallback(plot->swallower, XtNwindowGoneCallback, 
		      SwallowAgainCB, XtPointer(plot));

	if (plot->swallow_timer != 0)
	    XtRemoveTimeOut(plot->swallow_timer);

	plot->swallow_timer = 
	    XtAppAddTimeOut(XtWidgetToApplicationContext(plot->swallower),
			    app_data.plot_window_delay, SwallowTimeOutCB, 
			    XtPointer(plot));
    }

    plot->active = false;

    return plot;
}
// Answer GDB question
static void select_from_gdb(const string& question, string& reply)
{
    int count       = question.freq('\n') + 1;
    string *choices = new string[count];
    bool *selected  = new bool[count];

    split(question, choices, count, '\n');

    // Highlight choice #1 by default
    for (int i = 0; i < count; i++)
    {
	if (!has_nr(choices[i]))
	{
	    // Choice has no number (prompt) - remove it
	    for (int j = i; j < count - 1; j++)
		choices[j] = choices[j + 1];
	    count--;
	    i--;
	}
	else
	{
	    selected[i] = (get_positive_nr(choices[i]) == 1);
	}
    }

    if (count < 2)
    {
	// Nothing to choose from
	if (count == 1)
	{
	    // Take the first choice.
	    reply = itostring(atoi(choices[0].chars())) + "\n";
	}
	
	delete[] choices;
	delete[] selected;
	return;
    }

    // Popup selection dialog
    static string selection_reply;

    if (gdb_selection_dialog == 0)
    {
	Arg args[10];
	Cardinal arg = 0;
	XtSetArg(args[arg], XmNautoUnmanage, False); arg++;

	gdb_selection_dialog = 
	    verify(XmCreateSelectionDialog(find_shell(gdb_w),
					   XMST("gdb_selection_dialog"),
					   args, arg));
	Delay::register_shell(gdb_selection_dialog);

	XtUnmanageChild(XmSelectionBoxGetChild(gdb_selection_dialog,
					       XmDIALOG_TEXT));
	XtUnmanageChild(XmSelectionBoxGetChild(gdb_selection_dialog, 
					       XmDIALOG_SELECTION_LABEL));
	XtUnmanageChild(XmSelectionBoxGetChild(gdb_selection_dialog, 
					       XmDIALOG_APPLY_BUTTON));

	gdb_selection_list_w = XmSelectionBoxGetChild(gdb_selection_dialog, 
						      XmDIALOG_LIST);
	XtVaSetValues(gdb_selection_list_w,
		      XmNselectionPolicy, XmSINGLE_SELECT,
		      XtPointer(0));
	XtAddCallback(gdb_selection_dialog,
		      XmNokCallback, SelectCB, &selection_reply);
	XtAddCallback(gdb_selection_dialog,
		      XmNcancelCallback, CancelCB, &selection_reply);
	XtAddCallback(gdb_selection_dialog,
		      XmNhelpCallback, ImmediateHelpCB, 0);
    }

    setLabelList(gdb_selection_list_w, choices, selected, count, false, false);

    delete[] choices;
    delete[] selected;

    manage_and_raise(gdb_selection_dialog);

    selection_reply = "";
    while (selection_reply.empty() 
	   && gdb->running() && !gdb->isReadyWithPrompt())
	XtAppProcessEvent(XtWidgetToApplicationContext(gdb_w), XtIMAll);

    // Found a reply - return
    reply = selection_reply;
}
Beispiel #11
0
static void DoExportCB(Widget w, XtPointer client_data, XtPointer call_data)
{
    SelectPlotCB(w, client_data, call_data);

    PlotWindowInfo *plot = (PlotWindowInfo *)client_data;
    string target = get_file(w, client_data, call_data);
    if (target.empty())
	return;

    const StringArray& titles  = plot->plotter->data_titles();
    const StringArray& sources = plot->plotter->data_files();

    string source = "";
    string title  = "";
    for (int i = 0; source.empty() && i < sources.size(); i++)
    {
	if (!sources[i].empty())
	{
	    source = sources[i];
	    title  = titles[i];
	}
    }
    
    if (source.empty())
	return;			// This should not happen

    if (access(target.chars(), W_OK) == 0 && is_regular_file(target))
    {
	// File exists - request confirmation
	static Widget confirm_overwrite_dialog = 0;
	if (confirm_overwrite_dialog != 0)
	    DestroyWhenIdle(confirm_overwrite_dialog);

	Arg args[10];
	Cardinal arg = 0;
	XtSetArg(args[arg], XmNdialogStyle, 
		 XmDIALOG_FULL_APPLICATION_MODAL); arg++;
	confirm_overwrite_dialog = 
	    verify(XmCreateQuestionDialog(plot->shell,
					  XMST("confirm_overwrite_dialog"), 
					  args, arg));
	Delay::register_shell(confirm_overwrite_dialog);

	bool yes = false;
	bool no  = false;
	   
	XtAddCallback(confirm_overwrite_dialog,
		      XmNokCallback, SetCB, XtPointer(&yes));
	XtAddCallback(confirm_overwrite_dialog,
		      XmNcancelCallback, SetCB, XtPointer(&no));
	XtAddCallback(confirm_overwrite_dialog, 
		      XmNhelpCallback, ImmediateHelpCB, 0);

	MString question = rm("Overwrite existing file " 
			      + quote(target) + "?");
	XtVaSetValues (confirm_overwrite_dialog, XmNmessageString, 
		       question.xmstring(), XtPointer(0));
	manage_and_raise(confirm_overwrite_dialog);

	XtAppContext app_context = XtWidgetToApplicationContext(plot->shell);
	while (!yes && !no)
	    XtAppProcessEvent(app_context, XtIMAll);

	if (no)
	    return;
    }

    StatusDelay delay("Saving " + title + " data to " + quote(target));

    // Copy SOURCE to TARGET
    std::ifstream is(source.chars());
    std::ofstream os(target.chars());

    if (os.bad())
    {
	FILE *fp = fopen(target.chars(), "w");
	post_error(string("Cannot open ") 
		   + quote(target) + ": " + strerror(errno), 
		   "export_failed_error", plot->shell);
	if (fp)
	    fclose(fp);
	delay.outcome = strerror(errno);
	return;
    }

    int c;
    while ((c = is.get()) != EOF)
	os.put((unsigned char) c);

    XtUnmanageChild(plot->export_dialog);
}
Beispiel #12
0
static void 
ProcessComponentList(
        Widget parent,
        Widget mainRC )
{
   int       count=0;
   int       j=0;
   int       n, n2;
   Arg       args[MAX_ARGS];
   Widget    componentWidget;
   int       s;
   char      *string;
   char      *resString, *resString2;
   XmString  cmp_string;
   int       helpTag;
   char      *dtIcon;
   int       len;

   style.workProcs = False;
   if (style.xrdb.componentList == NULL) return;

   n = 0;
   XtSetArg(args[n], XmNalignment, XmALIGNMENT_CENTER); n++;
   XtSetArg(args[n], XmNpixmapPosition, XmPIXMAP_TOP); n++;
   XtSetArg(args[n], XmNshadowType, XmSHADOW_OUT); n++;
   n2 = 3;    /* number of preset args for creating Icons */

   resString = strdup (style.xrdb.componentList);
   resString2 = resString;
   len = strlen(resString);
   string = strtok(resString, " ");
   s = 0;
   while (string != NULL)
   {
      /* check for valid name, duplicate name *** */

      /* create Icon in Dtstyle main window */

      n = n2;
      XtSetArg(args[n], XmNfillMode, XmFILL_SELF); n++;
      if (colorUse == XmCO_BLACK_WHITE)
      {
          XtSetArg(args[n], XmNuseEmbossedText, False); n++;
      }
      XtSetArg(args[n], XmNpixmapForeground, style.primBSCol); n++;
      XtSetArg(args[n], XmNpixmapBackground, style.primTSCol); n++;
      if (strcmp(string, COLOR) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 27, "Color"));
          helpTag = HELP_COLOR_BUTTON;
	  dtIcon = _DtGetIconFileName(style.screen, COLOR_ICON, NULL, NULL, NULL);
          style.workProcs = True;          
      }
      else if (strcmp(string, FONT) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 28, "Font"));
	  dtIcon = _DtGetIconFileName(style.screen, FONT_ICON, NULL, NULL, NULL);
          helpTag = HELP_FONT_BUTTON;
      }

      else if (strcmp(string, BACKDROP) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 29, "Backdrop"));
	  dtIcon = _DtGetIconFileName(style.screen, BACKDROP_ICON, NULL, NULL, NULL);
          helpTag = HELP_BACKDROP_BUTTON;
      }

      else if (strcmp(string, KEYBOARD) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 30, "Keyboard"));
	  dtIcon = _DtGetIconFileName(style.screen, KEYBOARD_ICON, NULL, NULL, NULL);	  
          helpTag = HELP_KEYBOARD_BUTTON;        
      }

      else if (strcmp(string, MOUSE) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 31, "Mouse"));
	  dtIcon = _DtGetIconFileName(style.screen, MOUSE_ICON, NULL, NULL, NULL);	  
          helpTag = HELP_MOUSE_BUTTON;
      }

      else if (strcmp(string, BEEP) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 32, "Beep"));
	  dtIcon = _DtGetIconFileName(style.screen, BEEP_ICON, NULL, NULL, NULL);	  
          helpTag = HELP_AUDIO_BUTTON;
      }

      else if (strcmp(string, SCREEN) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 33, "Screen"));
	  dtIcon = _DtGetIconFileName(style.screen, SCREEN_ICON, NULL, NULL, NULL);	  
          helpTag = HELP_SCREEN_BUTTON;
      }

      else if (strcmp(string, DTWM) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 38, "Window"));
	  dtIcon = _DtGetIconFileName(style.screen, DTWM_ICON, NULL, NULL, NULL);	  
          helpTag = HELP_DTWM_BUTTON;
      }

      else if (strcmp(string, STARTUP) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 35, "Startup"));
	  dtIcon = _DtGetIconFileName(style.screen, STARTUP_ICON, NULL, NULL, NULL);	  
          helpTag = HELP_STARTUP_BUTTON;
      }
      else if (strcmp(string, I18N) == 0)
      {
          cmp_string = CMPSTR(GETMESSAGE(4, 34, "Intl'"));
	  dtIcon = _DtGetIconFileName(style.screen, I18N_ICON, NULL, NULL, NULL);	  
          helpTag = HELP_I18N_BUTTON;        
      }
      else
      {
          s += strlen(string) +1;
	  if (resString+s >= resString2 + len)
	      string = NULL;
	  else
	      string = strtok(resString+s, " ");
          continue;
      }
      XtSetArg(args[n], XmNimageName, dtIcon); n++;  
      XtSetArg(args[n], XmNstring, cmp_string); n++;
      componentWidget = _DtCreateControl(mainRC, string, args, n); 
      XtManageChild (componentWidget);
      XtAddCallback(componentWidget, XmNcallback, activateCB, string);
      XtAddCallback(componentWidget, XmNhelpCallback,
             (XtCallbackProc)HelpRequestCB, (XtPointer)helpTag);
      XmStringFree(cmp_string);
      XtFree(dtIcon);
      
      s += strlen(string) +1;
      if (resString+s >= resString2 + len)
	  string = NULL;
      else
	  string = strtok(resString+s, " ");

   } /* while */

}
Beispiel #13
0
/*+++++++++++++++++++++++++++++++++++++++++++++*/
static void 
build_mainWindow(
        Widget shell )
{
  int        count, n, n2;
  Arg        args[MAX_ARGS];
  Widget     WidgList[10];
  Widget     frame;
  Widget     mainMenu;
  Widget     mainRC;
  Widget     filePulldown;
  Widget     helpPulldown;
  Widget     exitBtn;
  char       *mnemonic;
  char       *tmpStr;
  Pixmap     pixmap;
  XmString   labelString;
  Pixmap     ditherPix;
  XmPixelSet pixelSet[XmCO_NUM_COLORS];
  Pixel      bg;
  short      a,i,p,s;


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

    XtSetArg(save.posArgs[save.poscnt], XmNnoResize, True); save.poscnt++;
    XtSetArg(save.posArgs[save.poscnt], XmNresizePolicy, XmRESIZE_NONE); save.poscnt++;
    style.mainWindow= XmCreateMainWindow(shell,"mainWindow",  save.posArgs, save.poscnt);
    XtAddCallback(style.mainWindow, XmNhelpCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_MAIN_WINDOW);

    n = 0;
    tmpStr = (char *)XtMalloc(strlen(GETMESSAGE(4, 1, "Style Manager"))+1);
    sprintf(tmpStr, GETMESSAGE(4, 1, "Style Manager"));
    XtSetArg(args[n], XmNtitle, tmpStr); n++;
    XtSetArg(args[n], XmNiconName, 
        (char *)GETMESSAGE(4, 37, "Style")); n++;
    XtSetValues(XtParent(style.mainWindow), args, n);
    XtFree(tmpStr);

    n = 0;
    mainMenu= XmCreateMenuBar(style.mainWindow,"mainMenu", args, n);
    XtAddCallback(mainMenu, XmNhelpCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_MENUBAR);
    XtManageChild(mainMenu);

    /* create the pulldown widgets */
    n = 0;
    filePulldown= XmCreatePulldownMenu(mainMenu,"fileMenu", args, n );
    XtAddCallback(filePulldown, XmNhelpCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_FILE_MENU);

    n = 0;
    helpPulldown= XmCreatePulldownMenu(mainMenu, "helpMenu" , args, n );
    XtAddCallback(helpPulldown, XmNhelpCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_HELP_MENU);

    /* create the cascade butons */
    count = 0;

    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 2, "F"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString =  CMPSTR((char *)GETMESSAGE(4, 3, "File"));
    XtSetArg(args[n], XmNlabelString, labelString);  n++;
    XtSetArg(args[n], XmNsubMenuId, filePulldown); n++;
    XtSetArg (args[n], XmNmarginWidth, LB_MARGIN_WIDTH); n++;
    WidgList[count++]= 
        XmCreateCascadeButton(mainMenu, "fileCascadeButton", args, n );
    XtAddCallback(WidgList[count-1], XmNhelpCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_FILE_MENU);
    XmStringFree(labelString);

    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 4, "H"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString =  CMPSTR((char *)GETMESSAGE(4, 5, "Help"));
    XtSetArg(args[n], XmNlabelString, labelString); n++;
    XtSetArg(args[n], XmNsubMenuId, helpPulldown); n++;
    XtSetArg (args[n], XmNmarginWidth, 6); n++;
    WidgList[count++]= 
        XmCreateCascadeButton(mainMenu, "helpCascadeButton", args, n );
    XtAddCallback(WidgList[count-1], XmNhelpCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_HELP_MENU);
    XmStringFree(labelString);

    n = 0;
    XtSetArg(args[n], XmNmenuHelpWidget, WidgList[count-1]);    n++;
    XtSetValues (mainMenu, args, n);

    XtManageChildren (WidgList, count);

    /* create the File menu pane's buttons */
    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 53, "x"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString =  CMPSTR((char *)GETMESSAGE(4, 7, "Exit"));
    XtSetArg(args[n], XmNlabelString, labelString); n++;
    exitBtn= XmCreatePushButton(filePulldown, "exit", args, n );
    XtAddCallback(exitBtn, XmNactivateCallback, activateCB_exitBtn, NULL);
    XtAddCallback(exitBtn, XmNhelpCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_EXIT);
    XtManageChild(exitBtn);
    XmStringFree(labelString);

    /* create the Help menu pane's buttons */
    count =0;

    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 54, "v"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString = CMPSTR((char *)GETMESSAGE(4, 55, "Overview"));
    XtSetArg(args[n], XmNlabelString, labelString); n++;
    WidgList[count++]= 
        XmCreatePushButton(helpPulldown, "overview", args, n );
    XtAddCallback(WidgList[count-1], XmNactivateCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_INTRODUCTION);
    XmStringFree(labelString);

    n = 0;
    WidgList[count++]= 
        XmCreateSeparatorGadget(helpPulldown,"separator",args,n);
            
    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 43, "T"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString = CMPSTR((char *)GETMESSAGE(4, 56, "Tasks"));
    XtSetArg(args[n], XmNlabelString, labelString);  n++;
    WidgList[count++]= XmCreatePushButton(helpPulldown, "tasks", args, n );
    XtAddCallback(WidgList[count-1], XmNactivateCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TASKS);
    XmStringFree(labelString);

    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 45, "R"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString = CMPSTR((char *)GETMESSAGE(4, 57, "Reference"));
    XtSetArg(args[n], XmNlabelString, labelString);  n++;
    WidgList[count++]= XmCreatePushButton(helpPulldown, "reference", args, n );
    XtAddCallback(WidgList[count-1], XmNactivateCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_REFERENCE);
    XmStringFree(labelString);

    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 47, "O"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString = CMPSTR((char *)GETMESSAGE(4, 48, "On Item"));
    XtSetArg(args[n], XmNlabelString, labelString);  n++;
    WidgList[count++]= XmCreatePushButton(helpPulldown, "onItem", args, n );
    XtAddCallback(WidgList[count-1], XmNactivateCallback,
        (XtCallbackProc)HelpModeCB, (XtPointer)NULL);
    XmStringFree(labelString);

    n = 0;
    WidgList[count++] = 
        XmCreateSeparatorGadget(helpPulldown,"separator",args,n);

    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 49, "U"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString = CMPSTR((char *)GETMESSAGE(4, 58, "Using Help"));
    XtSetArg(args[n], XmNlabelString, labelString); n++;
    WidgList[count++]= 
        XmCreatePushButton(helpPulldown, "usingHelp", args, n );
    XtAddCallback(WidgList[count-1], XmNactivateCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_USING);
    XmStringFree(labelString);

    n = 0;
    WidgList[count++] = 
        XmCreateSeparatorGadget(helpPulldown,"separator",args,n);

    n = 0;
    mnemonic = ((char *)GETMESSAGE(4, 59, "A"));
    XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
    labelString = CMPSTR((char *)GETMESSAGE(4, 60, "About Style Manager"));
    XtSetArg(args[n], XmNlabelString, labelString); n++;
    WidgList[count++]= XmCreatePushButton(helpPulldown, "stylemanager", args, n );
    XtAddCallback(WidgList[count-1], XmNactivateCallback,
        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_VERSION);
    XmStringFree(labelString);

    XtManageChildren(WidgList, count);

    /*  create frame and row column for icon gadgets */
    n = 0;
    XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++;
    XtSetArg(args[n], XmNshadowType, XmSHADOW_OUT); n++;
    XtSetArg(args[n], XmNshadowThickness, 1); n++;
    frame = XmCreateFrame(style.mainWindow, "frame", args, n);
    XtManageChild(frame);
                           
    /* Save pixels for later use                                           */
    /* primary top/bottom shadow -> fg/bg for pixmaps in primary areas     */
    /* secondary top/bottom shadow -> fg/bg for pixmaps in secondary areas */
    /* secondary select color -> backgrounds of editable text areas        */
    /* secondary foreground ->  fill color on toggle indicators            */

    /*  Get the primary colors to be used later */
    n = 0;
    XtSetArg(args[n], XmNbackground, &bg); n++;
    XtGetValues(style.mainWindow, args, n);

    XmGetColors (style.screen, style.colormap, bg,
                 NULL,
                 &style.primTSCol,
                 &style.primBSCol,
                 NULL);

    /*  Get the secondary colors to be used later */
    n = 0;
    XtSetArg(args[n], XmNbackground, &style.secBgCol); n++;
    XtGetValues(exitBtn, args, n);

    XmGetColors (style.screen, style.colormap, style.secBgCol,
                 &style.tgSelectColor,
                 &style.secTSCol,
                 &style.secBSCol,
                 &style.secSelectColor);

    if ((style.secTSCol == style.secBSCol) || /* B_W or shadowPixmaps==True */
        (!style.useMultiColorIcons))          /* multiColorIcons turned off */
    {
        /* force TS = White, BS = Black */
        style.secTSCol = style.primTSCol = WhitePixelOfScreen(style.screen);
        style.secBSCol = style.primBSCol = BlackPixelOfScreen(style.screen);
    }
    
    XmeGetPixelData(style.screenNum, &colorUse, pixelSet, &a, &i, &p, &s);

    n = 0;
    if (colorUse == XmCO_BLACK_WHITE)
    {
    ditherPix = XmGetPixmap (style.screen, "50_foreground",
                             style.primBSCol,style.primTSCol);
    XtSetArg(args[n], XmNbackgroundPixmap, ditherPix); n++;
    }
    XtSetArg(args[n], XmNallowOverlap, False); n++;
    XtSetArg(args[n], XmNadjustLast, False); n++;
    XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
    XtSetArg(args[n], XmNspacing, style.horizontalSpacing); n++;
    mainRC = XmCreateRowColumn(frame, "mainRC", args, n);
    XtManageChild(mainRC);

    n = 0;
    XtSetArg(args[n], XmNmenuBar, mainMenu);    n++;
    XtSetArg(args[n], XmNcommandWindow, NULL);    n++;
    XtSetArg(args[n], XmNworkWindow, frame);    n++;
    XtSetValues (style.mainWindow, args, n);

    ProcessComponentList (shell, mainRC);

}
Beispiel #14
0
main (int argc, char *argv[])
{
    Widget         toplevel, text_w, form, rowcol, label_w;
    XtAppContext   app;
    int            i;
    void           print_result(Widget, XtPointer, XtPointer);
    Arg            args[8];
    int            n;

    XtSetLanguageProc (NULL, NULL, NULL);
    toplevel = XtVaAppInitialize (&app, "Demos", NULL, 0, &argc, argv, NULL,     
                                    sessionShellWidgetClass, NULL);

    rowcol = XmCreateRowColumn (toplevel, "rowcol", NULL, 0);

    for (i = 0; i < XtNumber (labels); i++) {
        n = 0;
        XtSetArg (args[n], XmNfractionBase, 10);       n++;
        XtSetArg (args[n], XmNnavigationType, XmNONE); n++;
        form = XmCreateForm (rowcol, "form", args, n);

        n = 0;
        XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);       n++;
        XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);    n++;
        XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);      n++;
        XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
        XtSetArg (args[n], XmNrightPosition, 3);                   n++;
        XtSetArg (args[n], XmNalignment, XmALIGNMENT_END);         n++;
        XtSetArg (args[n], XmNnavigationType, XmNONE);             n++;
        label_w = XmCreateLabelGadget (form, labels[i], args, n);
        XtManageChild (label_w);

        n = 0;
        XtSetArg (args[n], XmNtraversalOn, True);                 n++;
        XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
        XtSetArg (args[n], XmNleftPosition, 4);                   n++;
        XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);    n++;
        XtSetArg (args[n], XmNnavigationType, XmTAB_GROUP);       n++;
        text_w = XmCreateTextField (form, "text_w", args, n);
        XtManageChild (text_w);

        /* When user hits return, print the label+value of text_w */
        XtAddCallback (text_w, XmNactivateCallback, print_result, 
                            (XtPointer) labels[i]);
        XtManageChild (form);
    }

    XtManageChild (rowcol);
    XtRealizeWidget (toplevel);
    XtAppMainLoop (app);
}
Beispiel #15
0
void
ui_populate_pulldown_menu(
	Widget		menu,
	int		num_columns,
	MenuItem	*menu_items
)
{
    Widget	widget;
    Arg		args[4];
    int 	i;
    XmString	xmlabel;
    int		n = 0;

    if (!menu)
	return;

    if (num_columns > 1)
    {
    	XtSetArg(args[n], XmNpacking, XmPACK_COLUMN);    n++;
    	XtSetArg(args[n], XmNnumColumns, num_columns);   n++;

	XtSetValues(menu, args, n);
    }

    for (i = 0; menu_items[i].label != NULL; i++)
    {
        if (menu_items[i].subitems)
	{
	    widget = ui_build_menu(menu, XmMENU_PULLDOWN, 
				       menu_items[i].num_columns,
			               menu_items[i].label, 
				       menu_items[i].name,
				       (MenuItem *)menu_items[i].subitems);

	    XtVaSetValues(widget, XmNuserData, (XtArgVal)menu_items[i].user_data, NULL);
	}
	else
	{
	    widget = XtVaCreateManagedWidget(menu_items[i].name,
			         *menu_items[i].wclass, 
				  menu, 
                                  XmNuserData,    (XtArgVal)menu_items[i].user_data,
				  NULL);

	    if (menu_items[i].label != NULL)
	    {
		xmlabel = XmStringCreateLocalized(menu_items[i].label);
	  	XtVaSetValues(widget, XmNlabelString, xmlabel, NULL);
	    	XmStringFree(xmlabel);
	    }
	
	    /* If label is glyph type, then change type and call
	     * routine to set glyph.
	     */
	    if (menu_items[i].label_type == AB_LABEL_GLYPH)
	    {
        	XtVaSetValues(widget, XmNlabelType, XmPIXMAP, NULL);
		dtb_set_label_from_bitmap_data(widget,
				menu_items[i].pixwidth,
				menu_items[i].pixheight,
				menu_items[i].bits);

	    }
	}

	if (menu_items[i].active == FALSE)
	    XtSetSensitive(widget, FALSE);
 	else if (menu_items[i].callback != NULL)
	    XtAddCallback(widget, XmNactivateCallback, 
				menu_items[i].callback, 
				menu_items[i].client_data);
   }

}
int do_hello_world( int argc, char *argv[], const char *printername, const char *toFile, const char *sample_string )
{
    XtAppContext         app;                                                   
    Widget               toplevel,                                              
                         shell,                                                 
                         print_shell,                                           
                         hello;                                                 
    long                 dpi_x = 0L,
                         dpi_y = 0L;                                                 
    char                 fontname[256]; /* BUG: is this really big enougth ? */ 
    XFontStruct         *textFont;                                              
    XmFontList           textFontList;                                          
    Cardinal             n;                                                     
    Arg                  args[10];                                              
    MyPrintCallbackData  mpcd;
       
    if( doPrint )
    {
      /* Get printer, either by "name" (foobar) or "name@display" (foobar@gaja:5) */
      if( XpuGetPrinter(printername, &pdpy, &pcontext) != 1 )
        Error(("XpuGetPrinter failure.\n"));
     
      /* Configure the print context (paper size, title etc.)
       * We must do this before creating any Xt widgets - otherwise they will
       * make wrong assuptions about fonts, resultions etc. ...
       */
      XpuSetJobTitle(pdpy, pcontext, "Simple Xprint XawPrintShell widget demo");
      
      /* Configuration done, set the context */
      XpSetContext(pdpy, pcontext);

      /* Get default printer resolution */   
      if( XpuGetResolution(pdpy, pcontext, &dpi_x, &dpi_y) != 1 )
      {
        fprintf(stderr, "No default resolution for printer '%s'\n", printername);
        XpuClosePrinterDisplay(pdpy, pcontext);
        return(EXIT_FAILURE);
      }

      pscreen = XpGetScreenOfContext(pdpy, pcontext);
    }
    else
    {
      pdpy = XOpenDisplay(NULL);
      if( !pdpy )
        Error(("XOpenDisplay failure.\n"));

      dpi_x = dpi_y = 0L;
      
      pscreen = XDefaultScreenOfDisplay(pdpy);
    }  

    toplevel = XawOpenApplication(&app, 
                                  pdpy, pscreen,
                                  "xpawprintshelldemo", "XpXawPrintShellDemo",
                                  applicationShellWidgetClass,
                                  &argc, argv);

    if( !toplevel )
      Error(("XawOpenApplication failure.\n"));

    if( doPrint )
    {
      n = 0;
      /* Override any geometry resource settings as XawPrintShell adjusts it's size
       * to the current page siue when |XawPrintLAYOUTMODE_DRAWABLEAREA| or
       * |XawPrintLAYOUTMODE_PAGESIZE| are used. */
      XtSetArg(args[n], XtNgeometry,    "+0+0");                          n++;
      XtSetArg(args[n], XawNlayoutMode, XawPrintLAYOUTMODE_DRAWABLEAREA); n++;
      print_shell = XtCreatePopupShell("myprintshell", 
                                       xawPrintShellWidgetClass, 
                                       toplevel, args, n);

      /* we're mapping/unmapping at start/end page time */
      XtSetMappedWhenManaged(print_shell, False);
      
      shell = print_shell;
    }
    else
    {
      shell = toplevel;
    }

    sprintf(fontname, "-adobe-courier-medium-r-normal--40-*-%ld-%ld-*-*-iso8859-1", dpi_x, dpi_y);
    textFont = XLoadQueryFont(pdpy, fontname);
    if( !textFont )
    {          
      sprintf(fontname, "-*-*-*-*-*-*-*-160-%ld-%ld-*-*-iso8859-1", dpi_x, dpi_y);
      textFont = XLoadQueryFont(pdpy, fontname);
    }
    if( !textFont )
      Error(("XLoadQueryFont failure.\n"));
    textFontList = XmFontListCreate(textFont, XmSTRING_DEFAULT_CHARSET);     

    n = 0;
    /* Make sure the cursor is off, current Xprt servers do not seem to like
     * blinking cursors that much... ;-/ */
    XtSetArg(args[n], XmNcursorPositionVisible, False);              n++;
    XtSetArg(args[n], XmNvalue,                 sample_string);      n++;
    XtSetArg(args[n], XmNfontList,              textFontList);       n++;
    XtSetArg(args[n], XmNeditMode,              XmMULTI_LINE_EDIT);  n++;
    
    hello = XmCreateText(shell, "mytext", args, n);
    if( !hello )
      Error(("XmCreateText failure.\n"));
      
    XtManageChild(hello);
    XtRealizeWidget(toplevel);
    XtRealizeWidget(shell);
    
    if( doPrint )
    {
      int   num_total_rows;
      short num_visible_rows;
      int   num_pages;

      pdpy      = XtDisplay(toplevel);
      pdrawable = XtWindow(toplevel);
      if( !pdpy || !pdrawable )
        Error(("No display.\n"));
      
      /* Make sure that the Xt machinery is really using the right screen (assertion) */
      if( XpGetScreenOfContext(XtDisplay(toplevel), pcontext) != XtScreen(toplevel) )
        Error(("Widget's screen != print screen. BAD.\n"));
                  
      /* Get number of rows visible per page and the number of total rows 
       * in the whole text widget... */
      n = 0;
      XtSetArg(args[n], XmNrows,       &num_visible_rows); n++ ;
      XtSetArg(args[n], XmNtotalLines, &num_total_rows);   n++ ;
      XtGetValues(hello, args, n);

      /* Take away one row to match the one-line overlapping used by the
       * "next-page" action proc */      
      num_visible_rows -= 1;

      /* Calculate the number of pages */
      num_pages = (num_total_rows+num_visible_rows-1) / num_visible_rows;
      Log(("Printing %d pages (num_total_rows=%d, num_visible_rows=%d)...\n", 
           num_pages, num_total_rows, num_visible_rows));
      
      /* Prepare our own context data for the print shell callbacks */
      mpcd.num_pages          = num_pages;
      mpcd.printshell_content = hello;
      mpcd.num_visible_rows   = num_visible_rows;
      mpcd.appcontext         = app;
      
      /* Setup the print shell callbacks... */
      XtAddCallback(print_shell,  XawNpageSetupCallback, PrintOnePageCB,  (XtPointer)&mpcd);
      XtAddCallback(print_shell,  XawNstartJobCallback,  PrintStartJobCB, NULL);
      XtAddCallback(print_shell,  XawNendJobCallback,    PrintEndJobCB,   (XtPointer)&mpcd);  

      /* ... and finally start the print job. */
      if( toFile )
      {
        printtofile_handle = XpuStartJobToFile(pdpy, pcontext, toFile);
        if( !printtofile_handle )
        {
          perror("XpuStartJobToFile failure");
          Error(("XpuStartJobToFile failure."));
        }
      }
      else
      {
        XpuStartJobToSpooler(pdpy);
      }
    }
    
    XtAppMainLoop(app);
    
    if( doPrint )
    {
      if( toFile )
      {
        if( XpuWaitForPrintFileChild(printtofile_handle) != XPGetDocFinished )
        {
          fprintf(stderr, "%s: Error while printing to file.\n", ProgramName);
        }
      }

      PrintSpoolerCommandResults(pdpy, pcontext);    

      /* We have to use XpDestroyContext() and XtCloseDisplay() instead
       * of XpuClosePrinterDisplay() to make libXt happy... */
      if( pcontext != None )
        XpDestroyContext(pdpy, pcontext);
      XtCloseDisplay(pdpy);
    }
   
    return EXIT_SUCCESS;
}
Beispiel #17
0
int MessageAvertissement(char *message, int typeMessage)
{   XEvent avrtEvent;
   Arg args[2];
   XmString label;
   Widget avrtWidgetParent;

   label = XmStringCreateLtoR(message, XmSTRING_DEFAULT_CHARSET);
   XtSetArg(args[0], XmNmessageString, label);
   
   switch(typeMessage)
      {
      case INFO:
      XtSetValues(infoWidget, args, 1);
      widgetCourant = infoWidget;
      break;
      
      case AVERTISSEMENT:
      XtSetValues(avrtWidget, args, 1);
      widgetCourant = avrtWidget;
      break;
      
      case OK_CANCEL:
      XtSetValues(okCancelWidget, args, 1);
      widgetCourant = okCancelWidget;
      break;
      }
   
   XmStringFree(label);
   
   avrtSelectionTerminee = False;
   
   DesactiverWidgetsControle();
   AjusterPositionForme(widgetCourant, xc.topLevel);
   
   XtManageChild(widgetCourant);
   FlusherTousLesEvenements();

   CheckColormap(widgetCourant);

   while (!avrtSelectionTerminee)
      {
      XtAppPeekEvent(SuperWidget.contexte, &(avrtEvent));
      switch(avrtEvent.type)
         {
         case ButtonPress:
         avrtWidgetParent =(Widget) TrouverWidgetParent(avrtEvent.xbutton.window);
         if (avrtWidgetParent == xc.topLevel)
            {
            XtAppNextEvent(SuperWidget.contexte, &(avrtEvent));
            XtDispatchEvent(&(avrtEvent));
            }
         else
            {
            XtAppNextEvent(SuperWidget.contexte, &(avrtEvent));
            }
         break;
         
         default:
         XtAppNextEvent(SuperWidget.contexte, &(avrtEvent));
         XtDispatchEvent(&(avrtEvent));
         break;
         }
      
      }
   ActiverWidgetsControle();
   return okCancel;
 
  }
Beispiel #18
0
void xtbin::xtbin_realize() {
  Arg args[2];
  int n;
  Widget top_widget;
  Widget embedded;
  XSetWindowAttributes attr;
  unsigned long mask;

  attr.bit_gravity = NorthWestGravity;
  attr.event_mask = 
    ButtonMotionMask |
    ButtonPressMask |
    ButtonReleaseMask |
    EnterWindowMask |
    ExposureMask |
    KeyPressMask |
    KeyReleaseMask |
    LeaveWindowMask |
    PointerMotionMask |
    StructureNotifyMask |
    VisibilityChangeMask |
    FocusChangeMask;

  attr.colormap         = xxlib_rgb_get_cmap(mXlibRgbHandle);
  attr.background_pixel = xxlib_rgb_xpixel_from_rgb(mXlibRgbHandle, 0xFFC0C0C0);
  attr.border_pixel     = xxlib_rgb_xpixel_from_rgb(mXlibRgbHandle, 0xFF646464);

#ifdef DEBUG  
  printf("attr.background_pixel = %lx, attr.border_pixel = %lx, parent_window = %x\n", 
         (long)attr.background_pixel,
         (long)attr.border_pixel, (int)parent_window);
#endif /* DEBUG */
  
  mask = CWBitGravity | CWEventMask | CWBorderPixel | CWBackPixel;

  if (attr.colormap)
    mask |= CWColormap;

  window = XCreateWindow(xtdisplay, parent_window,
                         x, y, width, height, 0, 
                         xxlib_rgb_get_depth(mXlibRgbHandle),
                         InputOutput, xxlib_rgb_get_visual(mXlibRgbHandle),
                         mask, &attr);
  XSetWindowBackgroundPixmap(xtdisplay, window, None);
  XSelectInput(xtdisplay, window, ExposureMask);

  XMapWindow(xtdisplay, window);
  XFlush(xtdisplay);

  top_widget = XtAppCreateShell("drawingArea", "Wrapper",
                                applicationShellWidgetClass, xtdisplay,
                                NULL, 0);

  xtwidget = top_widget;

  n = 0;
  XtSetArg(args[n], XtNheight, height); n++;
  XtSetArg(args[n], XtNwidth,  width);  n++;
  XtSetValues(top_widget, args, n);

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

  n = 0;
  XtSetArg(args[n], XtNheight, height); n++;
  XtSetArg(args[n], XtNwidth,  width);  n++;
  XtSetValues(embedded, args, n);

  oldwindow = top_widget->core.window;
  top_widget->core.window = window;

  XtRegisterDrawable(xtdisplay, window, top_widget);

  XtRealizeWidget(embedded);
  XtRealizeWidget(top_widget);
  XtManageChild(embedded);

  /* Now fill out the xtbin info */
  xtwindow = XtWindow(embedded);

  /* Suppress background refresh flashing */
  XSetWindowBackgroundPixmap(xtdisplay, XtWindow(top_widget), None);
  XSetWindowBackgroundPixmap(xtdisplay, XtWindow(embedded),   None);

  /* Listen to all Xt events */
  XSelectInput(xtdisplay, XtWindow(top_widget), 0x0fffff);
  XSelectInput(xtdisplay, XtWindow(embedded),   0x0fffff);

  sync();
}
Beispiel #19
0
int
main(int argc, char **argv)
{
  Widget	toplevel, form, mb, tf, sl, st, cb, menu, pb;
  XtAppContext	app;
  Arg		al[10];
  int		ac;

  XtSetLanguageProc(NULL, NULL, NULL);

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

  form = XtVaCreateManagedWidget("form", xmFormWidgetClass, toplevel,
		XmNwidth,		450,
		XmNheight,		300,
		XmNresizable,		True,
		XmNfractionBase,	3,
	NULL);

  mb = XtVaCreateManagedWidget("mb", xmRowColumnWidgetClass, form,
		XmNtopAttachment,	XmATTACH_FORM,
		XmNtopOffset,		0,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNleftOffset,		0,
		XmNrightAttachment,	XmATTACH_FORM,
		XmNrightOffset,		0,
		XmNrowColumnType,	XmMENU_BAR,
	NULL);

  tf = XtVaCreateManagedWidget("tf", xmTextFieldWidgetClass, form,
		XmNtopAttachment,	XmATTACH_WIDGET,
		XmNtopOffset,		0,
		XmNtopWidget,		mb,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNleftOffset,		0,
		XmNrightAttachment,	XmATTACH_FORM,
		XmNrightOffset,		0,
	NULL);

  ac = 0;
  XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  XtSetArg(al[ac], XmNtopWidget, tf); ac++;
  XtSetArg(al[ac], XmNtopOffset, 0); ac++;
  XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  XtSetArg(al[ac], XmNleftOffset, 0); ac++;
  XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
  XtSetArg(al[ac], XmNrightPosition, 1); ac++;
  XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
  sl = XmCreateScrolledList(form, "sl", al, ac);
  XtManageChild(sl);

  ac = 0;
  XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  XtSetArg(al[ac], XmNtopWidget, tf); ac++;
  XtSetArg(al[ac], XmNtopOffset, 0); ac++;
  XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  XtSetArg(al[ac], XmNleftWidget, XtParent(sl)); ac++;
  XtSetArg(al[ac], XmNleftOffset, 0); ac++;
  XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  XtSetArg(al[ac], XmNrightOffset, 0); ac++;
  XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
  st = XmCreateScrolledText(form, "st", al, ac);
  XtManageChild(st);

  ac = 0;
  menu = XmCreatePulldownMenu(mb, "menu", al, ac);

  cb = XtVaCreateManagedWidget("cb", xmCascadeButtonGadgetClass, mb,
		XmNsubMenuId,	menu,
	NULL);

  pb = XtVaCreateManagedWidget("quit", xmPushButtonGadgetClass, menu,
	NULL);
  XtAddCallback(pb, XmNactivateCallback, Quit, NULL);

  XtRealizeWidget(toplevel);
  {
  static XtWidgetGeometry Expected[] = {
  	{CWWidth | CWHeight,		0,	0,	450,	300,	0,0,0,	/* Form */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	0,	450,	31,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	5,	5,	28,	21,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	31,	450,	31,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	62,	150,	238,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	0,	150,	238,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	150,	62,	300,	238,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	223,	300,	15,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	0,	300,	219,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	0,	0,	0,	0,0,0,	/* two */},
};

  PrintDetails(toplevel, Expected);
  }

  XtAddCallback(st, XmNfocusCallback, Focus, "in");
  XtAddCallback(st, XmNlosingFocusCallback, Focus, "out");
  XtAddCallback(tf, XmNfocusCallback, Focus, "in");
  XtAddCallback(tf, XmNlosingFocusCallback, Focus, "out");

      LessTifTestMainLoop(toplevel);

  exit(0);
}
Beispiel #20
0
/*
 * Implementation
 */
XtPointer
MonitorConfig(XtPointer conf)
{
    XF86ConfMonitorPtr monitor = (XF86ConfMonitorPtr)conf;
    char monitor_name[48];
    Arg args[1];

    current_monitor = monitor;

    xf86info.cur_list = MONITOR;
    XtSetSensitive(back, xf86info.lists[MONITOR].cur_function > 0);
    XtSetSensitive(next, xf86info.lists[MONITOR].cur_function <
			 xf86info.lists[MONITOR].num_functions - 1);
    (xf86info.lists[MONITOR].functions[xf86info.lists[MONITOR].cur_function])
	(&xf86info);

    XawListUnhighlight(hlist);
    XawListUnhighlight(vlist);

    if (monitor != NULL) {
	XF86ConfScreenPtr screen = XF86Config->conf_screen_lst;
	char str[PARSER_RANGE_SIZE];

	XtSetArg(args[0], XtNstring, monitor->mon_identifier);
	XtSetValues(ident_widget, args, 1);

	while (screen != NULL) {
	    if (screen->scrn_monitor == monitor)
		break;

	    screen = (XF86ConfScreenPtr)(screen->list.next);
	}
	if (screen != NULL) {
	    oldcard = card = screen->scrn_device;
	    XtSetArg(args[0], XtNlabel, card->dev_identifier);
	}
	else {
	    oldcard = card = NULL;
	    XtSetArg(args[0], XtNlabel, "");
	}
	XtSetValues(cmenu, args, 1);

	mon_n_hsync = monitor->mon_n_hsync;
	memcpy(mon_hsync, monitor->mon_hsync,
	       sizeof(parser_range) * mon_n_hsync);
	*str = '\0';
	parser_range_to_string(str, mon_hsync, mon_n_hsync);
	XtSetArg(args[0], XtNstring, str);
	XtSetValues(hsync, args, 1);

	mon_n_vrefresh = monitor->mon_n_vrefresh;
	memcpy(mon_vrefresh, monitor->mon_vrefresh,
	       sizeof(parser_range) * mon_n_vrefresh);
	*str = '\0';
	parser_range_to_string(str, mon_vrefresh, mon_n_vrefresh);
	XtSetArg(args[0], XtNstring, str);
	XtSetValues(vsync, args, 1);
    }
    else {
	XF86ConfMonitorPtr monitor = XF86Config->conf_monitor_lst;
	int nmonitors = 0;

	oldcard = card = NULL;
	while (monitor != NULL) {
		++nmonitors;
	    monitor = (XF86ConfMonitorPtr)(monitor->list.next);
	}
	do {
	    XmuSnprintf(monitor_name, sizeof(monitor_name),
			"Monitor%d", nmonitors);
	    ++nmonitors;
	} while (xf86findMonitor(monitor_name,
		 XF86Config->conf_monitor_lst));

	XtSetArg(args[0], XtNstring, monitor_name);
	XtSetValues(ident_widget, args, 1);

	XtSetArg(args[0], XtNstring, "");
	XtSetValues(hsync, args, 1);
	XtSetValues(vsync, args, 1);

	XtSetArg(args[0], XtNlabel, "");
	XtSetValues(cmenu, args, 1);
    }

    if (ConfigLoop(MonitorConfigCheck) == True) {
	if (monitor == NULL) {
	    monitor = (XF86ConfMonitorPtr)
		XtCalloc(1, sizeof(XF86ConfMonitorRec));
	    monitor->mon_identifier = XtNewString(ident_string);
	}

	memcpy(monitor->mon_hsync, mon_hsync, sizeof(parser_range) *
	       (monitor->mon_n_hsync = mon_n_hsync));
	memcpy(monitor->mon_vrefresh, mon_vrefresh, sizeof(parser_range) *
	       (monitor->mon_n_vrefresh = mon_n_vrefresh));

	if (strcasecmp(monitor->mon_identifier, ident_string))
	    xf86renameMonitor(XF86Config, monitor, ident_string);

	if (oldcard != card) {
	    int i;

	    for (i = 0; i < computer.num_devices; i++)
		if (computer.devices[i]->widget == config)
		    break;
	    if (computer.devices[i]->config == NULL)
		XF86Config->conf_monitor_lst =
				xf86addMonitor(XF86Config->conf_monitor_lst,
					       monitor);
	    computer.devices[i]->config = (XtPointer)monitor;
	    ChangeScreen(monitor, monitor, card, oldcard);
	    DrawCables();
	}

	return (monitor);
    }

    return (NULL);
}
Beispiel #21
0
void
MonitorLayout(XF86SetupInfo *info)
{
    static int first = 1, men;
    static Widget layout, menu;
    XF86ConfDevicePtr device = XF86Config->conf_device_lst;
    Widget sme;
    Arg args[1];
    char *menuname;

    if (first) {
	Widget viewport;

	first = 0;

	layout = XtCreateWidget("monitorl", formWidgetClass,
				configp, NULL, 0);
	XtCreateManagedWidget("hlabel", labelWidgetClass, layout, NULL, 0);
	hsync = XtVaCreateManagedWidget("hsync", asciiTextWidgetClass, layout,
					XtNeditType, XawtextEdit,
					NULL, 0);
	viewport = XtCreateManagedWidget("hviewport", viewportWidgetClass,
					 layout, NULL, 0);
	hlist = XtVaCreateManagedWidget("hlist", listWidgetClass, viewport,
					XtNlist, hmodes,
					XtNnumberStrings, sizeof(hmodes) /
					sizeof(hmodes[0]), NULL, 0);
	XtAddCallback(hlist, XtNcallback, MonitorHsyncCallback, NULL);

	XtCreateManagedWidget("vlabel", labelWidgetClass, layout, NULL, 0);
	vsync = XtVaCreateManagedWidget("vsync", asciiTextWidgetClass, layout,
					XtNeditType, XawtextEdit,
					NULL, 0);
	viewport = XtCreateManagedWidget("vviewport", viewportWidgetClass,
					 layout, NULL, 0);
	vlist = XtVaCreateManagedWidget("vlist", listWidgetClass, viewport,
					XtNlist, vmodes,
					XtNnumberStrings, sizeof(vmodes) /
					sizeof(vmodes[0]), NULL, 0);
	XtAddCallback(vlist, XtNcallback, MonitorVsyncCallback, NULL);

	XtCreateManagedWidget("clabel", labelWidgetClass, layout, NULL, 0);
	cmenu = XtCreateManagedWidget("cmenu", menuButtonWidgetClass,
				      layout, NULL, 0);

	XtRealizeWidget(layout);
    }

    if (menu != NULL)
	XtDestroyWidget(menu);

    /*
     * swaps names because XtDestroyWidget will only really destroy it
     * when the code returns to XtAppMainLoop
     */
    menuname = men & 1 ? "mena" : "menb";
    menu = XtCreatePopupShell(menuname, simpleMenuWidgetClass,
			      cmenu, NULL, 0);
    XtSetArg(args[0], XtNmenuName, menuname);
    XtSetValues(cmenu, args, 1);
    ++men;
    sme = XtVaCreateManagedWidget("none", smeBSBObjectClass, menu,
				  NULL, 0);
    XtAddCallback(sme, XtNcallback, MonitorSelectCardCallback, NULL);

    while (device != NULL) {
	XF86ConfScreenPtr screen = XF86Config->conf_screen_lst;
	Widget sme;
	Bool sensitive = True;

	while (screen != NULL) {
	    if (screen->scrn_device == device) {
		sensitive = screen->scrn_monitor == NULL ||
			    screen->scrn_monitor == current_monitor;
		break;
	    }
	    screen = (XF86ConfScreenPtr)(screen->list.next);
	}
	sme = XtCreateManagedWidget(device->dev_identifier,
				    smeBSBObjectClass, menu,
				    NULL, 0);
	if (sensitive)
	    XtAddCallback(sme, XtNcallback, MonitorSelectCardCallback, device);
	XtSetSensitive(sme, sensitive);

	device = (XF86ConfDevicePtr)(device->list.next);
    }

    XtRealizeWidget(menu);

    XtChangeManagedSet(&current, 1, NULL, NULL, &layout, 1);
    current = layout;
}
Beispiel #22
0
static void CreateAnotherContainer()
{
    Widget        PopupShell;
    Widget        MainW2, menubar2, pulldown2, menu_btn2;
    Widget        CutPB2, CopyPB2, CopyLinkPB2, PastePB2, PasteLinkPB2;
    Widget        OtherContainer4;
    Widget        IconGad6, IconGad7, IconGad8, IconGad9, IconGad10;
    Cardinal      n;
    XmString      Label;
    Arg	          args[MAX_ARGS];

    /*
     * Create a Dialog Shell
     */
    n = 0;
    XtSetArg(args[n], XtNgeometry, "=375x375+400+300"); n++;
    XtSetArg(args[n], XtNallowShellResize, True); n++;
    PopupShell = XtCreatePopupShell("OtherContainer", 
				    topLevelShellWidgetClass, Shell1,
				    args, n);

    /*
     * Create a main window
     */
    n = 0;
    XtSetArg(args[n], XmNborderWidth, 2); n++;
    MainW2 = XmCreateMainWindow(PopupShell, "MainW2", args, n);
    XtManageChild(MainW2);

    /*
     * Create a menu bar with a pulldown menu for interacting with the 
     * clipboard
     */

    n = 0;
    menubar2 = XmCreateMenuBar(MainW2, "menubar2", args, n);
    XtManageChild(menubar2);

    n = 0;
    pulldown2 = XmCreatePulldownMenu(menubar2, "pulldown2", args, n);
    
    Label = XmStringCreate("Edit", XmSTRING_DEFAULT_CHARSET);
    n = 0;
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNsubMenuId, pulldown2);  n++;
    menu_btn2 = XmCreateCascadeButton(menubar2, "menu_btn2", args, n);
    XtManageChild(menu_btn2);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Cut", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    CutPB2 = XmCreatePushButtonGadget(pulldown2, "CutPB2", args, n);
    XtManageChild(CutPB2);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Copy", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    CopyPB2 = XmCreatePushButtonGadget(pulldown2, "CopyPB2", args, n);
    XtManageChild(CopyPB2);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Copy Link", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    CopyLinkPB2 = XmCreatePushButtonGadget(pulldown2, "CopyLinkPB2", args, n);
    XtManageChild(CopyLinkPB2);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Paste", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    PastePB2 = XmCreatePushButtonGadget(pulldown2, "PastePB2", args, n);
    XtManageChild(PastePB2);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Paste Link", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    PasteLinkPB2= XmCreatePushButtonGadget(pulldown2, "PasteLinkPB2", args, n);
    XtManageChild(PasteLinkPB2);
    XmStringFree(Label);
    
    /*
     * Create the container 
     */
    n = 0;
    XtSetArg(args[n], XmNwidth, 450); n++;
    XtSetArg(args[n], XmNheight, 450); n++;
    XtSetArg(args[n], XmNentryViewType, XmANY_ICON); n++;
    XtSetArg(args[n], XmNlayoutType, XmSPATIAL); n++;
    XtSetArg(args[n], XmNspatialStyle, XmNONE); n++;
    XtSetArg(args[n], XmNautomaticSelection, XmNO_AUTO_SELECT); n++;
    OtherContainer4 = XmCreateContainer(MainW2, "OtherContainer", args, n);
    XtManageChild(OtherContainer4);
    
    XtAddCallback(OtherContainer4, XmNconvertCallback, ConvertCB, NULL);
    XtAddCallback(OtherContainer4, XmNdestinationCallback, DestinationCB, 
		  NULL);

    XtAddCallback(CutPB2, XmNactivateCallback, CutCB, 
		  (XtPointer) OtherContainer4);
    XtAddCallback(CopyPB2, XmNactivateCallback, CopyCB, 
		  (XtPointer) OtherContainer4);
    XtAddCallback(CopyLinkPB2, XmNactivateCallback, CopyLinkCB,
		  (XtPointer) OtherContainer4);
    XtAddCallback(PastePB2, XmNactivateCallback, PasteCB, 
		  (XtPointer) OtherContainer4);
    XtAddCallback(PasteLinkPB2, XmNactivateCallback, PasteLinkCB, 
		  (XtPointer) OtherContainer4);
    n = 0;
    XtSetArg(args[n], XmNx, 50); n++;
    XtSetArg(args[n], XmNy, 50); n++;
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    IconGad6 = XmCreateIconGadget(OtherContainer4, "IconGad6", args, n);
    XtManageChild(IconGad6);
    
    n = 0;
    XtSetArg(args[n], XmNx, 150); n++;
    XtSetArg(args[n], XmNy, 150); n++;
    XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
    IconGad7 = XmCreateIconGadget(OtherContainer4, "IconGad7", args, n);
    XtManageChild(IconGad7);
    
    n = 0;
    XtSetArg(args[n], XmNx, 50); n++;
    XtSetArg(args[n], XmNy, 300); n++;
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    IconGad8 = XmCreateIconGadget(OtherContainer4, "IconGad8", args, n);
    XtManageChild(IconGad8);
    
    n = 0;
    XtSetArg(args[n], XmNx, 300); n++;
    XtSetArg(args[n], XmNy, 300); n++;
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    IconGad9 = XmCreateIconGadget(OtherContainer4, "IconGad9", args, n);
    XtManageChild(IconGad9);
    
    n = 0;
    XtSetArg(args[n], XmNx, 200); n++;
    XtSetArg(args[n], XmNy, 50); n++;
    XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
    IconGad10 = XmCreateIconGadget(OtherContainer4, "IconGad10", args, n);
    XtManageChild(IconGad10);
    
    XmMainWindowSetAreas(MainW2, menubar2, NULL, NULL, NULL, OtherContainer4);

    XtPopup(PopupShell, XtGrabNone);
}
Beispiel #23
0
XFE_ABNameGenTabView::XFE_ABNameGenTabView(XFE_Component *top,
					   XFE_View *view):
  XFE_PropertyTabView(top, view, XFE_AB_NAME_GENERAL_TAB)
{

  int ac, numForms = AB_LAST+2;
  Arg    av[20];
  Widget topForm = getBaseWidget(),
         label = NULL,
         stripForm[AB_LAST+2];
  char *genTabLabels[AB_LAST+1];
  Dimension width;

  genTabLabels[AB_FIRST_NAME] = XP_GetString(XFE_AB_FIRSTNAME);
  genTabLabels[AB_LAST_NAME] = XP_GetString(XFE_AB_LASTNAME);
  genTabLabels[AB_DISPLAY_NAME] = XP_GetString(XFE_AB_DISPLAYNAME);

  genTabLabels[AB_EMAIL] = XP_GetString(XFE_AB_EMAIL);
  genTabLabels[AB_NICKNAME] = XP_GetString(XFE_AB_NICKNAME);

  genTabLabels[AB_TITLE] = XP_GetString(XFE_AB_TITLE);
  genTabLabels[AB_COMPANY_NAME] = XP_GetString(XFE_AB_COMPANY);
  genTabLabels[AB_LAST] = XP_GetString(XFE_AB_NOTES);

  int i; // for use in multiple for loops... 
         // without breaking newer ANSI C++ rules
  for (i=0; i < numForms; i++) {
    ac = 0;

    stripForm[i] = XmCreateForm(topForm, "strip", av, ac);
    if (i < (AB_LAST+1)) {
      /* Create labels
       */
      label = XtVaCreateManagedWidget (genTabLabels[i],
									   xmLabelGadgetClass, stripForm[i],
									   XmNalignment, XmALIGNMENT_END, 
									   NULL);
	  m_labels[i] = label;
      XtVaSetValues(label, 
					XmNleftAttachment, XmATTACH_FORM,
					XmNtopAttachment, XmATTACH_FORM,
					XmNrightAttachment, XmATTACH_NONE,
					XmNbottomAttachment, XmATTACH_FORM,
					0);
	  XtVaGetValues(label, 
					XmNwidth, &width,
					0);

	  m_labelWidth = (m_labelWidth < width)?width:m_labelWidth;

      /* TextF / Text
       */
      if (i < AB_LAST) {
		  /* TextF
		   */
		  ac = 0;
		  m_textFs[i] = fe_CreateTextField(stripForm[i], 
										  (char *) genTabLabels[i],
										  av, ac);
		  XtVaSetValues(m_textFs[i], 
						XmNleftAttachment, XmATTACH_WIDGET,
						XmNleftWidget, label,
						XmNtopAttachment, XmATTACH_FORM,
						XmNrightAttachment, XmATTACH_FORM,
						XmNbottomAttachment, XmATTACH_FORM,
						0);
		  XtManageChild(m_textFs[i]);
      }/* if */
      else {
		  /* Text
		   */
		  ac = 0;
		  XtSetArg (av[ac], XmNheight, 100); ac++;
		  XtSetArg (av[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
		  m_notesTxt = fe_CreateText(stripForm[i], "notesText", av, ac);
		  XtVaSetValues(m_notesTxt, 
						XmNleftAttachment, XmATTACH_WIDGET,
						XmNleftWidget, label,
						XmNtopAttachment, XmATTACH_FORM,
						XmNrightAttachment, XmATTACH_FORM,
						XmNbottomAttachment, XmATTACH_FORM,
						0);
		  XtManageChild(m_notesTxt);
		  
      }/* else */
    }/* if */
    else {
		/* the toggle */
		XmString xmstr;
		xmstr = XmStringCreate(XP_GetString(XFE_AB_PREFHTML),
							   XmFONTLIST_DEFAULT_TAG);
		ac = 0;
		XtSetArg (av[ac], XmNlabelString, xmstr); ac++;
		m_prefHTMLTog = XmCreateToggleButton(stripForm[i], "prefHTMLTog", 
											 av, ac);
		XtVaSetValues(m_prefHTMLTog, 
					  XmNleftAttachment, XmATTACH_FORM,
					  XmNleftOffset, m_labelWidth,
					  XmNtopAttachment, XmATTACH_FORM,
					  XmNrightAttachment, XmATTACH_NONE,
					  XmNbottomAttachment, XmATTACH_FORM,
					  0);
		XtManageChild(m_prefHTMLTog);
		
    }/* else */
    if (i == 0)
		XtVaSetValues(stripForm[i], 
					  XmNleftAttachment, XmATTACH_FORM,
					  XmNrightAttachment, XmATTACH_FORM,
					  XmNtopAttachment, XmATTACH_FORM,
					  XmNtopOffset, 10,
					  0);
    else
		XtVaSetValues(stripForm[i], 
					  XmNleftAttachment, XmATTACH_FORM,
					  XmNrightAttachment, XmATTACH_FORM,
					  XmNtopAttachment, XmATTACH_WIDGET,
					  XmNtopWidget, stripForm[i-1],
					  XmNtopOffset, (i == AB_TITLE || 
									 i == AB_EMAIL || 
									 i == AB_LAST)?10:3,
									 0);
					  XtManageChild(stripForm[i]);
  }/* for i */
  for (i=0; i < (AB_LAST+1); i++) {
	  XtVaSetValues(m_labels[i], 
					XmNwidth, m_labelWidth,
					0);
  }/* for i */

}
Beispiel #24
0
/**************************************************************
 * DaCreateGui:
 **************************************************************/
Widget DaCreateGui(char    * name,
		   char    * aclass,
		   int       argc,
		   char   ** argv,
		   Display * display)
{
  Arg args[15];
  Widget widget_array[10];
  int n;

  /***************** object of type : ApplicationShell *****************/
  n = 0;
  /* Setup argc & argv attribute */
  XtSetArg(args[n], XtNargc, argc); n++;
  XtSetArg(args[n], XtNargv, argv); n++;

  widget_array[WI_DAINPUT] = 
    XtAppCreateShell(name, aclass, applicationShellWidgetClass,
		     display, args, n);

  /***************** mainWindow : XmMainWindow *****************/
  widget_array[WI_MAINWINDOW] =
    XmCreateMainWindow(widget_array[WI_DAINPUT], "mainWindow", NULL, 0);

  /***************** menuBar : XmMenuBar *****************/
  widget_array[WI_MENUBAR] =
    XmCreateMenuBar(widget_array[WI_MAINWINDOW], "menuBar", NULL, 0);

  /***************** File : XmCascadeButton *****************/
  widget_array[WI_FILE] =
    XmCreateCascadeButton(widget_array[WI_MENUBAR], "File", NULL, 0);

  /***************** fileMenu : XmPulldownMenu *****************/
  widget_array[WI_FILEMENU] =
    XmCreatePulldownMenu(widget_array[WI_MENUBAR], "fileMenu", NULL, 0);
  {
    Arg args[1];
    XtSetArg(args[0], XmNsubMenuId, widget_array[WI_FILEMENU]);
    XtSetValues(widget_array[WI_FILE], args, 1);
  }

  /***************** Exit : XmPushButton *****************/
  widget_array[WI_EXIT] =
    XmCreatePushButton(widget_array[WI_FILEMENU], "Exit", NULL, 0);

  XtAddCallback(widget_array[WI_EXIT], 
		XmNactivateCallback, DaExit, NULL);

  /***************** Help : XmCascadeButton *****************/
  widget_array[WI_HELP] =
    XmCreateCascadeButton(widget_array[WI_MENUBAR], "Help", NULL, 0);

  /***************** helpMenu : XmPulldownMenu *****************/
  widget_array[WI_HELPMENU] =
    XmCreatePulldownMenu(widget_array[WI_MENUBAR], "helpMenu", NULL, 0);
  {
    Arg args[1];
    XtSetArg(args[0], XmNsubMenuId, widget_array[WI_HELPMENU]);
    XtSetValues(widget_array[WI_HELP], args, 1);
  }

  /***************** Overview : XmPushButton *****************/
  widget_array[WI_OVERVIEW] =
    XmCreatePushButton(widget_array[WI_HELPMENU], "Overview", NULL, 0);

  XtAddCallback(widget_array[WI_OVERVIEW], 
		XmNactivateCallback, DaOverView, NULL);

  /***************** workArea : XmDrawingArea *****************/
  n = 0;
  XtSetArg(args[n], XmNwidth, 300); n++;
  XtSetArg(args[n], XmNheight, 35); n++;
  widget_array[WI_WORKAREA] =
    XmCreateDrawingArea(widget_array[WI_MAINWINDOW], "workArea", args, n);

  /* 
   * Register drawing area for input method support and set input 
   * context values.
   */
  XmImRegister(widget_array[WI_WORKAREA], 0);
  {
    Pixel bg, fg;
    Pixmap bg_pixmap;
    n = 0;
    XtSetArg(args[n], XmNbackground, &bg); n++;
    XtSetArg(args[n], XmNforeground, &fg); n++;
    XtSetArg(args[n], XmNbackgroundPixmap, &bg_pixmap);n++;
    XtGetValues(widget_array[WI_WORKAREA], args, n);
    n = 0;
    XtSetArg(args[n], XmNbackground, bg); n++;
    XtSetArg(args[n], XmNforeground, fg); n++;
    XtSetArg(args[n], XmNbackgroundPixmap, bg_pixmap);n++;
    XmImSetValues(widget_array[WI_WORKAREA], args, n);
  }

  /* 
   * Add event handler for focus events. This is needed for the
   * input method to correctly display the input area.
   */
  XtAddEventHandler(widget_array[WI_WORKAREA], 
		    EnterWindowMask|LeaveWindowMask|FocusChangeMask, 
		    False, DaFocusHandler, NULL);

  XtAddCallback(widget_array[WI_WORKAREA],
		XmNexposeCallback, DaRedrawText, NULL);

  XtAddCallback(widget_array[WI_WORKAREA],
		XmNinputCallback, DaInputText, NULL);

  XtAddCallback(widget_array[WI_WORKAREA],
		XmNresizeCallback, DaResizedText, NULL);


  /***************** menuBar : XmMenuBar *****************/
  n = 0;
  XtSetArg(args[n], XmNmenuHelpWidget, widget_array[WI_HELP]); n++;
  XtSetValues(widget_array[WI_MENUBAR], args, n);


  XtManageChild(widget_array[WI_EXIT]);
  XtManageChild(widget_array[WI_FILE]);
  XtManageChild(widget_array[WI_OVERVIEW]);
  XtManageChild(widget_array[WI_HELP]);
  XtManageChild(widget_array[WI_MENUBAR]);
  XtManageChild(widget_array[WI_WORKAREA]);
  XtManageChild(widget_array[WI_MAINWINDOW]);

  /*
   *   Return the first created widget.
   */
  return widget_array[WI_DAINPUT];
}
Beispiel #25
0
void
main(int argc, char **argv)
{
    int    		i,j;
    Cardinal		n;
    XmString            Label;
    Arg			args[MAX_ARGS];
    int			test_num;
    char		test_char;
    char		ContainerName[NAME_LEN + 1];
    
    ContainerName[0] = '\0';
    test_num = 0;
    test_char = '\0';
    
    CommonTestInit(argc, argv);

    if (UserData != NULL) {
	
	if (strcmp(UserData, "a") == 0) 
	    test_num = 1;
	else if (strcmp(UserData, "b") == 0) 
	    test_num = 2;
	else if (strcmp(UserData, "c") == 0) 
	    test_num = 3;
	else if (strcmp(UserData, "d") == 0) 
	    test_num = 4;
	
	test_char = *UserData;
	
	free(UserData);
	
    }
    sprintf(ContainerName, "Container4%c", test_char);

    /*
     * Create a main window
     */
    n = 0;
    XtSetArg(args[n], XmNborderWidth, 2); n++;
    MainW1 = XmCreateMainWindow(Shell1, "MainW1", args, n);
    XtManageChild(MainW1);

    /*
     * Create a menu bar with a pulldown menu for interacting with the 
     * clipboard
     */

    n = 0;
    menubar1 = XmCreateMenuBar(MainW1, "menubar1", args, n);
    XtManageChild(menubar1);

    n = 0;
    pulldown1 = XmCreatePulldownMenu(menubar1, "pulldown1", args, n);
    
    Label = XmStringCreate("Edit", XmSTRING_DEFAULT_CHARSET);
    n = 0;
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNsubMenuId, pulldown1);  n++;
    menu_btn1 = XmCreateCascadeButton(menubar1, "menu_btn1", args, n);
    XtManageChild(menu_btn1);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Cut", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    CutPB1 = XmCreatePushButtonGadget(pulldown1, "CutPB1", args, n);
    XtManageChild(CutPB1);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Copy", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    CopyPB1 = XmCreatePushButtonGadget(pulldown1, "CopyPB1", args, n);
    XtManageChild(CopyPB1);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Copy Link", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    CopyLinkPB1 = XmCreatePushButtonGadget(pulldown1, "CopyLinkPB1", args, n);
    XtManageChild(CopyLinkPB1);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Paste", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    PastePB1 = XmCreatePushButtonGadget(pulldown1, "PastePB1", args, n);
    XtManageChild(PastePB1);
    XmStringFree(Label);

    n = 0;
    Label = XmStringCreate("Paste Link", XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, Label);  n++;
    XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
    PasteLinkPB1= XmCreatePushButtonGadget(pulldown1, "PasteLinkPB1", args, n);
    XtManageChild(PasteLinkPB1);
    XmStringFree(Label);
    
    /*
     * Create the container 
     */

    ColumnHeadings = (XmStringTable) XtMalloc(NUM_COL * sizeof(XmString));

    for (i = 0; i < NUM_COL; i++)
	 ColumnHeadings[i] = XmStringGenerate(ColumnHeadingText[i],
					      NULL,
					      XmCHARSET_TEXT,
					      NULL);

    n = 0;
    XtSetArg(args[n], XmNdetailColumnHeading, ColumnHeadings); n++;
    XtSetArg(args[n], XmNdetailColumnHeadingCount, NUM_COL); n++;
    XtSetArg(args[n], XmNdetailOrderCount, NUM_COL-1); n++;
    Container4 = XmCreateContainer(MainW1, ContainerName, args, n);

    XtManageChild(Container4);
    
    XtAddCallback(Container4, XmNdefaultActionCallback, PrintChildrenCB, NULL);
    XtAddCallback(Container4, XmNconvertCallback, ConvertCB, NULL);
    XtAddCallback(Container4, XmNdestinationCallback, DestinationCB, NULL);

    XtAddCallback(CutPB1, XmNactivateCallback, CutCB, (XtPointer) Container4);
    XtAddCallback(CopyPB1, XmNactivateCallback, CopyCB, (XtPointer)Container4);
    XtAddCallback(CopyLinkPB1, XmNactivateCallback, CopyLinkCB, 
		  (XtPointer) Container4);
    XtAddCallback(PastePB1, XmNactivateCallback, PasteCB, 
		  (XtPointer) Container4);
    XtAddCallback(PasteLinkPB1, XmNactivateCallback, PasteLinkCB, 
		  (XtPointer) Container4);

    for (i=0; i<NUM_COL; i++)
      XmStringFree(ColumnHeadings[i]);
    XtFree((XtPointer) ColumnHeadings);

    EntryDetails = (XmStringTable *) XtMalloc(NUM_OBJ * sizeof(XmStringTable));
    
    for (i = 0; i < NUM_OBJ; i++) {
	ColumnHeadings = (XmStringTable)XtMalloc((NUM_COL-1) * sizeof(XmString));
	ColumnHeadings[0] = XmStringGenerate(FullTitleText[i],
					     NULL,
					     XmCHARSET_TEXT,
					     NULL);
	ColumnHeadings[1] = XmStringGenerate(FlavorText[i],
					     NULL,
					     XmCHARSET_TEXT,
					     NULL);
	ColumnHeadings[2] = XmStringGenerate(AgeText[i],
					     NULL,
					     XmCHARSET_TEXT,
					     NULL);
	EntryDetails[i] = ColumnHeadings;
    }


    n = 0;
    XtSetArg(args[n], XmNx, 100); n++;
    XtSetArg(args[n], XmNy, 100); n++;
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[0]); n++;
    IconGad1 = XmCreateIconGadget(Container4, "IconGad1", args, n);
    XtManageChild(IconGad1);
    
    n = 0;
    XtSetArg(args[n], XmNx, 200); n++;
    XtSetArg(args[n], XmNy, 200); n++;
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[1]); n++;
    IconGad2 = XmCreateIconGadget(Container4, "IconGad2", args, n);
    XtManageChild(IconGad2);
    
    n = 0;
    XtSetArg(args[n], XmNx, 300); n++;
    XtSetArg(args[n], XmNy, 100); n++;
    XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[2]); n++;
    IconGad3 = XmCreateIconGadget(Container4, "IconGad3", args, n);
    XtManageChild(IconGad3);
    
    n = 0;
    XtSetArg(args[n], XmNx, 50); n++;
    XtSetArg(args[n], XmNy, 400); n++;
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[3]); n++;
    IconGad4 = XmCreateIconGadget(Container4, "IconGad4", args, n);
    XtManageChild(IconGad4);
    
    n = 0;
    XtSetArg(args[n], XmNentryParent, IconGad3); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    XtSetArg(args[n], XmNdetail, EntryDetails[4]); n++;
    IconGad31 = XmCreateIconGadget(Container4, "IconGad31", args, n);
    XtManageChild(IconGad31);
    
    n = 0;
    XtSetArg(args[n], XmNentryParent, IconGad3); n++;
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[5]); n++;
    IconGad32 = XmCreateIconGadget(Container4, "IconGad32", args, n);
    XtManageChild(IconGad32);
    
    n = 0;
    XtSetArg(args[n], XmNentryParent, IconGad32); n++;
    XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[6]); n++;
    IconGad321 = XmCreateIconGadget(Container4, "IconGad321", args, n);
    XtManageChild(IconGad321);
    
    n = 0;
    XtSetArg(args[n], XmNentryParent, IconGad321); n++;
    XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[7]); n++;
    IconGad3211 = XmCreateIconGadget(Container4, "IconGad3211", args, n);
    XtManageChild(IconGad3211);
    
    n = 0;
    XtSetArg(args[n], XmNentryParent, IconGad3); n++;
    XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[8]); n++;
    IconGad33 = XmCreateIconGadget(Container4, "IconGad33", args, n);
    XtManageChild(IconGad33);
    
    n = 0;
    XtSetArg(args[n], XmNx, 70); n++;
    XtSetArg(args[n], XmNy, 420); n++;
    XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
    XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; 
    XtSetArg(args[n], XmNdetail, EntryDetails[9]); n++;
    IconGad5 = XmCreateIconGadget(Container4, "IconGad5", args, n);
    XtManageChild(IconGad5);
    
    XmMainWindowSetAreas(MainW1, menubar1, NULL, NULL, NULL, Container4);

    for (i = 0; i < NUM_OBJ; i++) {
	
	ColumnHeadings = EntryDetails[i];
	for (j = 0; j < NUM_COL-1; j++)
	    XmStringFree(ColumnHeadings[j]);
	XtFree((XtPointer)ColumnHeadings);
	
    }
    XtFree((XtPointer)EntryDetails);
    
    XtRealizeWidget(Shell1);
    
    CommonPause();

    CommonPause();

    XmContainerRelayout(Container4);
    CommonPause();

    if ((test_num == 1) || (test_num == 2)) {
	TestContainerReorder();
	CommonPause();
    }

    /*
     * Create another Container for UTM testing
     */
    CreateAnotherContainer();
    CommonPause();
    CommonPause();
    CommonPause();
    CommonPause();
    CommonPause();
    CommonPause();
    CommonPause();

    CommonPause();
    
    XtAppMainLoop(app_context);
    
}
void display_tabular_data ()
{
	Widget		form;
	Widget		rowcol;
	Widget		page;
	Arg		args [10];
	XmString	str;
	int		i;

	void	ttab_page_callback (Widget w, XtPointer client_data,
			XtPointer call_data);

	if (ttab_dialog != (Widget) NULL) {

	    XmListDeleteAllItems (ttab_list);

	} else {

	    ttab_dialog = XtVaCreatePopupShell ("Product Tabular Data",
		xmDialogShellWidgetClass,	draw_widget,
		XmNdeleteResponse,		XmDESTROY,
		NULL);

	    form = XtVaCreateWidget ("tabular_form",
		xmFormWidgetClass,	ttab_dialog,
		XmNforeground,		white_color,
		XmNbackground,		steelblue_color,
		NULL);

	    rowcol = XtVaCreateWidget ("tabular_rowcol",
		xmRowColumnWidgetClass,	form,
		XmNtopAttachment,	XmATTACH_FORM,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNrightAttachment,	XmATTACH_FORM,
		XmNorientation,		XmHORIZONTAL,
		XmNforeground,		white_color,
		XmNbackground,		steelblue_color,
		NULL);

	    page = XtVaCreateManagedWidget ("Previous Page",
		xmPushButtonWidgetClass,	rowcol,
		XmNforeground,		white_color,
		XmNbackground,		steelblue_color,
		NULL);

	    XtAddCallback (page,
		XmNactivateCallback, ttab_page_callback, (XtPointer) -1);

	    page = XtVaCreateManagedWidget ("Next Page",
		xmPushButtonWidgetClass,	rowcol,
		XmNforeground,		white_color,
		XmNbackground,		steelblue_color,
		NULL);

	    XtAddCallback (page,
		XmNactivateCallback, ttab_page_callback, (XtPointer) 1);

	    XtManageChild (rowcol);

	    XtSetArg (args [0], XmNvisibleItemCount, ttab->number_of_lines [0]);
	    XtSetArg (args [1], XmNtopWidget,        rowcol);
	    XtSetArg (args [2], XmNtopAttachment,    XmATTACH_WIDGET);
	    XtSetArg (args [3], XmNleftAttachment,   XmATTACH_WIDGET);
	    XtSetArg (args [4], XmNrightAttachment,  XmATTACH_WIDGET);
	    XtSetArg (args [5], XmNbottomAttachment, XmATTACH_WIDGET);
	    XtSetArg (args [6], XmNfontList,	 fontlist);
	    XtSetArg (args [7], XmNforeground,	 white_color);
	    XtSetArg (args [8], XmNbackground,	 seagreen_color);
	    XtSetArg (args [9], XmNwidth, 		 720);

	    ttab_list = XmCreateScrolledList (form,
		"ttab_scrolled_list",
		args,
		10);

	    XtManageChild (ttab_list);

	    XtManageChild (form);

	    XtPopup (ttab_dialog, XtGrabNone);

	}

	current_page = 0;

	for (i=0;i<=ttab->number_of_lines [current_page];i++) {

	    str = XmStringCreate (ttab->text [current_page][i], "ttab_font");

	    XmListAddItemUnselected (ttab_list, str, i+1);

	    XmStringFree (str);

	}
}
Beispiel #27
0
int main (int argc, char **argv)
{
	int nTic1,nTic2,width,height;
	float smin,smax,bclip,wclip,x1beg,x1end,x2beg,x2end;
	char *edgecolor="cyan",*tricolor="yellow",*cmap="gray",
		*label1="",*label2="",*title="",
		*labelFont="",*titleFont="",
		*axesColor="",*gridColor="",*titleColor="",
		*style="seismic",*grid1="none",*grid2="none";
	Model *model;
	XrmValue from,to;
	ExposeCD exposeCD;
	Widget toplevel,axes;
	Display *dpy;
	Window win;
	Arg args[100];
	int nargs;
	float bhue=0,whue=240,sat=1,bright=1;

	/* initialize getpar */
	initargs(argc,argv);
        requestdoc(0);

	
	/* read model */
	model = readModel(stdin);
	
	/* determine minimum and maximum s(x,y) */
	minmax(model,&smin,&smax);
	
	/* get optional parameters */
	getparstring("edgecolor",&edgecolor);
	getparstring("tricolor",&tricolor);
	bclip = smin; getparfloat("bclip",&bclip);
	wclip = smax; getparfloat("wclip",&wclip);
        getparstring("cmap",&cmap);   

	/* initialize toolkit intrinsics and set toplevel parameters */
	toplevel = XtInitialize(argv[0],"Sxplot",NULL,0,&argc,argv);
	nargs = 0;
	if (getparint("width",&width))
		{XtSetArg(args[nargs],XtNwidth,width); nargs++;}
	if (getparint("height",&height))
		{XtSetArg(args[nargs],XtNheight,height); nargs++;}
	XtSetValues(toplevel,args,nargs);

	/* create axes and set axes parameters */
	axes = XtCreateManagedWidget("axes",xtcwpAxesWidgetClass,
		toplevel,NULL,0);


	nargs = 0;
	if (getparstring("grid1",&grid1)) {
		from.addr = (char *)grid1;
		XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesGrid,&to);
		if (to.addr) XtSetArg(args[nargs],XtNgrid1,*((int*)to.addr));
		nargs++;
	}
	if (getparstring("grid2",&grid2)) {
		from.addr = (char *)grid2;
		XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesGrid,&to);
		if (to.addr) XtSetArg(args[nargs],XtNgrid2,*((int*)to.addr));
		nargs++;
	}
	if (getparint("nTic1",&nTic1))
		{XtSetArg(args[nargs],XtNnTic1,nTic1); nargs++;}
	if (getparint("nTic2",&nTic2))
		{XtSetArg(args[nargs],XtNnTic2,nTic2); nargs++;}
	if (getparstring("label1",&label1))
		{XtSetArg(args[nargs],XtNlabel1,label1); nargs++;}
	if (getparstring("label2",&label2))
		{XtSetArg(args[nargs],XtNlabel2,label2); nargs++;}
	if (getparstring("title",&title))
		{XtSetArg(args[nargs],XtNtitle,title); nargs++;}
	if (getparstring("style",&style)) {
		from.size = (unsigned int) strlen(style);  from.addr = (char *)style;
		XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesStyle,&to);
		if (to.addr) XtSetArg(args[nargs],XtNstyle,*((int*)to.addr));
		nargs++;
	}
	if (getparstring("axesColor",&axesColor)) {
		from.addr = (char *)axesColor;
		XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to);
		if (to.addr) XtSetArg(args[nargs],XtNaxesColor,
			*((unsigned long*)to.addr));
		nargs++;
	}
	if (getparstring("gridColor",&gridColor)) {
		from.addr = (char *)gridColor;
		XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to);
		if (to.addr) XtSetArg(args[nargs],XtNgridColor,
			*((unsigned long*)to.addr));
		nargs++;
	}
	if (getparstring("titleColor",&titleColor)) {
		from.addr = (char *)titleColor;
		XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to);
		if (to.addr) XtSetArg(args[nargs],XtNtitleColor,
			*((unsigned long*)to.addr));
		nargs++;
	}
	if (getparstring("labelFont",&labelFont)) {
		from.addr = (char *)labelFont;
		XtConvertAndStore(axes,XtRString,&from,XtRFont,&to);
		if (to.addr) XtSetArg(args[nargs],XtNlabelFont,
			*((Font*)to.addr));
		nargs++;
	}
	if (getparstring("titleFont",&titleFont)) {
		from.addr = (char *)titleFont;
		XtConvertAndStore(axes,XtRString,&from,XtRFont,&to);
		if (to.addr) XtSetArg(args[nargs],XtNtitleFont,
			*((Font*)to.addr));
		nargs++;
	}
	XtSetValues(axes,args,nargs);
	x1beg = model->xmin; getparfloat("x1beg",&x1beg);
	x1end = model->xmax; getparfloat("x1end",&x1end);
	x2beg = model->ymin; getparfloat("x2beg",&x2beg);
	x2end = model->ymax; getparfloat("x2end",&x2end);
	XtcwpSetAxesValues(axes,x1beg,x1end,x2beg,x2end);

	/* add callbacks to axes widget */
	XtAddCallback(axes,XtNresizeCallback,(XtCallbackProc) resizeCB,NULL);
	exposeCD.model = model;
	exposeCD.edgecolor = edgecolor;
	exposeCD.tricolor = tricolor;
	exposeCD.bclip = bclip;
	exposeCD.wclip = wclip;
	XtAddCallback(axes,XtNexposeCallback,(XtCallbackProc) exposeCB,&exposeCD);
	XtAddCallback(axes,XtNinputCallback,(XtCallbackProc) inputCB,NULL);

	/* realize widgets */
	XtRealizeWidget(toplevel);

	/* if necessary, create private colormap */
	dpy = XtDisplay(toplevel);
	win = XtWindow(toplevel);

	if (STREQ(cmap,"gray")) {
	  XSetWindowColormap(dpy,win,XtcwpCreateGrayColormap(dpy,win));
	} else if (STREQ(cmap,"hue")) {
	  XSetWindowColormap(dpy,win,XtcwpCreateHueColormap(dpy,win,
														bhue,whue,sat,bright)); /* see Note below */
	}
	
	/* go */
	XtMainLoop();

	return EXIT_SUCCESS;
}
Beispiel #28
0
void getStartupPrefs(Widget mainWin)
{
    Widget       prefForm;
    Widget       portLabel;
    Widget       child;
    XmString     labelString;
    Arg          args[4];
    int          argcount;
    FILE         *confFile;
    char         serverPortNum[6];
    char    	 *confFilePath;


    argcount = 0;
    labelString = XM_STRING_CREATE("Startup Prefs");
    XtSetArg(args[argcount], XmNdialogTitle, labelString);
    argcount++;
    XtSetArg(args[argcount], XmNautoUnmanage, True);
    argcount++;
    startPrefDiag = XmCreatePromptDialog(mainWin, "startup_prefs", args, argcount);
    XmStringFree(labelString);

    /* Now get rid of the things we don't want */
    child = XmSelectionBoxGetChild(startPrefDiag, XmDIALOG_SELECTION_LABEL);
    XtUnmanageChild(child);
    child = XmSelectionBoxGetChild(startPrefDiag, XmDIALOG_TEXT);
    XtUnmanageChild(child);

    prefForm = XtVaCreateWidget("form", xmFormWidgetClass, startPrefDiag,
                                XmNfractionBase, 18, NULL);

    labelString = XM_STRING_CREATE("Name:");
    XtVaCreateManagedWidget("name_label",
                            xmLabelWidgetClass, prefForm,
                            XmNlabelString, labelString,
                            XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 0,
                            XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 0,
                            NULL);
    XmStringFree(labelString);

    labelString = XM_STRING_CREATE("Nick:");
    XtVaCreateManagedWidget("nick_label",
                            xmLabelWidgetClass, prefForm,
                            XmNlabelString, labelString,
                            XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 6,
                            XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 0,
                            NULL);
    XmStringFree(labelString);

    labelString = XM_STRING_CREATE("Server:");
    XtVaCreateManagedWidget("server_label",
                            xmLabelWidgetClass, prefForm,
                            XmNlabelString, labelString,
                            XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 12,
                            XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 0,
                            NULL);
    XmStringFree(labelString);


    nameTextForm = XtVaCreateManagedWidget("name_form",
                                           xmTextFieldWidgetClass, prefForm,
                                           XmNmaxLength, MAX_NAME_LEN,
                                           XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 0,
                                           XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 4,
                                           XmNrightAttachment, XmATTACH_POSITION, XmNrightPosition, 18,
                                           NULL);

    nickTextForm = XtVaCreateManagedWidget("nick_form",
                                           xmTextFieldWidgetClass, prefForm,
                                           XmNmaxLength, MAX_NICK_LEN,
                                           XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 6,
                                           XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 4,
                                           XmNrightAttachment, XmATTACH_POSITION, XmNrightPosition, 18,
                                           NULL);

    portTextForm = XtVaCreateManagedWidget("port_form",
                                           xmTextFieldWidgetClass, prefForm,
                                           XmNmaxLength, 5,
                                           XmNcolumns, 5,
                                           XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 12,
                                           XmNrightAttachment, XmATTACH_POSITION, XmNrightPosition, 18,
                                           NULL);

    labelString = XM_STRING_CREATE("Port: ");
    portLabel = XtVaCreateManagedWidget("port_label",
                                        xmLabelWidgetClass, prefForm,
                                        XmNlabelString, labelString,
                                        XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 12,
                                        XmNrightAttachment, XmATTACH_WIDGET, XmNrightWidget, portTextForm,
                                        NULL);
    XmStringFree(labelString);

    serverTextForm = XtVaCreateManagedWidget("server_form",
                     xmTextFieldWidgetClass, prefForm,
                     XmNmaxLength, MAX_SERVERNAME_LEN,
                     XmNtopAttachment, XmATTACH_POSITION, XmNtopPosition, 12,
                     XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 4,
                     XmNrightAttachment, XmATTACH_WIDGET, XmNrightWidget, portLabel,
                     NULL);


    XtAddCallback(startPrefDiag, XmNokCallback, okButtStartupCbk, NULL);
    XtAddCallback(startPrefDiag, XmNhelpCallback, helpButtStartupCbk, NULL);

    XtManageChild(prefForm);

    XtManageChild(startPrefDiag);

    /* read configuration file */
    if (confFilePath = getPreferencesFilePath())
    {
        confFile = fopen (confFilePath, "r");
        if (confFile)
        {
            char buff[FILE_BUFF_SIZE];
            char *pos;

            fgets(buff, FILE_BUFF_SIZE, confFile);
            if (buff[strlen(buff)-1] == '\n')
                buff[strlen(buff)-1] = '\0';
            if(!strncmp(buff, "DefaultNick", strlen("DefaultNick")))
                if (pos = strchr(buff, ' '))
                    strcpy(sysState.myNick, pos+1);
            fgets(buff, FILE_BUFF_SIZE, confFile);
            if (buff[strlen(buff)-1] == '\n')
                buff[strlen(buff)-1] = '\0';
            if(!strncmp(buff, "DefaultName", strlen("DefaultName")))
                if (pos = strchr(buff, ' '))
                    strcpy(sysState.myName, pos+1);
            fgets(buff, FILE_BUFF_SIZE, confFile);
            if (buff[strlen(buff)-1] == '\n')
                buff[strlen(buff)-1] = '\0';
            if(!strncmp(buff, "DefaultServer", strlen("DefaultServer")))
                if (pos = strchr(buff, ' '))
                    strcpy(sysState.serverName, pos+1);
            fgets(buff, FILE_BUFF_SIZE, confFile);
            if (buff[strlen(buff)-1] == '\n')
                buff[strlen(buff)-1] = '\0';
            if(!strncmp(buff, "DefaultPortNum", strlen("DefaultPortNum")))
                if (pos = strchr(buff, ' '))
                    strcpy(serverPortNum, pos+1);
            fclose(confFile);
        } else
        {
            printf("config file not found.\n");
            strcpy(sysState.myNick, "nebula_user");
            strcpy(sysState.myName, "Nebula User");
            strcpy(sysState.serverName, "irc.freenode.org");
            strcpy(serverPortNum, "6666");
        }
        free(confFilePath);
    }
    XmTextSetString(nickTextForm, sysState.myNick);
    XmTextSetString(nameTextForm, sysState.myName);
    XmTextSetString(serverTextForm, sysState.serverName);
    XmTextSetString(portTextForm, serverPortNum);
}
Beispiel #29
0
int wxMessageDialog::ShowModal()
{
    WX_HOOK_MODAL_DIALOG();

    const long style = GetMessageDialogStyle();

    DialogCreateFunction dialogCreateFunction;
    if ( style & wxYES_NO )
    {
        // if we have [Yes], it must be a question
        dialogCreateFunction = XmCreateQuestionDialog;
    }
    else if ( style & wxICON_STOP )
    {
        // error dialog is the one with error icon...
        dialogCreateFunction = XmCreateErrorDialog;
    }
    else if ( style & wxICON_EXCLAMATION )
    {
        // ...and the warning dialog too
        dialogCreateFunction = XmCreateWarningDialog;
    }
    else
    {
        // finally, use the info dialog by default
        dialogCreateFunction = XmCreateInformationDialog;
    }

    Widget wParent = m_parent ? GetWidget(m_parent) : (Widget) 0;
    if ( !wParent )
    {
        wxWindow *window = wxTheApp->GetTopWindow();
        if ( !window )
        {
            wxFAIL_MSG("can't show message box without parent window");

            return wxID_CANCEL;
        }

        wParent = GetWidget(window);
    }

    // prepare the arg list
    Arg args[10];
    int ac = 0;

    wxXmString text(GetFullMessage());
    wxXmString title(m_caption);
    XtSetArg(args[ac], XmNmessageString, text()); ac++;
    XtSetArg(args[ac], XmNdialogTitle, title()); ac++;

    Display* dpy = XtDisplay(wParent);

    if (m_backgroundColour.IsOk())
    {
        wxComputeColours (dpy, & m_backgroundColour, NULL);

        XtSetArg(args[ac], XmNbackground, g_itemColors[wxBACK_INDEX].pixel); ac++;
        XtSetArg(args[ac], XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel); ac++;
        XtSetArg(args[ac], XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel); ac++;
        XtSetArg(args[ac], XmNforeground, g_itemColors[wxFORE_INDEX].pixel); ac++;
    }

    wxFont font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);

#if __WXMOTIF20__ && !__WXLESSTIF__
    XtSetArg(args[ac], XmNbuttonRenderTable, font.GetFontTypeC(dpy)); ac++;
    XtSetArg(args[ac], XmNlabelRenderTable, font.GetFontTypeC(dpy)); ac++;
    XtSetArg(args[ac], XmNtextRenderTable, font.GetFontTypeC(dpy)); ac++;
#else
    XtSetArg(args[ac], XmNbuttonFontList, font.GetFontTypeC(dpy)); ac++;
    XtSetArg(args[ac], XmNlabelFontList, font.GetFontTypeC(dpy)); ac++;
    XtSetArg(args[ac], XmNtextFontList, font.GetFontTypeC(dpy)); ac++;
#endif

    // do create message box

    Widget wMsgBox = (*dialogCreateFunction)(wParent, wxMOTIF_STR(""), args, ac);

    wxCHECK_MSG( wMsgBox, wxID_CANCEL, "msg box creation failed" );

    // get the buttons which we might either remove or rename
    // depending on the requested style
    //
    Widget wBtnOk = XmMessageBoxGetChild(wMsgBox, XmDIALOG_OK_BUTTON);
    Widget wBtnHelp = XmMessageBoxGetChild(wMsgBox, XmDIALOG_HELP_BUTTON);
    Widget wBtnCancel = XmMessageBoxGetChild(wMsgBox, XmDIALOG_CANCEL_BUTTON);

    if ( style & wxYES_NO )
    {
        wxXmString yes(_("Yes")), no(_("No")), cancel(_("Cancel"));

        if ( style & wxCANCEL )
        {
            // use the cancel button for No and the help button for
            // Cancel  Yuk :-)  MB
            //
            XtVaSetValues(wBtnOk, XmNlabelString, yes(), NULL);
            XtVaSetValues(wBtnCancel, XmNlabelString, no(), NULL);
            XtVaSetValues(wBtnHelp, XmNlabelString, cancel(), NULL);
        }
        else
        {
            // no cancel button requested...
            // remove the help button and use cancel for no
            //
            XtVaSetValues(wBtnCancel, XmNlabelString, no(), NULL);
            XtUnmanageChild(wBtnHelp);
        }
    }
    else
    {
        // remove the help button and the cancel button (unless it was
        // requested)
        //
        XtUnmanageChild(wBtnHelp);
        if ( !(style & wxCANCEL ) ) XtUnmanageChild(wBtnCancel);
    }

    // set the callbacks for the message box buttons
    XtAddCallback(wMsgBox, XmNokCallback,
                  (XtCallbackProc)msgboxCallBackOk, (XtPointer)this);
    XtAddCallback(wMsgBox, XmNcancelCallback,
                  (XtCallbackProc)msgboxCallBackCancel, (XtPointer)this);
    XtAddCallback(wMsgBox, XmNhelpCallback,
                  (XtCallbackProc)msgboxCallBackHelp, (XtPointer)this);
    XtAddCallback(wMsgBox, XmNunmapCallback,
                  (XtCallbackProc)msgboxCallBackClose, (XtPointer)this);

    // show it as a modal dialog
    XtManageChild(wMsgBox);
    XtAddGrab(wMsgBox, True, False);

    // the m_result will be changed when message box goes away
    m_result = -1;

    // local message loop
    XtAppContext context = XtWidgetToApplicationContext(wParent);
    XEvent event;
    while ( m_result == -1 )
    {
        XtAppNextEvent(context, &event);
        XtDispatchEvent(&event);
    }

    // translate the result if necessary
    if ( style & wxYES_NO )
    {
        if ( m_result == wxID_OK )
            m_result = wxID_YES;
        else if ( m_result == wxID_CANCEL )
            m_result = wxID_NO;
        else if ( m_result == wxID_HELP )
            m_result = wxID_CANCEL;
    }

    return m_result;
}
Beispiel #30
-1
main(int argc, char *argv[])
{
    toplevel = XtAppInitialize(&app, "Paperplane", NULL, 0, &argc, argv,
                               fallbackResources, NULL, 0);
    dpy = XtDisplay(toplevel);
    /* find an OpenGL-capable RGB visual with depth buffer */
    vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
    if (vi == NULL) {
        vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
        if (vi == NULL)
            XtAppError(app, "no RGB visual with depth buffer");
        doubleBuffer = GL_FALSE;
    }
    /* create an OpenGL rendering context */
    cx = glXCreateContext(dpy, vi, /* no display list sharing */ None,
        /* favor direct */ GL_TRUE);
    if (cx == NULL)
        XtAppError(app, "could not create rendering context");
    /* create an X colormap since probably not using default visual */
#ifdef noGLwidget
    cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
        vi->visual, AllocNone);
    /*
     * Establish the visual, depth, and colormap of the toplevel
     * widget _before_ the widget is realized.
     */
    XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth,
                  XtNcolormap, cmap, NULL);
#endif
    XtAddEventHandler(toplevel, StructureNotifyMask, False,
                      map_state_changed, NULL);
    mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0);
    XtManageChild(mainw);
    /* create menu bar */
    menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0);
    XtManageChild(menubar);
#ifdef noGLwidget
    /* Hack around Xt's unfortunate default visual inheritance. */
    XtSetArg(menuPaneArgs[0], XmNvisual, vi->visual);
    menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
    menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
    btn = XmCreatePushButton(menupane, "Quit", NULL, 0);
    XtAddCallback(btn, XmNactivateCallback, quit, NULL);
    XtManageChild(btn);
    XtSetArg(args[0], XmNsubMenuId, menupane);
    cascade = XmCreateCascadeButton(menubar, "File", args, 1);
    XtManageChild(cascade);
#ifdef noGLwidget
    menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
    menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
    btn = XmCreateToggleButton(menupane, "Motion", NULL, 0);
    XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc)toggle, NULL);
    XtManageChild(btn);
    btn = XmCreatePushButton(menupane, "Add plane", NULL, 0);
    XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)add_plane, NULL);
    XtManageChild(btn);
    btn = XmCreatePushButton(menupane, "Remove plane", NULL, 0);
    XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)remove_plane, NULL);
    XtManageChild(btn);
    XtSetArg(args[0], XmNsubMenuId, menupane);
    cascade = XmCreateCascadeButton(menubar, "Planes", args, 1);
    XtManageChild(cascade);
    /* create framed drawing area for OpenGL rendering */
    frame = XmCreateFrame(mainw, "frame", NULL, 0);
    XtManageChild(frame);
#ifdef noGLwidget
    glxarea = XtVaCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass,
                                      frame, NULL);
#else
#ifdef noMotifGLwidget
    /* notice glwDrawingAreaWidgetClass lacks an 'M' */
    glxarea = XtVaCreateManagedWidget("glxarea", glwDrawingAreaWidgetClass,
#else
    glxarea = XtVaCreateManagedWidget("glxarea", glwMDrawingAreaWidgetClass,
#endif
                                      frame, GLwNvisualInfo, vi, NULL);
#endif
    XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc)draw, NULL);
    XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
    XtAddCallback(glxarea, XmNinputCallback, input, NULL);
    /* set up application's window layout */
    XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame);
    XtRealizeWidget(toplevel);
    /*
     * Once widget is realized (ie, associated with a created X window), we
     * can bind the OpenGL rendering context to the window.
     */
    glXMakeCurrent(dpy, XtWindow(glxarea), cx);
    made_current = GL_TRUE;
    /* setup OpenGL state */
    glClearDepth(1.0);
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 20);
    glMatrixMode(GL_MODELVIEW);
    /* add three initial random planes */
    srandom(getpid());
    add_plane(); add_plane(); add_plane(); add_plane(); add_plane();
    /* start event processing */
    toggle();
    XtAppMainLoop(app);
}