コード例 #1
0
ファイル: wb_wge_motif.cpp プロジェクト: Strongc/proview
WGeMotif::WGeMotif( Widget wge_parent_wid, void *wge_parent_ctx, char *wge_name, char *wge_filename,
	  int wge_scrollbar, int wge_menu, int wge_navigator, int wge_width, int wge_height, 
	  int x, int y, char *object_name, int wge_modal = 0) :
  WGe(wge_parent_ctx, wge_name, wge_filename, wge_scrollbar, wge_menu, wge_navigator, wge_width,
      wge_height, x, y, object_name, wge_modal),
  parent_wid(wge_parent_wid), value_dialog(0), set_focus_disabled(0), focus_timerid(0)
{
  pwr_tFileName	uid_filename = {"$pwr_exe/wb_wge.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  char 		title[300];
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  Widget	wge_widget;
  char		wname[] = "Proview/R Ge";

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

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

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

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

  dcli_translate_filename( uid_filename, uid_filename);

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

  // Motif
  MrmInitialize();

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

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


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

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

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

  MrmRegisterNames(reglist, reglist_num);

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

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

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

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

  MrmCloseHierarchy(s_DRMh);

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

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

  if ( !menu)
    XtUnmanageChild( menu_widget);

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

  if ( navigator)
  {
    // Create navigator popup

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

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

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

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

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

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

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

  /*
   * Now start the module creation
   */

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

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

  register_callbacks();

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

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

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

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

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

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

  XtSetValues( parent_wid, args, i);

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

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

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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

  gre->init();

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

  function_setup();

  MrmCloseHierarchy(s_MrmH);

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

  XtUnmanageChild(widgets.textinput);

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

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

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

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

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

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

  return FOE__SUCCESS;
}
コード例 #3
0
ファイル: ge_attr_motif.cpp プロジェクト: siamect/proview
AttrMotif::AttrMotif(Widget a_parent_wid, void* a_parent_ctx, void* a_object,
    attr_sItem* itemlist, int item_cnt)
    : Attr(a_parent_ctx, a_object, itemlist, item_cnt),
      parent_wid(a_parent_wid), value_current_recall(0)
{
  char uid_filename[120] = { "pwr_exe:ge_attr.uid" };
  char* uid_filename_p = uid_filename;
  Arg args[20];
  pwr_tStatus sts;
  char title[80];
  int i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  char name[] = "Proview/R Navigator";

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

  static XtActionsRec actions[]
      = { { (char*)"attr_inputfocus", (XtActionProc)attr_action_inputfocus } };

  static MrmRegisterArg reglist[] = { { (char*)"attr_ctx", 0 },
    { (char*)"attr_activate_exit", (caddr_t)attr_activate_exit },
    { (char*)"attr_activate_store", (caddr_t)attr_activate_store },
    { (char*)"attr_activate_recall_prev", (caddr_t)attr_activate_recall_prev },
    { (char*)"attr_activate_recall_next", (caddr_t)attr_activate_recall_next },
    { (char*)"attr_activate_change_value",
        (caddr_t)attr_activate_change_value },
    { (char*)"attr_activate_help", (caddr_t)attr_activate_help },
    { (char*)"attr_create_msg_label", (caddr_t)attr_create_msg_label },
    { (char*)"attr_create_cmd_prompt", (caddr_t)attr_create_cmd_prompt },
    { (char*)"attr_create_cmd_input", (caddr_t)attr_create_cmd_input },
    { (char*)"attr_create_cmd_scrolledinput",
        (caddr_t)attr_create_cmd_scrolledinput },
    { (char*)"attr_create_cmd_scrolled_ok",
        (caddr_t)attr_create_cmd_scrolled_ok },
    { (char*)"attr_create_cmd_scrolled_ca",
        (caddr_t)attr_create_cmd_scrolled_ca },
    { (char*)"attr_create_attrnav_form", (caddr_t)attr_create_attrnav_form },
    { (char*)"attr_activate_cmd_scrolledinput",
        (caddr_t)attr_activate_cmd_input },
    { (char*)"attr_activate_cmd_scrolled_ok",
        (caddr_t)attr_activate_cmd_scrolled_ok },
    { (char*)"attr_activate_cmd_scrolled_ca",
        (caddr_t)attr_activate_cmd_scrolled_ca } };

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

  {
    char* s;

    if ((s = getenv("pwr_exe")) == NULL) {
      printf("** pwr_exe is not defined\n");
      exit(0);
    }
    sprintf(uid_filename, "%s/ge_attr.uid", s);
  }

  // Motif
  MrmInitialize();

  strcpy(title, "PROVIEW/R Attr");

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

  // 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);

  parent_wid = XtCreatePopupShell(
      "objectEditor", topLevelShellWidgetClass, a_parent_wid, args, 0);

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

  MrmCloseHierarchy(s_DRMh);

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

  if (compiled_translations == NULL)
    compiled_translations = XtParseTranslationTable(translations);
  XtOverrideTranslations(toplevel, compiled_translations);

  i = 0;
  XtSetArg(args[i], XmNwidth, 500);
  i++;
  XtSetArg(args[i], XmNheight, 700);
  i++;
  XtSetValues(toplevel, args, i);

  XtManageChild(toplevel);
  XtUnmanageChild(cmd_input);
  XtUnmanageChild(cmd_scrolledinput);
  XtUnmanageChild(cmd_scrolled_ok);
  XtUnmanageChild(cmd_scrolled_ca);

  attrnav = new AttrNavMotif(
      this, attrnav_form, "Plant", itemlist, item_cnt, &brow_widget, &sts);
  ((AttrNav*)attrnav)->message_cb = &Attr::message;
  ((AttrNav*)attrnav)->change_value_cb = &Attr::change_value_c;
  ((AttrNav*)attrnav)->get_subgraph_info_cb = &Attr::get_subgraph_info_c;
  ((AttrNav*)attrnav)->get_dyn_info_cb = &Attr::get_dyn_info_c;
  ((AttrNav*)attrnav)->reconfigure_attr_cb = &Attr::reconfigure_attr_c;
  ((AttrNav*)attrnav)->get_plant_select_cb = &Attr::get_plant_select_c;
  ((AttrNav*)attrnav)->get_current_colors_cb = &Attr::get_current_colors_c;

  XtPopup(parent_wid, XtGrabNone);

  // Connect the window manager close-button to exit
  flow_AddCloseVMProtocolCb(
      parent_wid, (XtCallbackProc)attr_activate_exit, this);
}
コード例 #4
0
WdaMotif::WdaMotif( 
	Widget 		wa_parent_wid,
	void 		*wa_parent_ctx, 
	ldh_tSesContext wa_ldhses, 
	pwr_tObjid 	wa_objid,
	pwr_tClassId 	wa_classid,
	const char      *wa_attribute,
	int 		wa_editmode,
	int 		wa_advanced_user,
	int		wa_display_objectname) :
  Wda(wa_parent_ctx,wa_ldhses,wa_objid,wa_classid,wa_attribute,wa_editmode,
      wa_advanced_user,wa_display_objectname), 
  parent_wid(wa_parent_wid), set_focus_disabled(0), value_current_recall(0)
{
  char		uid_filename[120] = {"pwr_exe:wb_wda.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  char 		title[80];
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  char		name[] = "Proview/R Navigator";

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

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

  static MrmRegisterArg	reglist[] = {
        {(char*) "wda_ctx", 0 },
	{(char*) "wda_activate_setclass",(caddr_t)activate_setclass },
	{(char*) "wda_activate_setattr",(caddr_t)activate_setattr },
	{(char*) "wda_activate_nextattr",(caddr_t)activate_nextattr },
	{(char*) "wda_activate_prevattr",(caddr_t)activate_prevattr },
	{(char*) "wda_activate_exit",(caddr_t)activate_exit },
	{(char*) "wda_activate_print",(caddr_t)activate_print },
	{(char*) "wda_activate_change_value",(caddr_t)activate_change_value },
	{(char*) "wda_activate_close_changeval",(caddr_t)activate_close_changeval },
	{(char*) "wda_activate_help",(caddr_t)activate_help },
	{(char*) "wda_create_msg_label",(caddr_t)create_msg_label },
	{(char*) "wda_create_cmd_prompt",(caddr_t)create_cmd_prompt },
	{(char*) "wda_create_cmd_input",(caddr_t)create_cmd_input },
	{(char*) "wda_create_cmd_scrolledinput",(caddr_t)create_cmd_scrolledinput },
	{(char*) "wda_create_cmd_scrolled_ok",(caddr_t)create_cmd_scrolled_ok },
	{(char*) "wda_create_cmd_scrolled_ca",(caddr_t)create_cmd_scrolled_ca },
	{(char*) "wda_create_wdanav_form",(caddr_t)create_wdanav_form },
	{(char*) "wda_activate_cmd_scrolledinput",(caddr_t)activate_cmd_input },
	{(char*) "wda_activate_cmd_scrolled_ok",(caddr_t)activate_cmd_scrolled_ok },
	{(char*) "wda_activate_cmd_scrolled_ca",(caddr_t)activate_cmd_scrolled_ca },
	{(char*) "wdaclass_activate_ok",(caddr_t)class_activate_ok },
	{(char*) "wdaclass_activate_cancel",(caddr_t)class_activate_cancel },
	{(char*) "wdaclass_create_hiervalue",(caddr_t)class_create_hiervalue },
	{(char*) "wdaclass_create_classvalue",(caddr_t)class_create_classvalue },
	{(char*) "wdaclass_create_attrobjects",(caddr_t)class_create_attrobjects }
	};

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

  // for ( i = 0; i < int(sizeof(value_recall)/sizeof(value_recall[0])); i++)
  //  value_recall[i][0] = 0;

  dcli_translate_filename( uid_filename, uid_filename);

  // Create object context
//  attrctx->close_cb = close_cb;
//  attrctx->redraw_cb = redraw_cb;

  // Motif
  MrmInitialize();

  strcpy( title, "PwR Object attributes");

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

  // 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);

  parent_wid = XtCreatePopupShell("spreadSheetEditor", 
		topLevelShellWidgetClass, parent_wid, args, 0);

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

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

  MrmCloseHierarchy(s_DRMh);


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

  i = 0;
  XtSetArg(args[i],XmNwidth,800);i++;
  XtSetArg(args[i],XmNheight,600);i++;
  XtSetValues( toplevel ,args,i);
    
  XtManageChild( toplevel);
  XtUnmanageChild( cmd_input);
  XtUnmanageChild( cmd_scrolledinput);
  XtUnmanageChild( cmd_scrolled_ok);
  XtUnmanageChild( cmd_scrolled_ca);

  utility = ((WUtility *)parent_ctx)->utype;
  wdanav = new WdaNavMotif( (void *)this, wdanav_form, "Plant",
		ldhses, objid, classid, attribute, wa_editmode,
		wa_advanced_user,
		wa_display_objectname, utility, &brow_widget, &sts);
  ((WdaNav *)wdanav)->message_cb = &Wda::message_cb;
  ((WdaNav *)wdanav)->change_value_cb = &Wda::change_value_cb;

  XtPopup( parent_wid, XtGrabNone);

  wow = new CoWowMotif( parent_wid);

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

  if ( utility == wb_eUtility_Wtt)
  {
    ((Wtt *)parent_ctx)->register_utility( (void *) this,
	wb_eUtility_SpreadsheetEditor);
  }
}
コード例 #5
0
//
// Create the navigator widget
//
SubGraphsMotif::SubGraphsMotif(
	void *xn_parent_ctx,
	Widget	xn_parent_wid,
	const char *xn_name,
	void *xn_growctx,
	Widget *w,
	pwr_tStatus *status) :
  SubGraphs( xn_parent_ctx, xn_name, xn_growctx, status),
  parent_wid(xn_parent_wid), trace_timerid(0)	
{
  char		uid_filename[120] = "pwr_exe:ge_subgraphs.uid";
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  char 		title[80];
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  char		name[] = "Proview/R Navigator";

  static MrmRegisterArg	reglist[] = {
        {(char*) "subgraphs_ctx", 0 },
	{(char*) "subgraphs_activate_exit",(caddr_t)subgraphs_activate_exit },
	{(char*) "subgraphs_activate_attr",(caddr_t)subgraphs_activate_attr },
	{(char*) "subgraphs_activate_set_extern",(caddr_t)subgraphs_activate_set_extern },
	{(char*) "subgraphs_activate_set_intern",(caddr_t)subgraphs_activate_set_intern },
	{(char*) "subgraphs_activate_help",(caddr_t)subgraphs_activate_help },
	{(char*) "subgraphs_create_sg_form",(caddr_t)subgraphs_create_sg_form }
	};
  static int	reglist_num = (sizeof reglist / sizeof reglist[0]);

  dcli_translate_filename( uid_filename, uid_filename);

  // Create object context
  reglist[0].value = (caddr_t) this;

  // Motif
  MrmInitialize();

  strcpy( title, "Loaded SubGraphs");

  // 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);

  parent_wid = XtCreatePopupShell(title, 
		topLevelShellWidgetClass, parent_wid, args, 0);

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

  MrmCloseHierarchy(s_DRMh);

  i = 0;
  XtSetArg(args[i],XmNwidth,500);i++;
  XtSetArg(args[i],XmNheight,1200);i++;
  XtSetValues( toplevel ,args,i);
    
  XtManageChild( toplevel);

  strcpy( name, xn_name);

  form_widget = ScrolledBrowCreate( subgraphs_form,
	name, NULL, 0, 
	SubGraphs::init_brow_cb, this, (Widget *)&brow_widget);
  XtManageChild( form_widget);


  XtPopup( parent_wid, XtGrabNone);

  // Create the root item
  *w = toplevel;

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

  *status = 1;
}
コード例 #6
0
RtTraceMotif::RtTraceMotif( void *tr_parent_ctx, Widget tr_parent_wid, pwr_tObjid tr_objid,
			    pwr_tStatus *status) :
  RtTrace( tr_parent_ctx, tr_objid, status), parent_wid(tr_parent_wid)
{
  // FlowWidget	fwidget;
  char		uid_filename[120] = {"xtt_trace.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  unsigned long sts;
  pwr_tOName   	name;
  int		i;
  pwr_tObjid	window_objid;
  pwr_tClassId	cid;
  char   	title[220];
  pwr_tOName   	hostname;
  pwr_tOName   	plcconnect;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  Widget	trace_widget;
  static MrmRegisterArg	reglist[] = {
        {(char*) "tra_ctx", 0 },
	{(char*) "tra_activate_close",(caddr_t)activate_close },
	{(char*) "tra_activate_print",(caddr_t)activate_print },
	{(char*) "tra_activate_printselect",(caddr_t)activate_printselect },
	{(char*) "tra_activate_savetrace",(caddr_t)activate_savetrace },
	{(char*) "tra_activate_restoretrace",(caddr_t)activate_restoretrace },
	{(char*) "tra_activate_cleartrace",(caddr_t)activate_cleartrace },
	{(char*) "tra_activate_trace",(caddr_t)activate_trace },
	{(char*) "tra_activate_display_object",(caddr_t)activate_display_object },
	{(char*) "tra_activate_open_object",(caddr_t)activate_open_object },
	{(char*) "tra_activate_show_cross",(caddr_t)activate_show_cross },
	{(char*) "tra_activate_open_classgraph",(caddr_t)activate_open_classgraph },
	{(char*) "tra_activate_collect_insert",(caddr_t)activate_collect_insert },
	{(char*) "tra_activate_view",(caddr_t)activate_view },
	{(char*) "tra_activate_simulate",(caddr_t)activate_simulate },
	{(char*) "tra_activate_zoomin",(caddr_t)activate_zoomin },
	{(char*) "tra_activate_zoomout",(caddr_t)activate_zoomout },
	{(char*) "tra_activate_zoomreset",(caddr_t)activate_zoomreset },
	{(char*) "tra_activate_scantime1",(caddr_t)activate_scantime1 },
	{(char*) "tra_activate_scantime2",(caddr_t)activate_scantime2 },
	{(char*) "tra_activate_scantime3",(caddr_t)activate_scantime3 },
	{(char*) "tra_activate_scantime4",(caddr_t)activate_scantime4 },
	{(char*) "tra_activate_scantime5",(caddr_t)activate_scantime5 },
	{(char*) "tra_activate_help",(caddr_t)activate_help },
	{(char*) "tra_activate_helpplc",(caddr_t)activate_helpplc },
	{(char*) "tra_create_form",(caddr_t)create_form },
	{(char*) "tra_create_menu",(caddr_t)create_menu }
	};

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

  lng_get_uid( uid_filename, uid_filename);

  sts = gdh_ObjidToName( tr_objid, name, sizeof(name), cdh_mNName); 
  if (EVEN(sts)) {
    *status = sts;
    return;
  }
  strcpy( title, "Trace ");
  strcat( title, name);

  /* Find plcwindow */
  sts = gdh_GetObjectClass( tr_objid, &cid);
  if ( EVEN(sts)) {
    *status = sts;
    return;
  }

  if ( !(cid == pwr_cClass_windowplc ||
         cid == pwr_cClass_windowcond ||
         cid == pwr_cClass_windoworderact ||
         cid == pwr_cClass_windowsubstep ))
  {

    sts = gdh_GetChild( tr_objid, &window_objid);
    if ( EVEN(sts)) {
      *status = sts;
      return;
    }
  }
  else
    window_objid = tr_objid; 

  sts = gdh_GetObjectClass( window_objid, &cid);
  if ( EVEN(sts)) {
    *status = sts;
    return;
  }

  if ( !(cid == pwr_cClass_windowplc ||
         cid == pwr_cClass_windowcond ||
         cid == pwr_cClass_windoworderact ||
         cid == pwr_cClass_windowsubstep )) {
    *status = 0;
    return;
  }

  sts = get_filename( window_objid, filename, &m_has_host, hostname, 
		      plcconnect);
  if ( EVEN(sts)) {
    *status = sts;
    return;
  }

  /* Create object context */
  objid = window_objid;
  if ( m_has_host) {
    strcpy( m_hostname, hostname);
    strcpy( m_plcconnect, plcconnect);
  }
  reglist[0].value = (caddr_t) this;
 
  toplevel = XtCreatePopupShell( name, 
		topLevelShellWidgetClass, parent_wid, 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*) "trace_window", toplevel,
			title, args, 1, &trace_widget, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch %s\n", name);

  MrmCloseHierarchy(s_DRMh);


  i = 0;
  XtSetArg(args[i],XmNwidth,800);i++;
  XtSetArg(args[i],XmNheight,600);i++;
  XtSetValues( toplevel ,args,i);
    
  XtManageChild( trace_widget);

  i = 0;
/*
  XtSetArg(args[i],XmNwidth,790);i++;
  XtSetArg(args[i],XmNheight,560);i++;
*/
  XtSetArg( args[i], XmNtopAttachment, XmATTACH_WIDGET);i++;
  XtSetArg( args[i], XmNtopWidget, menu);i++;
  XtSetArg( args[i], XmNrightAttachment, XmATTACH_FORM);i++;
  XtSetArg( args[i], XmNleftAttachment, XmATTACH_FORM);i++;
  XtSetArg( args[i], XmNbottomAttachment, XmATTACH_FORM);i++;
  flow_widget = FlowCreate( form, (char*) "Flow window", args, i, 
			    init_flow, (void *)this);

  XtManageChild( (Widget) flow_widget);
/*
  XtRealizeWidget(toplevel);
*/
  XtPopup( toplevel, XtGrabNone);

  // fwidget = (FlowWidget) flow_widget;
  // flow_ctx = (flow_tCtx)fwidget->flow.flow_ctx;
  // flow_SetCtxUserData( flow_ctx, this);

  /* Create navigator popup */

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

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

  i = 0;
  XtSetArg(args[i],XmNwidth,200);i++;
  XtSetArg(args[i],XmNheight,200);i++;
  nav_widget = FlowCreateNav( nav_shell, (char*) "navigator",
        args, i, flow_widget);
  XtManageChild( nav_widget);
  XtRealizeWidget( nav_shell);

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

  wow = new CoWowMotif( toplevel);
  trace_timerid = wow->timer_new();

  viewsetup();
  flow_Open( flow_ctx, filename);
  trasetup();
  trace_start();

#if defined OS_LINUX
  {
    struct stat info;

    if ( stat( filename, &info) != -1)
      version = info.st_ctime;    
  }
#endif

}
コード例 #7
0
XttMotif::XttMotif( int argc, char *argv[], int *return_sts) :
  Xtt( &argc, &argv, return_sts),
  cmd_current_recall(0), value_current_recall(0) 
{
  char		uid_filename[120] = {"xtt.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  int		i;
  XtAppContext  app_ctx;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  Widget	xtt_widget;
  char		title[120] = "Xtt ";
  char		nodename[80];

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

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

  static MrmRegisterArg	reglist[] = {
        {(char*) "xtt_ctx", 0 },
	{(char*) "xtt_activate_exit",(caddr_t)activate_exit },
	{(char*) "xtt_activate_print",(caddr_t)activate_print },
	{(char*) "xtt_activate_find",(caddr_t)activate_find },
	{(char*) "xtt_activate_findregex",(caddr_t)activate_findregex },
	{(char*) "xtt_activate_findnext",(caddr_t)activate_findnext },
	{(char*) "xtt_activate_collapse",(caddr_t)activate_collapse },
	{(char*) "xtt_activate_openobject",(caddr_t)activate_openobject },
	{(char*) "xtt_activate_openplc",(caddr_t)activate_openplc },
	{(char*) "xtt_activate_opengraph",(caddr_t)activate_opengraph },
	{(char*) "xtt_activate_showcrossref",(caddr_t)activate_showcrossref },
	{(char*) "xtt_activate_change_value",(caddr_t)activate_change_value },
	{(char*) "xtt_activate_command",(caddr_t)activate_command },
	{(char*) "xtt_activate_collect_insert",(caddr_t)activate_collect_insert },
	{(char*) "xtt_activate_collect_show",(caddr_t)activate_collect_show },
	{(char*) "xtt_activate_collect_remove",(caddr_t)activate_collect_remove },
	{(char*) "xtt_activate_collect_clear",(caddr_t)activate_collect_clear },
	{(char*) "xtt_activate_advanceduser",(caddr_t)activate_advanceduser },
	{(char*) "xtt_activate_zoom_in",(caddr_t)activate_zoom_in },
	{(char*) "xtt_activate_zoom_out",(caddr_t)activate_zoom_out },
	{(char*) "xtt_activate_zoom_reset",(caddr_t)activate_zoom_reset },
	{(char*) "xtt_activate_help",(caddr_t)activate_help },
	{(char*) "xtt_activate_help_project",(caddr_t)activate_help_project },
	{(char*) "xtt_activate_help_proview",(caddr_t)activate_help_proview },
	{(char*) "xtt_create_msg_label",(caddr_t)create_msg_label },
	{(char*) "xtt_create_cmd_prompt",(caddr_t)create_cmd_prompt },
	{(char*) "xtt_create_cmd_input",(caddr_t)create_cmd_input },
	{(char*) "xtt_create_xnav_form",(caddr_t)create_xnav_form },
	{(char*) "xtt_activate_india_ok",(caddr_t)activate_india_ok },
	{(char*) "xtt_activate_india_cancel",(caddr_t)activate_india_cancel },
	{(char*) "xtt_create_india_label",(caddr_t)create_india_label },
	{(char*) "xtt_create_india_text",(caddr_t)create_india_text }
	};

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

  syi_NodeName( &sts, nodename, sizeof(nodename));
  if ( ODD(sts))
    strcat( title, nodename);

  // Motif
  Lng::get_uid( uid_filename, uid_filename);
  MrmInitialize();

  toplevel = XtVaAppInitialize (
		      &app_ctx, 
		      "Rt_xtt",
		      NULL, 0, 
		      &argc, argv, 
		      fbr, 
		      XtNallowShellResize,  True,
		      XtNtitle, title,
		      XmNmappedWhenManaged, True,
		      NULL);

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

  if (compiled_translations == NULL) 
    XtAppAddActions( XtWidgetToApplicationContext(toplevel), 
						actions, XtNumber(actions));
 
  // Save the context structure in the widget
  i = 0;
  XtSetArg( args[i], XmNuserData, (XtPointer) this);i++;

  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*) "xtt_window", toplevel,
			title, args, i, &xtt_widget, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch xtt_window\n");

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

  MrmCloseHierarchy(s_DRMh);


  if (compiled_translations == NULL) 
    compiled_translations = XtParseTranslationTable(translations);
  XtOverrideTranslations( xtt_widget, compiled_translations);

  i = 0;
  XtSetArg(args[i],XmNwidth,350);i++;
  XtSetArg(args[i],XmNheight,600);i++;
  XtSetArg(args[i], XmNdeleteResponse, XmDO_NOTHING);i++;
  XtSetValues( toplevel ,args,i);
    
  XtManageChild( xtt_widget);
  XtUnmanageChild( cmd_input);

  xnav = new XNavMotif( this, xnav_form, "Plant",
		&brow_widget, (xnav_sStartMenu *)root_menu, 
		opplace_str, op_close_button, &sts);
  xnav->message_cb = &xtt_message_cb;
  xnav->close_cb = &close;
  xnav->map_cb = &map;
  xnav->change_value_cb = &change_value;
  xnav->set_dimension_cb = &set_dimension;
  xnav->attach_audio = attach_audio;

  // Create help window
  CoXHelp *xhelp = new CoXHelpMotif( toplevel, this, xhelp_eUtility_Xtt, &sts);
  xhelp->open_URL_cb = open_URL_cb;
  CoXHelp::set_default( xhelp);

  XtRealizeWidget( toplevel);

  if ( !xnav->is_authorized( pwr_mAccess_AllRt, 0))
    xnav->open_login();

  wow = new CoWowMotif( toplevel);
  if ( !quiet)
    wow->DisplayWarranty();

//  XmProcessTraversal( xnav->brow_widget, XmTRAVERSE_CURRENT);
//  xnav->set_inputfocus();

  init_hotkey( app_ctx, toplevel);

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

  if ( xnav->op)
    close( this, 0);

  timerid = wow->timer_new();

  // Start timer to check for qcom events
  timerid->add( 1000, qcom_events, this);

  xtt_mainloop( app_ctx);  
}
コード例 #8
0
XAttOneMotif::XAttOneMotif( Widget xa_parent_wid,
			    void *xa_parent_ctx, 
			    pwr_sAttrRef *xa_aref,
			    char *xa_title,
			    unsigned int xa_priv,
			    int *xa_sts) :
  XAttOne( xa_parent_ctx, xa_aref, xa_title, xa_priv, xa_sts), 
  parent_wid(xa_parent_wid), set_focus_disabled(0), value_current_recall(0)
{
  char		uid_filename[120] = {"xtt_xattone.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  pwr_tAName   	title;
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  char		name[] = "Proview/R Navigator";

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

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

  static MrmRegisterArg	reglist[] = {
        {(char*) "xao_ctx", 0 },
	{(char*) "xao_activate_exit",(caddr_t)activate_exit },
	{(char*) "xao_activate_help",(caddr_t)activate_help },
	{(char*) "xao_create_msg_label",(caddr_t)create_msg_label },
	{(char*) "xao_create_cmd_prompt",(caddr_t)create_cmd_prompt },
	{(char*) "xao_create_cmd_input",(caddr_t)create_cmd_input },
	{(char*) "xao_create_cmd_label",(caddr_t)create_cmd_label },
	{(char*) "xao_create_cmd_scrolledinput",(caddr_t)create_cmd_scrolledinput },
	{(char*) "xao_create_cmd_scrolled_ok",(caddr_t)create_cmd_scrolled_ok },
	{(char*) "xao_create_cmd_scrolled_ap",(caddr_t)create_cmd_scrolled_ap },
	{(char*) "xao_create_cmd_scrolled_ca",(caddr_t)create_cmd_scrolled_ca },
	{(char*) "xao_activate_cmd_scrolledinput",(caddr_t)activate_cmd_input },
	{(char*) "xao_activate_cmd_scrolled_ok",(caddr_t)activate_cmd_scrolled_ok },
	{(char*) "xao_activate_cmd_scrolled_ap",(caddr_t)activate_cmd_scrolled_ap },
	{(char*) "xao_activate_cmd_scrolled_ca",(caddr_t)activate_cmd_scrolled_ca }
	};

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

  // for ( i = 0; i < int(sizeof(value_recall)/sizeof(value_recall[0])); i++)
  //  value_recall[i][0] = 0;

  Lng::get_uid( uid_filename, uid_filename);

  // Create object context
//  attrctx->close_cb = close_cb;
//  attrctx->redraw_cb = redraw_cb;

  // Motif
  MrmInitialize();

  *xa_sts = gdh_AttrrefToName( &aref, title, sizeof(title), cdh_mNName);
  if ( EVEN(*xa_sts)) return;

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

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

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

  MrmRegisterNames(reglist, reglist_num);

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

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

  MrmCloseHierarchy(s_DRMh);


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

  i = 0;
  XtSetArg(args[i],XmNwidth,420);i++;
  XtSetArg(args[i],XmNheight,120);i++;
  XtSetValues( toplevel ,args,i);
    
  if ( priv & pwr_mPrv_RtWrite || priv & pwr_mPrv_System)
    access_rw = 1;
  else
    access_rw = 0;

  XtManageChild( toplevel);
  if ( access_rw) 
    XtUnmanageChild( cmd_label);
  else {
    XtUnmanageChild( cmd_input);
    XtUnmanageChild( cmd_scrolled_ok);
    XtUnmanageChild( cmd_scrolled_ap);
  }
  XtUnmanageChild( cmd_scrolledinput);


  XtPopup( parent_wid, XtGrabNone);

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

  change_value( 1);

  *xa_sts = XATT__SUCCESS;
}
コード例 #9
0
ファイル: wb_vsel_motif.cpp プロジェクト: Strongc/proview
WVselMotif::WVselMotif (
  pwr_tStatus   *status,
  void		*wv_parent_ctx,
  Widget	wv_parent_wid,
  const char   	*wv_name,
  ldh_tWBContext wv_wbctx,
  char		*volumename,
  int		(*bc_success)( void *, pwr_tVolumeId *, int),
  void		(*bc_cancel)(),
  int		(*bc_time_to_exit)( void *),
  int		show_volumes,
  wb_eType      wv_wb_type) : 
  WVsel(status,wv_parent_ctx,wv_name,wv_wbctx,volumename,bc_success,bc_cancel,
	bc_time_to_exit,show_volumes,wv_wb_type), parent_wid(wv_parent_wid)
{
  Arg		args[20];
  int		sts;
  int 		i;
  pwr_tVolumeId volid, *volume_ptr;
  pwr_tVolumeId	volume;
  pwr_tClassId	classid;
  char		volname[80];
  int		size;
  int		volume_count;
  int		display_window;

  /* DRM database hierarchy related variables */
  MrmHierarchy 	s_DRMh;
  MrmType 	dclass;
  char		uid_filename[200] = {"pwr_exe:wb_vsel.uid"};
  char		*uid_filename_p = uid_filename;


  static MrmRegisterArg	reglist[] = {
  /* First the context variable */
  {(char*) "vsel_ctx", 0 },
  {(char*) "vsel_write_priv", 0 },

  /* Callbacks for the controlled login widget */
  {(char*) "vsel_create_adb",(caddr_t)create_adb},
  {(char*) "vsel_destroy_adb",(caddr_t)destroy_adb},
  {(char*) "vsel_create_label",(caddr_t)create_label},
  {(char*) "vsel_activate_ok",(caddr_t)activate_ok},
  {(char*) "vsel_activate_cancel",(caddr_t)activate_cancel},
  {(char*) "vsel_activate_close",(caddr_t)activate_close},
  {(char*) "vsel_activate_showall",(caddr_t)activate_showall},
  {(char*) "vsel_create_volumelist",(caddr_t)create_volumelist},
  {(char*) "vsel_action_volumelist",(caddr_t)action_volumelist}
  };

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

  sts = dcli_translate_filename( uid_filename, uid_filename);
  if ( EVEN(sts)) {
    printf( "** pwr_exe is not defined\n");
    exit(0);
  }

  strcpy( volname, "");
  if ( volumename != NULL && *volumename != 0 && !show_volumes)
    /* Start the navigater for this volume */
    strcpy( volname, volumename);
  else if ( !show_volumes && wb_type != wb_eType_Buffer)
  {
    /* If there is only one volume in the db, select this volume */
    volume_count = 0;

    sts = ldh_GetVolumeList( wbctx, &volume);
    while ( ODD(sts) )
    {
      sts = ldh_GetVolumeClass( wbctx, volume, &classid);
      if (EVEN(sts)) { *status = sts; return; }
  
      if ( cdh_isClassVolumeClass( classid) ||
 	   classid == pwr_eClass_WorkBenchVolume ||
	   volume == ldh_cRtVolume)
      {
        sts = ldh_GetNextVolume( wbctx, volume, &volume);
        continue;
      }
      sts = ldh_VolumeIdToName( wbctx, volume, volname, sizeof(volname),
	    &size);
      if (EVEN(sts)) { *status = sts; return; }
      volume_count++;

      sts = ldh_GetNextVolume( wbctx, volume, &volume);
    }
    if ( volume_count != 1)
      strcpy( volname, "");
  }

  
  //  If volume name is supplied, find this volume and open the navigator.

  if ( strcmp( volname, "") && wb_type != wb_eType_Buffer)
    /* Check syntax, if new volumes is found, show the window */
    sts = check_volumelist( 1, &display_window);

  if ( strcmp( volname, "") && !display_window)
  {
    sts = ldh_VolumeNameToId( wbctx, volname, &volid);
    WFoe::error_msg(sts);
    if ( ODD(sts))
    {
      volume_ptr = (pwr_tVolumeId *) calloc( 1, sizeof( pwr_tVolumeId));
      *volume_ptr = volid;
      (vsel_bc_success) ( (void *)this, volume_ptr, 1);
      if (vsel_bc_cancel != NULL)
        (vsel_bc_cancel) ();

      *status = LOGIN__SUCCESS;
      return;
    }
    else
      printf( "-- Unable to open volume '%s', volume doesn't exist\n",
	volname);
  }
 

  
  // Now start the module creation

  // set initialization values in context */

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

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

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

  MrmRegisterNames(reglist, reglist_num);

  i=0;
  XtSetArg(args[i],XmNiconName,name);  i++;
  
  /* Save the id of the top in the context */ 
  widgets.toplevel = XtCreatePopupShell (
    "selectvolume", topLevelShellWidgetClass, parent_wid, args, i);

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

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

  XtSetValues( widgets.toplevel  ,args,i);

  /* now that we have a top level we can get the main window */
  sts = MrmFetchWidgetOverride(s_DRMh, (char*) "vsel_window",
    widgets.toplevel, name, args, 1, 
    &widgets.vsel_window, &dclass);

  if (sts != MrmSUCCESS) printf("can't fetch utedit widget\n");

  XtManageChild( widgets.vsel_window);

  /* SG 09.02.91 a top level should always be realized ! */
  XtPopup( widgets.toplevel, XtGrabNone );


  MrmCloseHierarchy(s_DRMh);

  wow = new CoWowMotif( widgets.vsel_window);

  if ( wb_type != wb_eType_Buffer)
    sts = check_volumelist( 0, &display_window);

  // Set input focus to the scrolled list widget
  XmProcessTraversal( widgets.volumelist, XmTRAVERSE_CURRENT);

  *status = LOGIN__SUCCESS;
}
コード例 #10
0
GeCurveMotif::GeCurveMotif( void 	*gc_parent_ctx, 
			    Widget 	parent_widget,
			    char	*curve_name,
			    char  *filename,
			    GeCurveData *curve_data,
			    int   pos_right) :
  GeCurve( gc_parent_ctx, curve_name, filename, curve_data, pos_right)
{
  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);

  i = 0;
  XtSetArg(args[i],XmNwidth,800);i++;
  XtSetArg(args[i],XmNheight,600);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);

}
コード例 #11
0
XCrrMotif::XCrrMotif( 
	Widget 		xa_parent_wid,
	void 		*xa_parent_ctx, 
	pwr_sAttrRef 	*xa_objar,
	int 		xa_advanced_user,
        int             *xa_sts) :
  XCrr( xa_parent_ctx, xa_objar, xa_advanced_user, xa_sts),
  parent_wid(xa_parent_wid), set_focus_disabled(0)
{
  char		uid_filename[120] = {"xtt_xcrr.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  pwr_tAName   	title;
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  char		name[] = "Proview/R Navigator";

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

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

  static MrmRegisterArg	reglist[] = {
        {(char*) "xcrr_ctx", 0 },
	{(char*) "xcrr_activate_exit",(caddr_t)activate_exit },
	{(char*) "xcrr_activate_openplc",(caddr_t)activate_openplc },
	{(char*) "xcrr_activate_help",(caddr_t)activate_help },
	{(char*) "xcrr_create_xcrrnav_form",(caddr_t)create_xcrrnav_form }
	};

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

  Lng::get_uid( uid_filename, uid_filename);

  // Motif
  MrmInitialize();

  *xa_sts = gdh_AttrrefToName( &objar, title, sizeof(title), cdh_mNName);
  if ( EVEN(*xa_sts)) return;

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

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

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

  MrmRegisterNames(reglist, reglist_num);

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

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

  MrmCloseHierarchy(s_DRMh);


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

  i = 0;
  XtSetArg(args[i],XmNwidth,420);i++;
  XtSetArg(args[i],XmNheight,300);i++;
  XtSetValues( toplevel ,args,i);
    
  XtManageChild( toplevel);

  xcrrnav = new XAttNavMotif( (void *)this, xcrrnav_form, xattnav_eType_CrossRef,
			      "Plant", &objar, xa_advanced_user, 0, &brow_widget, &sts);
  xcrrnav->popup_menu_cb = &xcrr_popup_menu_cb;
  xcrrnav->start_trace_cb = &xcrr_start_trace_cb;
  xcrrnav->close_cb = &xcrr_close_cb;

  XtPopup( parent_wid, XtGrabNone);

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

  *xa_sts = XATT__SUCCESS;
}
コード例 #12
0
ファイル: xtt_clog_motif.cpp プロジェクト: Strongc/proview
CLogMotif::CLogMotif( void *clog_parent_ctx,
		      Widget	clog_parent_wid,
		      const char *clog_name,
		      pwr_tStatus *status) :
  CLog( clog_parent_ctx, clog_name, status), parent_wid(clog_parent_wid),
  clock_cursor(0)
{
  char		uid_filename[120] = {"xtt_clog.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;

  static char clog_translations[] =
    "<FocusIn>: clog_inputfocus()\n";
  static XtTranslations clog_compiled_translations = NULL;
  static XtActionsRec clog_actions[] =
  {
    {(char*) "clog_inputfocus",      (XtActionProc) action_inputfocus}
  };

  static MrmRegisterArg	reglist[] = {
        {(char*) "clog_ctx", 0 },
	{(char*) "clog_activate_exit",(caddr_t)activate_exit },
	{(char*) "clog_activate_select_file",(caddr_t)activate_select_file },
	{(char*) "clog_activate_next_file",(caddr_t)activate_next_file },
	{(char*) "clog_activate_prev_file",(caddr_t)activate_prev_file },
	{(char*) "clog_activate_update",(caddr_t)activate_update },
	{(char*) "clog_activate_zoom_in",(caddr_t)activate_zoom_in },
	{(char*) "clog_activate_zoom_out",(caddr_t)activate_zoom_out },
	{(char*) "clog_activate_zoom_reset",(caddr_t)activate_zoom_reset },
	{(char*) "clog_activate_filter",(caddr_t)activate_filter },
	{(char*) "clog_activate_help",(caddr_t)activate_help },
	{(char*) "clog_activate_helpmsg",(caddr_t)activate_helpmsg },
	{(char*) "clog_create_form",(caddr_t)create_form },
	{(char*) "clog_filter_tog_cr",(caddr_t)filter_tog_cr },
	{(char*) "clog_filter_string_cr",(caddr_t)filter_string_cr },
	{(char*) "clog_filter_act_but_cb",(caddr_t)filter_act_but_cb },
	{(char*) "clog_filesel_ok_cb",(caddr_t)filesel_ok_cb },
	{(char*) "clog_filesel_cancel_cb",(caddr_t)filesel_cancel_cb },
	{(char*) "clog_filesel_list_cr",(caddr_t)filesel_list_cr }
	};
  static int	reglist_num = (sizeof reglist / sizeof reglist[0]);

  *status = 1;

  Lng::get_uid( uid_filename, uid_filename);

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

  // Motif
  MrmInitialize();


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

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

  MrmRegisterNames(reglist, reglist_num);

  parent_wid_clog = XtCreatePopupShell( clog_name, 
		topLevelShellWidgetClass, parent_wid, args, i);

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

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

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

  MrmCloseHierarchy(s_DRMh);

  if ( clog_compiled_translations == NULL) 
  {
    XtAppAddActions( XtWidgetToApplicationContext( toplevel), 
		clog_actions, XtNumber(clog_actions));
    clog_compiled_translations = XtParseTranslationTable( clog_translations);
  }
  XtOverrideTranslations( toplevel, clog_compiled_translations);

  i = 0;
  XtSetArg(args[i],XmNwidth,1000);i++;
  XtSetArg(args[i],XmNheight,800);i++;
  XtSetValues( toplevel ,args,i);
    
  XtManageChild( toplevel);

  // Create clognav
  clognav = new CLogNavMotif( this, form_clog, &clognav_widget);

  XtPopup( parent_wid_clog, XtGrabNone);

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

  wow = new CoWowMotif( toplevel);

  *status = 1;
}
コード例 #13
0
EvMotif::EvMotif( void *ev_parent_ctx,
		  Widget	ev_parent_wid,
		  char *eve_name,
		  char *ala_name,
		  char *blk_name,
		  pwr_tObjid ev_user,
		  int display_ala,
		  int display_eve,
		  int display_blk,
		  int display_return,
		  int display_ack,
		  int ev_beep,
		  pwr_tMask ev_pop_mask,
		  int ev_eventname_seg,
		  pwr_tStatus *status) :
  Ev( ev_parent_ctx, eve_name, ala_name, blk_name, ev_user, display_ala, display_eve,
      display_blk, display_return, display_ack, ev_beep, ev_pop_mask, ev_eventname_seg, status),
  parent_wid(ev_parent_wid), parent_wid_eve(NULL), parent_wid_ala(NULL)
{
  char		uid_filename[120] = {"xtt_eve.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  int		i;
  pwr_sClass_User	*userobject_ptr;
  MrmHierarchy s_DRMh;
  MrmType dclass;

  static char eve_translations[] =
    "<FocusIn>: eve_inputfocus()\n";
  static char ala_translations[] =
    "<FocusIn>: ala_inputfocus()\n";
  static char blk_translations[] =
    "<FocusIn>: blk_inputfocus()\n";
  static XtTranslations eve_compiled_translations = NULL;
  static XtTranslations ala_compiled_translations = NULL;
  static XtTranslations blk_compiled_translations = NULL;

  static XtActionsRec eve_actions[] =
  {
    {(char*) "eve_inputfocus",      (XtActionProc) eve_action_inputfocus}
  };
  static XtActionsRec ala_actions[] =
  {
    {(char*) "ala_inputfocus",      (XtActionProc) ala_action_inputfocus}
  };
  static XtActionsRec blk_actions[] =
  {
    {(char*) "blk_inputfocus",      (XtActionProc) blk_action_inputfocus}
  };

  static MrmRegisterArg	reglist[] = {
        {(char*) "ev_ctx", 0 },
	{(char*) "ev_eve_activate_exit",(caddr_t)eve_activate_exit },
	{(char*) "ev_eve_activate_print",(caddr_t)eve_activate_print },
	{(char*) "ev_eve_activate_ack_last",(caddr_t)eve_activate_ack_last },
	{(char*) "ev_eve_activate_zoom_in",(caddr_t)eve_activate_zoom_in },
	{(char*) "ev_eve_activate_zoom_out",(caddr_t)eve_activate_zoom_out },
	{(char*) "ev_eve_activate_zoom_reset",(caddr_t)eve_activate_zoom_reset },
	{(char*) "ev_eve_activate_open_plc",(caddr_t)eve_activate_open_plc },
	{(char*) "ev_eve_activate_display_in_xnav",(caddr_t)eve_activate_display_in_xnav },
	{(char*) "ev_eve_activate_disp_hundredth",(caddr_t)eve_activate_disp_hundredth },
	{(char*) "ev_eve_activate_hide_object",(caddr_t)eve_activate_hide_object },
	{(char*) "ev_eve_activate_hide_text",(caddr_t)eve_activate_hide_text },
	{(char*) "ev_eve_activate_help",(caddr_t)eve_activate_help },
	{(char*) "ev_eve_activate_helpevent",(caddr_t)eve_activate_helpevent },
	{(char*) "ev_eve_create_form",(caddr_t)eve_create_form },
	{(char*) "ev_ala_activate_exit",(caddr_t)ala_activate_exit },
	{(char*) "ev_ala_activate_print",(caddr_t)ala_activate_print },
	{(char*) "ev_ala_activate_ack_last",(caddr_t)ala_activate_ack_last },
	{(char*) "ev_ala_activate_zoom_in",(caddr_t)ala_activate_zoom_in },
	{(char*) "ev_ala_activate_zoom_out",(caddr_t)ala_activate_zoom_out },
	{(char*) "ev_ala_activate_zoom_reset",(caddr_t)ala_activate_zoom_reset },
	{(char*) "ev_ala_activate_open_plc",(caddr_t)ala_activate_open_plc },
	{(char*) "ev_ala_activate_display_in_xnav",(caddr_t)ala_activate_display_in_xnav },
	{(char*) "ev_ala_activate_disp_hundredth",(caddr_t)ala_activate_disp_hundredth },
	{(char*) "ev_ala_activate_hide_object",(caddr_t)ala_activate_hide_object },
	{(char*) "ev_ala_activate_hide_text",(caddr_t)ala_activate_hide_text },
	{(char*) "ev_ala_activate_help",(caddr_t)ala_activate_help },
	{(char*) "ev_ala_activate_helpevent",(caddr_t)ala_activate_helpevent },
	{(char*) "ev_ala_create_form",(caddr_t)ala_create_form },
	{(char*) "ev_blk_activate_exit",(caddr_t)blk_activate_exit },
	{(char*) "ev_blk_activate_print",(caddr_t)blk_activate_print },
	{(char*) "ev_blk_activate_zoom_in",(caddr_t)blk_activate_zoom_in },
	{(char*) "ev_blk_activate_zoom_out",(caddr_t)blk_activate_zoom_out },
	{(char*) "ev_blk_activate_zoom_reset",(caddr_t)blk_activate_zoom_reset },
	{(char*) "ev_blk_activate_block_remove",(caddr_t)blk_activate_block_remove },
	{(char*) "ev_blk_activate_open_plc",(caddr_t)blk_activate_open_plc },
	{(char*) "ev_blk_activate_display_in_xnav",(caddr_t)blk_activate_display_in_xnav },
	{(char*) "ev_blk_activate_help",(caddr_t)blk_activate_help },
	{(char*) "ev_blk_create_form",(caddr_t)blk_create_form }
	};
  static int	reglist_num = (sizeof reglist / sizeof reglist[0]);

  *status = 1;

  Lng::get_uid( uid_filename, uid_filename);

  // Check user object
  if ( cdh_ObjidIsNull( user))
  {
    *status = XNAV__NOUSER;
    return;
  }

  sts = gdh_ObjidToPointer ( user, (pwr_tAddress *) &userobject_ptr);
  if ( EVEN(sts)) 
  {
    *status = XNAV__NOUSER;
    return;
  }
  ala_size = userobject_ptr->MaxNoOfAlarms;
  eve_size = userobject_ptr->MaxNoOfEvents;
  blk_size = 0;
  create_aliaslist( userobject_ptr);

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

  // Motif
  MrmInitialize();


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

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

  MrmRegisterNames(reglist, reglist_num);

  parent_wid_eve = XtCreatePopupShell( eve_name, 
		topLevelShellWidgetClass, parent_wid, args, i);

  sts = MrmFetchWidgetOverride( s_DRMh, (char*) "eve_window", parent_wid_eve,
			eve_name, args, 1, &toplevel_eve, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch %s\n", eve_name);

  parent_wid_ala = XtCreatePopupShell( ala_name, 
		topLevelShellWidgetClass, parent_wid, args, i);

  sts = MrmFetchWidgetOverride( s_DRMh, (char*) "ala_window", parent_wid_ala,
			ala_name, args, 1, &toplevel_ala, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch %s\n", ala_name);

  parent_wid_blk = XtCreatePopupShell( blk_name, 
		topLevelShellWidgetClass, parent_wid, args, i);

  sts = MrmFetchWidgetOverride( s_DRMh, (char*) "blk_window", parent_wid_blk,
			blk_name, args, 1, &toplevel_blk, &dclass);
  if (sts != MrmSUCCESS)  printf("can't fetch %s\n", blk_name);

  MrmCloseHierarchy(s_DRMh);

  if ( eve_compiled_translations == NULL) 
  {
    XtAppAddActions( XtWidgetToApplicationContext( toplevel_eve), 
		eve_actions, XtNumber(eve_actions));
    eve_compiled_translations = XtParseTranslationTable( eve_translations);
  }
  XtOverrideTranslations( toplevel_eve, eve_compiled_translations);

  if ( ala_compiled_translations == NULL) 
  {
    XtAppAddActions( XtWidgetToApplicationContext( toplevel_ala), 
		ala_actions, XtNumber(ala_actions));
    ala_compiled_translations = XtParseTranslationTable( ala_translations);
  }
  XtOverrideTranslations( toplevel_ala, ala_compiled_translations);

  if ( blk_compiled_translations == NULL) 
  {
    XtAppAddActions( XtWidgetToApplicationContext( toplevel_blk), 
		blk_actions, XtNumber(blk_actions));
    blk_compiled_translations = XtParseTranslationTable( blk_translations);
  }
  XtOverrideTranslations( toplevel_blk, blk_compiled_translations);

  i = 0;
  XtSetArg(args[i],XmNwidth,700);i++;
  XtSetArg(args[i],XmNheight,600);i++;
  XtSetValues( toplevel_eve ,args,i);
    
  i = 0;
  XtSetArg(args[i],XmNwidth,700);i++;
  XtSetArg(args[i],XmNheight,300);i++;
  XtSetValues( toplevel_ala ,args,i);
    
  i = 0;
  XtSetArg(args[i],XmNwidth,700);i++;
  XtSetArg(args[i],XmNheight,300);i++;
  XtSetValues( toplevel_blk ,args,i);
    
  XtManageChild( toplevel_eve);
  XtManageChild( toplevel_ala);
  XtManageChild( toplevel_blk);

  // Create ala and eve...
  eve = new EvListMotif( this, form_eve, ev_eType_EventList, eve_size, eventname_seg, &eve_widget);
  eve->start_trace_cb = &eve_start_trace_cb;
  eve->display_in_xnav_cb = &eve_display_in_xnav_cb;
  eve->name_to_alias_cb = &ev_name_to_alias_cb;
  eve->popup_menu_cb = &ev_popup_menu_cb;

  ala = new EvListMotif( this, form_ala, ev_eType_AlarmList, ala_size, eventname_seg, &ala_widget);
  ala->start_trace_cb = &ala_start_trace_cb;
  ala->display_in_xnav_cb = &ala_display_in_xnav_cb;
  ala->name_to_alias_cb = &ev_name_to_alias_cb;
  ala->popup_menu_cb = &ev_popup_menu_cb;
  ala->sound_cb = &ev_sound_cb;

  blk = new EvListMotif( this, form_blk, ev_eType_BlockList, blk_size, eventname_seg, &blk_widget);
  blk->start_trace_cb = &blk_start_trace_cb;
  blk->display_in_xnav_cb = &blk_display_in_xnav_cb;
  blk->popup_menu_cb = &ev_popup_menu_cb;
  // blk->hide_text = 1;

//  XtManageChild( form_widget);

  if ( display_eve) {
    XtPopup( parent_wid_eve, XtGrabNone);
    eve_displayed = 1;
  }
  else
    XtRealizeWidget( parent_wid_eve);

  if ( display_ala) {
    XtPopup( parent_wid_ala, XtGrabNone);
    ala_displayed = 1;
  }
  else
    XtRealizeWidget( parent_wid_ala);

  if ( display_blk) {
    XtPopup( parent_wid_blk, XtGrabNone);
    blk_displayed = 1;
  }
  else
    XtRealizeWidget( parent_wid_blk);


  // Connect the window manager close-button to exit
  flow_AddCloseVMProtocolCb( parent_wid_eve, 
	(XtCallbackProc)eve_activate_exit, this);
  flow_AddCloseVMProtocolCb( parent_wid_ala, 
	(XtCallbackProc)ala_activate_exit, this);
  flow_AddCloseVMProtocolCb( parent_wid_blk, 
	(XtCallbackProc)blk_activate_exit, this);

  wow = new CoWowMotif( toplevel_ala);

  // Store this for the mh callbacks
  ev = this;

  sts = outunit_connect( user);
  if ( EVEN(sts))
    *status = sts;
}
コード例 #14
0
CoXHelpMotif::CoXHelpMotif( 
	Widget 		xa_parent_wid,
	void 		*xa_parent_ctx,
	xhelp_eUtility	utility,
        int             *xa_sts) :
 	CoXHelp(xa_parent_ctx,utility,xa_sts), parent_wid(xa_parent_wid)
{
  char		uid_filename[120] = {"xtt_xhelp.uid"};
  char		*uid_filename_p = uid_filename;
  Arg 		args[20];
  pwr_tStatus	sts;
  char 		title[80];
  int		i;
  MrmHierarchy s_DRMh;
  MrmType dclass;
  char		name[] = "Proview/R Navigator";

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

  static XtActionsRec actions[] =
    {
      {(char*) "xhelp_inputfocus",      (XtActionProc) CoXHelpMotif::action_inputfocus}
    };

  static MrmRegisterArg	reglist[] = {
    {(char*) "xhelp_ctx", 0 },
    {(char*) "xhelp_activate_exit",(caddr_t)CoXHelpMotif::activate_exit },
    {(char*) "xhelp_activate_zoom_in",(caddr_t)CoXHelpMotif::activate_zoom_in },
    {(char*) "xhelp_activate_zoom_out",(caddr_t)CoXHelpMotif::activate_zoom_out },
    {(char*) "xhelp_activate_zoom_reset",(caddr_t)CoXHelpMotif::activate_zoom_reset },
    {(char*) "xhelp_activate_search",(caddr_t)CoXHelpMotif::activate_search },
    {(char*) "xhelp_activate_searchnext",(caddr_t)CoXHelpMotif::activate_searchnext },
    {(char*) "xhelp_activate_searchprevious",(caddr_t)CoXHelpMotif::activate_searchprevious },
    {(char*) "xhelp_activate_india_ok",(caddr_t)CoXHelpMotif::activate_india_ok },
    {(char*) "xhelp_activate_india_cancel",(caddr_t)CoXHelpMotif::activate_india_cancel },
    {(char*) "xhelp_create_india_label",(caddr_t)CoXHelpMotif::create_india_label },
    {(char*) "xhelp_create_india_text",(caddr_t)CoXHelpMotif::create_india_text },
    {(char*) "xhelp_activate_help",(caddr_t)CoXHelpMotif::activate_help },
    {(char*) "xhelp_create_xhelpnav_form",(caddr_t)CoXHelpMotif::create_xhelpnav_form }
	};

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

  Lng::get_uid( uid_filename, uid_filename);

  // Motif
  MrmInitialize();

  strcpy( title, Lng::translate("Help"));
  reglist[0].value = (caddr_t) this;

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

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

  MrmRegisterNames(reglist, reglist_num);

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

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

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

  MrmCloseHierarchy(s_DRMh);


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

  i = 0;
  XtSetArg(args[i],XmNwidth,500);i++;
  XtSetArg(args[i],XmNheight,700);i++;
  XtSetValues( toplevel ,args,i);
    
  XtManageChild( toplevel);

  xhelpnav = new CoXHelpNavMotif( (void *)this, xhelpnav_form, title, utility, &brow_widget, 
                             &sts);
  xhelpnav->open_URL_cb = CoXHelp::open_URL;

  // XtPopup( parent_wid, XtGrabNone);
  // displayed = 1;
  XtRealizeWidget( parent_wid);

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

  *xa_sts = 1;
}
コード例 #15
0
XAttMotif::XAttMotif( Widget 		xa_parent_wid,
                      void 		*xa_parent_ctx,
                      pwr_sAttrRef 	*xa_objar,
                      int 		xa_advanced_user,
                      int             *xa_sts) :
    XAtt( xa_parent_ctx, xa_objar, xa_advanced_user, xa_sts),
    parent_wid(xa_parent_wid), set_focus_disabled(0),
    value_current_recall(0)
{
    char		uid_filename[120] = {"xtt_xatt.uid"};
    char		*uid_filename_p = uid_filename;
    Arg 		args[20];
    pwr_tStatus	sts;
    pwr_tAName   	title;
    int		i;
    MrmHierarchy s_DRMh;
    MrmType dclass;
    char		name[] = "Proview/R Navigator";

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

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

    static MrmRegisterArg	reglist[] = {
        {(char*) "xatt_ctx", 0 },
        {(char*) "xatt_activate_exit",(caddr_t)activate_exit },
        {(char*) "xatt_activate_display_object",(caddr_t)activate_display_object },
        {(char*) "xatt_activate_show_cross",(caddr_t)activate_show_cross },
        {(char*) "xatt_activate_open_classgraph",(caddr_t)activate_open_classgraph },
        {(char*) "xatt_activate_open_plc",(caddr_t)activate_open_plc },
        {(char*) "xatt_activate_change_value",(caddr_t)activate_change_value },
        {(char*) "xatt_activate_close_changeval",(caddr_t)activate_close_changeval },
        {(char*) "xatt_activate_help",(caddr_t)activate_help },
        {(char*) "xatt_create_msg_label",(caddr_t)create_msg_label },
        {(char*) "xatt_create_cmd_prompt",(caddr_t)create_cmd_prompt },
        {(char*) "xatt_create_cmd_input",(caddr_t)create_cmd_input },
        {(char*) "xatt_create_cmd_scrolledinput",(caddr_t)create_cmd_scrolledinput },
        {(char*) "xatt_create_cmd_scrolled_ok",(caddr_t)create_cmd_scrolled_ok },
        {(char*) "xatt_create_cmd_scrolled_ca",(caddr_t)create_cmd_scrolled_ca },
        {(char*) "xatt_create_xattnav_form",(caddr_t)create_xattnav_form },
        {(char*) "xatt_activate_cmd_scrolledinput",(caddr_t)activate_cmd_input },
        {(char*) "xatt_activate_cmd_scrolled_ok",(caddr_t)activate_cmd_scrolled_ok },
        {(char*) "xatt_activate_cmd_scrolled_ca",(caddr_t)activate_cmd_scrolled_ca }
    };

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

    // for ( i = 0; i < int(sizeof(value_recall)/sizeof(value_recall[0])); i++)
    //  value_recall[i][0] = 0;

    Lng::get_uid( uid_filename, uid_filename);

    // Create object context
//  attrctx->close_cb = close_cb;
//  attrctx->redraw_cb = redraw_cb;

    // Motif
    MrmInitialize();

    *xa_sts = gdh_AttrrefToName( &objar, title, sizeof(title), cdh_mNName);
    if ( EVEN(*xa_sts)) return;

    cdh_StrncpyCutOff( title, title, 100, 1);

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

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

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

    MrmRegisterNames(reglist, reglist_num);

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

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

    MrmCloseHierarchy(s_DRMh);


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

    if (compiled_translations == NULL)
        compiled_translations = XtParseTranslationTable(translations);
    XtOverrideTranslations( toplevel, compiled_translations);

    i = 0;
    XtSetArg(args[i],XmNwidth,420);
    i++;
    XtSetArg(args[i],XmNheight,600);
    i++;
    XtSetValues( toplevel ,args,i);

    XtManageChild( toplevel);
    XtUnmanageChild( cmd_input);
    XtUnmanageChild( cmd_scrolledinput);
    XtUnmanageChild( cmd_scrolled_ok);
    XtUnmanageChild( cmd_scrolled_ca);

    xattnav = new XAttNavMotif( (void *)this, xattnav_form, xattnav_eType_Object,
                                "Plant", &objar, xa_advanced_user, &brow_widget, &sts);
    xattnav->message_cb = &message_cb;
    xattnav->change_value_cb = &change_value_cb;
    xattnav->popup_menu_cb = &xatt_popup_menu_cb;
    xattnav->is_authorized_cb = &xatt_is_authorized_cb;

    XtPopup( parent_wid, XtGrabNone);

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

    *xa_sts = XATT__SUCCESS;
}