home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / sos3-2.lha / src / gsh / gsh_main.c < prev   
Encoding:
C/C++ Source or Header  |  1992-01-23  |  43.2 KB  |  1,509 lines
  1. /* --------------------------------------------------------------------------
  2.  * Copyright 1992 by Forschungszentrum Informatik (FZI)
  3.  *
  4.  * You can use and distribute this software under the terms of the licence
  5.  * you should have received along with this program.
  6.  * If not or if you want additional information, write to
  7.  * Forschungszentrum Informatik, "STONE", Haid-und-Neu-Strasse 10-14,
  8.  * D-7500 Karlsruhe 1, Germany.
  9.  * --------------------------------------------------------------------------
  10.  */
  11. #include <sys/file.h>          // avoid warning for flock
  12. #include <libc.h>
  13. #include <stdio.h>
  14.  
  15. #include "sys.h"
  16. #include "smg.h"
  17. #include "sos.h"
  18.  
  19. #include "gsh_err.h"
  20. #include "mta_use.h"
  21. #include "dir_use.h"
  22. #include "cci_use.h"
  23.  
  24. #define XTFUNCPROTO
  25.  
  26. #include <X11/IntrinsicP.h>
  27. #include <X11/Shell.h>
  28. extern "C" {
  29. #include <X11/Xaw/List.h>
  30. #include <X11/Xaw/Form.h>
  31. #include <X11/Xaw/Command.h>
  32. #include <X11/Xaw/Label.h>
  33. #include <X11/Xaw/Text.h>
  34. #define ASCII_STRING
  35. #include <X11/Xaw/AsciiText.h>
  36. #include <X11/Xaw/Viewport.h>
  37. }
  38. #include <X11/StringDefs.h>
  39. #include <X11/cursorfont.h>
  40.  
  41. #undef TRUE
  42. #undef FALSE
  43.  
  44. // ************************  Types and Objects  *************************
  45.  
  46. const int default_distance = 4;
  47. Pixel red_pxl, green_pxl, blue_pxl;
  48.  
  49. struct what_to_show
  50. {  sos_Bool cmp, met;
  51.    int operator== (what_to_show &s) {return cmp==s.cmp AND met == s.met;}
  52.    int operator!= (what_to_show &s) {return cmp!=s.cmp OR met != s.met;}
  53. };
  54. static what_to_show current_show = {TRUE, FALSE};
  55.  
  56. static cmd_count = 0;
  57. const cmd_string_length = 128;
  58. const cmd_value_length = 10;
  59.  
  60. struct cmd_menu
  61. {  sos_Object o;
  62.    sos_Method m;
  63.    Widget main;
  64.    int nr_pars;
  65.    Widget *par_wdgts;
  66.    char **par_txts;
  67. };
  68.  
  69. struct object_menu_comp
  70. {  sos_Bool is_method;
  71.    sos_Object o;    // isa sos_Method, if is_method
  72. };
  73.  
  74. struct object_menu
  75. {  sos_Object o;
  76.    int object_nr;
  77.    what_to_show show;
  78.    int nr_comps;
  79.    object_menu_comp *omc;
  80.    char **sl;
  81.  
  82.    object_menu(){}
  83.    ~object_menu();
  84. };
  85.  
  86. struct object_menu_item {object_menu_comp omc; char *s;};
  87. static struct omi_list
  88. {  object_menu_item *omi;
  89.    int nr_items;
  90.  
  91.    omi_list () {nr_items = 0;}
  92.  
  93.    void      clear();
  94.    void      insert (sos_Object o, sos_Bool is_method, char *s);
  95.    void      print (char*);
  96.    void      print (smg_String&);
  97.    void      print (sos_Object o);
  98.    void      make_object_menu (object_menu *om);
  99.  
  100. } omis;
  101.  
  102. enum ocmd_cmds {ocmd_FORMAT, ocmd_CMP, ocmd_MET, ocmd_QUIT};
  103. static char *ocmd_menu_items [5] =
  104.             {"Format", "hide components", "show methods", "quit"};
  105. static Widget ocmd_menu;
  106. static object_menu *ocmd_current_menu;
  107.  
  108. static class displayed_object_list
  109. {  displayed_object_list *next;
  110.    object_menu *om;
  111.    Widget w;
  112. public:
  113.    int number;
  114.  
  115.    displayed_object_list () {number = 0;}
  116.  
  117.    void        insert (object_menu *om, Widget w);
  118.    void        remove (object_menu *om);
  119.    Widget    widget (sos_Object o);
  120.    object_menu*    menu (sos_Object o);
  121.    object_menu*    menu_for_nr (int nr);
  122. } displayed_objects;
  123.  
  124. struct position
  125. {  int x, y;
  126.    static position root ();
  127.    static position at_widget (Widget w);
  128.    static position next_to (Widget w);
  129. };
  130.  
  131. static const    nr_menues = 3;
  132. static Widget    menu_header[nr_menues];
  133. static Widget    menu_list[nr_menues];
  134. enum hdr_cmds {hdr_FILE, hdr_VIEW, hdr_CONTAINER};
  135. static char*    menu_header_items [nr_menues] = {"File", "View", "Container"};
  136. enum file_cmds {file_ROOT, file_OBJECT, file_QUIT};
  137. enum view_cmds {view_CMP, view_MET};
  138. enum cnt_cmds {cnt_OPEN_READ, cnt_OPEN_WRITE, cnt_COMMIT, cnt_RESET,
  139.            cnt_CLOSE, cnt_CREATE, cnt_DESTROY};
  140. static char*    menu_list_items [nr_menues] [8] =
  141.             {  {"root", "object...", "quit"},
  142.                {"hide components", "show methods"},
  143.                {"open reading", "open writing", "commit", "reset",
  144.             "close", "create", "destroy"}
  145.         };
  146. static int    open_menu = nr_menues;
  147.  
  148. const int ac_max = 30;
  149. Arg      al[ac_max];
  150. int      ac;
  151.  
  152. Widget app_form_wdgt, form_wdgt;
  153.  
  154. const int   cnt_length = 10;
  155. static char cnt_string [cnt_length+1];
  156. const int   os_length = 10;
  157. static char os_string [os_length+1];
  158.  
  159. static struct
  160. {  Widget main, cnt, os;
  161. } co_menu_wdgts;
  162.  
  163. static struct
  164. {  Widget main, cnt;
  165. } cnt_menu_wdgts;
  166.  
  167. static cnt_cmds cnt_cmd;
  168.  
  169. sos_Object    root_object;
  170.  
  171. Widget        info_line_wdgt;
  172. const int    info_length = 80;
  173. char        info_string [info_length+1];
  174.  
  175. // ***********************  Global Functions  ***************************
  176.  
  177. static void      draw_frame (Display *disp, Window win, GC dragGC,
  178.                   int win_x, int win_y,
  179.                   Dimension width, Dimension height);
  180. static void      query_pointer (Display *disp, Window win,
  181.                    int &win_x, int &win_y,
  182.                    int xoffs, int yoffs);
  183. static void      drag_object (Widget w,
  184.                    caddr_t client_data,
  185.                    XEvent *event);
  186.  
  187. static void      object_callback (Widget w,
  188.                    caddr_t client_data,
  189.                    caddr_t call_data);
  190. static void      ocmd_callback (Widget w,
  191.                  caddr_t client_data,
  192.                  caddr_t call_data);
  193.  
  194. static sos_Object call_comp_method (sos_Object &o, sos_Method &m);
  195.  
  196. static void      display_component (sos_Object o,
  197.                      sos_Method m,
  198.                      what_to_show show);
  199. static void      display_class_instance (sos_Object o,
  200.                       sos_Class_type ct,
  201.                       what_to_show show);
  202. static void      display_object_menu (sos_Object o,
  203.                        position pos,
  204.                        what_to_show show);
  205.  
  206. static void      display_cmd_menu (sos_Object o, sos_Method m,
  207.                     int object_nr, position pos);
  208.  
  209. static void      menu_list_callback (Widget w,
  210.                       caddr_t client_data,
  211.                       caddr_t call_data);
  212. static void      menu_header_callback (Widget w,
  213.                     caddr_t client_data,
  214.                     caddr_t call_data);
  215.  
  216. static void      co_cancel_callback (Widget w,
  217.                       caddr_t client_data,
  218.                       caddr_t call_data);
  219. static void      co_do_callback (Widget w,
  220.                   caddr_t client_data,
  221.                   caddr_t call_data);
  222. static void      display_co_menu();
  223.  
  224. static void      cnt_cancel_callback (Widget w,
  225.                        caddr_t client_data,
  226.                        caddr_t call_data);
  227. static void      cnt_do_callback (Widget w,
  228.                    caddr_t client_data,
  229.                    caddr_t call_data);
  230. static void      display_cnt_menu();
  231.  
  232. static void      display_root();
  233. static void      display_info (err_msg msg);
  234.  
  235. static void      install_header_menues ();
  236. static void      install_ocmd_menu ();
  237. static void      install_dialogues ();
  238.  
  239. // **********************  SetValue Arguments  **************************
  240.  
  241. void inline inc_ac()
  242. {  if (ac >= ac_max)
  243.    {  fprintf (stderr, "argument overflow\n");
  244.       exit (1);
  245.    }
  246.    ac++;
  247. }
  248.  
  249. // ***************************  Dragging  *******************************
  250.  
  251. void draw_frame (Display *disp, Window win, GC dragGC,
  252.              int win_x, int win_y,
  253.              Dimension width, Dimension height)
  254. {  XDrawRectangle (disp, win, dragGC, win_x, win_y, width, height);
  255. }
  256.  
  257. void inline query_pointer (Display *disp, Window win,
  258.                int &win_x, int &win_y,
  259.                int xoffs, int yoffs)
  260. {  Window    rootwin, childwin;
  261.    int        root_x, root_y;
  262.    unsigned int    mask;
  263.  
  264.    XQueryPointer (disp, win,
  265.           &rootwin, &childwin,
  266.           &root_x, &root_y,
  267.           &win_x, &win_y, &mask);
  268.    win_x -= xoffs; if (win_x < 0) win_x = 0;
  269.    win_y -= yoffs; if (win_y < 0) win_y = 0;
  270. }
  271.  
  272. void drag_object (Widget w, caddr_t, XEvent *event)
  273. {  XEvent    ev;
  274.    Widget    parent = XtParent (w);
  275.    Display    *disp = XtDisplay (parent);
  276.    Window     win = XtWindow (parent);
  277.    GC        dragGC;
  278.    Dimension    width, height, borderwidth;
  279.    int        win_x, win_y;
  280.    int        xoffs, yoffs;
  281.    static int    initGC = TRUE;
  282.  
  283.  
  284.    if (event->xbutton.button != 2) return;
  285.  
  286.    // GC beim ersten Aufruf initialisieren
  287.    if (initGC == TRUE)
  288.    { 
  289.       dragGC = XCreateGC (disp, win, 0, NULL);
  290.       XSetForeground (disp, dragGC, BlackPixel (disp, 0));
  291.       XSetSubwindowMode (disp, dragGC, IncludeInferiors);
  292.       XSetFunction (disp, dragGC, GXxor);
  293.    }
  294.  
  295.    ac=0;
  296.    XtSetArg (al[ac], XtNwidth, &width); inc_ac();
  297.    XtSetArg (al[ac], XtNheight, &height); inc_ac();
  298.    XtSetArg (al[ac], XtNborderWidth, &borderwidth); inc_ac();
  299.    XtGetValues (w, al, ac);
  300.  
  301.    xoffs = event->xbutton.x + borderwidth;
  302.    yoffs = event->xbutton.y + borderwidth;
  303.  
  304.    query_pointer (disp, win, win_x, win_y, xoffs, yoffs);
  305.    draw_frame (disp, win, dragGC, win_x, win_y, width, height);
  306.  
  307.    XChangeActivePointerGrab(disp,
  308.                 (unsigned)(ButtonReleaseMask | ButtonMotionMask
  309.                              | OwnerGrabButtonMask),
  310.                 XCreateFontCursor (disp, XC_fleur),
  311.                 (Time)CurrentTime);
  312.   
  313.    while (TRUE)
  314.    {  XtNextEvent (&ev);
  315.       switch (ev.type)
  316.       {  case MotionNotify:
  317.         draw_frame (disp, win, dragGC, win_x, win_y, width, height);
  318.         query_pointer (disp, win, win_x, win_y, xoffs, yoffs);
  319.         draw_frame (disp, win, dragGC, win_x, win_y, width, height);
  320.         break;
  321.      case ButtonRelease:
  322.         if (ev.xbutton.button == 2)
  323.         {  draw_frame (disp, win, dragGC, win_x, win_y, width, height);
  324.            query_pointer (disp, win, win_x, win_y, xoffs, yoffs);
  325.  
  326.            XtMoveWidget (w, win_x, win_y);
  327.            XRaiseWindow (XtDisplay (w), XtWindow (w));
  328.            ac=0;
  329.            XtSetArg (al[ac], XtNhorizDistance, win_x); inc_ac();
  330.            XtSetArg (al[ac], XtNvertDistance, win_y); inc_ac();
  331.            XtSetValues (w, al, ac);
  332.            XtUnmanageChild (w);
  333.            XtManageChild (w);
  334.            return;
  335.         }
  336.         break;
  337.       }
  338.    }
  339. }
  340.  
  341. // *************************  Object Menues  ****************************
  342.  
  343. object_menu::~object_menu()
  344. {  for (int i=0; i<nr_comps; i++)
  345.       delete sl[i];
  346.    delete omc;
  347.    delete sl;
  348. }
  349.  
  350. void omi_list::clear ()
  351. {  omi = 0;
  352.    nr_items = 0;
  353. }
  354.  
  355. void omi_list::insert (sos_Object o, sos_Bool is_method, char *s)
  356. {  if (nr_items % 10 == 0)
  357.    {  object_menu_item *new_omi = new object_menu_item [nr_items+10];
  358.       for (int i=0; i<nr_items; i++)
  359.          new_omi[i] = omi[i];
  360.       delete omi;
  361.       omi = new_omi;
  362.    }
  363.    omi [nr_items].s = new char [strlen(s)+1];
  364.    strcpy (omi [nr_items].s, s);
  365.    omi [nr_items].omc.is_method = is_method;
  366.    omi [nr_items].omc.o = o;
  367.    nr_items++;
  368. }
  369.  
  370. void omi_list::print (char *s)
  371. {  char *new_str = new char [strlen (s) + strlen (omi [nr_items-1].s) + 1];
  372.    strcpy (new_str, omi [nr_items-1].s);
  373.    strcat (new_str, s);
  374.    delete omi [nr_items-1].s;
  375.    omi [nr_items-1].s = new_str;
  376. }
  377.  
  378. void omi_list::print (smg_String &s)
  379. {  print (s.make_Cstring(SMG_BORROW));
  380. }
  381.  
  382. void omi_list::print (sos_Object o)
  383. {  if (o == NO_OBJECT)
  384.    {  print ("<>");
  385.       return;
  386.    }
  387.  
  388.    sos_Type tp = o.type();
  389.  
  390.    if (tp.has_type (sos_Class_type_type))
  391.    {  if (o.isa (sos_Named_type))
  392.       {  sos_String str = sos_Named::make (o).get_name();
  393.      if (str != NO_OBJECT)
  394.         print (str.make_Cstring());
  395.      print ("...");
  396.       }
  397.       else if (o.isa (sos_String_type))
  398.       {  print ("\"");
  399.      print (sos_String::make (o).make_Cstring());
  400.      print ("\"");
  401.       }
  402.       else
  403.      print ("...");
  404.    }
  405.    else if (tp.has_type (sos_Enum_type_type))
  406.    {  int i = sos_Int_from_enum (o, tp);
  407.       print (sos_Enum_type::make (tp).get_literals().get_nth (i+1).
  408.         make_Cstring());
  409.    }
  410.    else if (tp.has_type (sos_Extern_type_type))
  411.       print (cci_Schema_impl::string_from_extern_object (o).make_Cstring());
  412.    else
  413.       print ("???");
  414. }
  415.  
  416. static int compare_omi (void *c1, void *c2)
  417. {  return strcmp (((object_menu_item*)c1)->s, ((object_menu_item*)c2)->s);
  418. }
  419.  
  420. void omi_list::make_object_menu (object_menu *om)
  421. {  qsort (&omi[2], nr_items-2, sizeof(object_menu_item), compare_omi);
  422.    char **sl = new char* [nr_items];
  423.    object_menu_comp *omc = new object_menu_comp [nr_items];
  424.    om->nr_comps = nr_items;
  425.    om->sl = sl;
  426.    om->omc = omc;
  427.    for (int i=0; i<nr_items; i++)
  428.    {  sl[i] = omi[i].s;
  429.       omc[i] = omi[i].omc;
  430.    }
  431. }
  432.  
  433. void object_callback (Widget w, caddr_t client_data, caddr_t call_data)
  434. {  int i = ((XawListReturnStruct*) call_data)->list_index;
  435.    object_menu *om = (object_menu*) client_data;
  436.  
  437.    XawListUnhighlight (w);
  438.  
  439.    if (i == 0)
  440.    {  position pos = position::at_widget (w);
  441.       if (om->show.cmp)
  442.      ocmd_menu_items [1] = "hide components";
  443.       else
  444.      ocmd_menu_items [1] = "show components";
  445.       if (om->show.met)
  446.      ocmd_menu_items [2] = "hide methods";
  447.       else
  448.      ocmd_menu_items [2] = "show methods";
  449.       XawListHighlight (ocmd_menu, 0);
  450.       XtMoveWidget (ocmd_menu, pos.x, pos.y);
  451.       XtMapWidget (ocmd_menu);
  452.       XRaiseWindow (XtDisplay (ocmd_menu), XtWindow (ocmd_menu));
  453.       XtAddGrab (ocmd_menu, TRUE, FALSE);
  454.       ocmd_current_menu = om;
  455.    }
  456.    else
  457.    {  object_menu_comp omc;
  458.       omc = om->omc[i];
  459.       if (omc.is_method)
  460.      display_cmd_menu (om->o, sos_Method::make (omc.o),
  461.                om->object_nr, position::next_to (w));
  462.       else
  463.      display_object_menu (omc.o, position::next_to (w), current_show);
  464.    }
  465. }
  466.  
  467. // **********************  Object Command Menu  *************************
  468.  
  469. void ocmd_callback (Widget, caddr_t, caddr_t call_data)
  470. {  ocmd_cmds cmd = ocmd_cmds (((XawListReturnStruct*) call_data)->list_index);
  471.    sos_Object o;
  472.    position pos;
  473.    what_to_show show;
  474.  
  475.    XtRemoveGrab (ocmd_menu);
  476.    XtUnmapWidget (ocmd_menu);
  477.  
  478.    switch (cmd)
  479.    {  case ocmd_FORMAT:
  480.      break;
  481.       case ocmd_CMP:
  482.      o = ocmd_current_menu->o;
  483.      pos = position::at_widget
  484.           (displayed_objects.widget (ocmd_current_menu->o));
  485.      show = ocmd_current_menu->show;
  486.      show.cmp = (sos_Bool)(NOT show.cmp);
  487.      display_object_menu (o, pos, show);
  488.      break;
  489.       case ocmd_MET:
  490.      o = ocmd_current_menu->o;
  491.      pos = position::at_widget
  492.           (displayed_objects.widget (ocmd_current_menu->o));
  493.      show = ocmd_current_menu->show;
  494.      show.met = (sos_Bool)(NOT show.met);
  495.      display_object_menu (o, pos, show);
  496.      break;
  497.       case ocmd_QUIT:
  498.      displayed_objects.remove (ocmd_current_menu);
  499.      break;
  500.       default:
  501.      break;
  502.    }
  503.    ocmd_current_menu = 0;
  504. }
  505.  
  506. // *************************  Dumped Objects  ***************************
  507.  
  508. void displayed_object_list::insert (object_menu *om, Widget w)
  509. {  displayed_object_list *ol = new displayed_object_list;
  510.    ol->next = next;
  511.    ol->om = om;
  512.    ol->w = w;
  513.    next = ol;
  514.    number++;
  515. }
  516.  
  517. void displayed_object_list::remove (object_menu *om)
  518. {  for (displayed_object_list *ol = this; ol->next; ol=ol->next)
  519.       if (ol->next->om == om)
  520.       {  displayed_object_list *od = ol->next;
  521.      ol->next = ol->next->next;
  522.      XtDestroyWidget (od->w);
  523.      delete od;
  524.      delete om;
  525.      return;
  526.       }
  527. }
  528.  
  529. Widget displayed_object_list::widget (sos_Object o)
  530. {  for (displayed_object_list *ol = next; ol; ol=ol->next)
  531.       if (ol->om->o == o)
  532.      return ol->w;
  533.    return NULL;
  534. }
  535.  
  536. object_menu* displayed_object_list::menu (sos_Object o)
  537. {  for (displayed_object_list *ol = next; ol; ol=ol->next)
  538.       if (ol->om->o == o)
  539.      return ol->om;
  540.    return 0;
  541. }
  542.  
  543. object_menu* displayed_object_list::menu_for_nr (int nr)
  544. {  for (displayed_object_list *ol = next; ol; ol=ol->next)
  545.       if (ol->om->object_nr == nr)
  546.      return ol->om;
  547.    return 0;
  548. }
  549.  
  550. // ************************  Widget Positions  **************************
  551.  
  552. position position::root ()
  553. {  position result;
  554.    result.x = default_distance;
  555.    result.y = default_distance;
  556.    return result;
  557. }
  558.  
  559. position position::at_widget (Widget w)
  560. {  ac=0;
  561.    position result;
  562.    int width;
  563.  
  564.    XtSetArg (al[ac], XtNhorizDistance, &result.x); inc_ac();
  565.    XtSetArg (al[ac], XtNvertDistance, &result.y); inc_ac();
  566.    XtSetArg (al[ac], XtNwidth, &width); inc_ac();
  567.    XtGetValues (w, al, ac);
  568.    return result;
  569. }
  570.  
  571. position position::next_to (Widget w)
  572. {  ac=0;
  573.    position result;
  574.    Dimension width;
  575.  
  576.    XtSetArg (al[ac], XtNhorizDistance, &result.x); inc_ac();
  577.    XtSetArg (al[ac], XtNvertDistance, &result.y); inc_ac();
  578.    XtSetArg (al[ac], XtNwidth, &width); inc_ac();
  579.    XtGetValues (w, al, ac);
  580.    result.x += width + default_distance;
  581.    return result;
  582. }
  583.  
  584. // *******************  Display Object Components  **********************
  585.  
  586. void exec_method (sos_Method &m, sos_Object &o, sos_Object_Array &p,
  587.           sos_Object &result)
  588. {  result = m.execute (o, p);
  589. }
  590.  
  591. sos_Object call_comp_method (sos_Object &o, sos_Method &m)
  592. {  sos_Object result;
  593.  
  594.    err_block
  595.    {  exec_method (m, o, sos_Object_Array::make (NO_OBJECT), result);
  596.    }
  597.    err_exception
  598.    {  display_info(err_last_raised());
  599.       result = NO_OBJECT;
  600.    }
  601.    err_block_end
  602.  
  603.    return result;
  604. }
  605.  
  606. void display_component (sos_Object o, sos_Method m, what_to_show show)
  607. {  sos_Method rm = m.get_generated_from();
  608.    if (rm == NO_OBJECT)
  609.       rm = m;
  610.  
  611.    if (rm.get_kind() == sos_PUBLIC)
  612.    {  if (rm.has_type (sos_Comp_method_type) AND
  613.       NOT sos_Comp_method::make (rm).get_is_set())
  614.       {  if (show.cmp)
  615.      {  err_block
  616.         {  sos_Object co = call_comp_method (o, rm);
  617.            omis.insert (co, FALSE, "");
  618.            omis.print (rm.get_name().make_Cstring());
  619.            omis.print ("=");
  620.            omis.print (co);
  621.         }
  622.         err_exception
  623.         {  omis.insert (NO_OBJECT, FALSE, "");
  624.            omis.print (rm.get_name().make_Cstring());
  625.            omis.print ("=???");
  626.         }
  627.         err_block_end
  628.      }
  629.       }
  630.       else
  631.       {  if (show.met)
  632.      {  omis.insert (rm, TRUE, "");
  633.         omis.print (rm.get_name().make_Cstring());
  634.         omis.print ("(...)");
  635.      }
  636.       }
  637.    }
  638. }
  639.  
  640. void display_class_instance (sos_Object o,
  641.                  sos_Class_type ct,
  642.                  what_to_show show)
  643. {  sos_Method_table mt = ct.get_inherited_methods();
  644.    agg_iterate_association (mt, sos_String name, sos_Method_List ml)
  645.    {  agg_iterate (ml, sos_Method m)
  646.       {  if (NOT m.get_is_static ())
  647.         display_component (o, m, show);
  648.       }
  649.       agg_iterate_end (ml, m);
  650.    }
  651.    agg_iterate_association_end (mt, name, ml);
  652.  
  653.    if (o.has_type (sos_Class_type_type))
  654.    {  if (show.met)
  655.       {  sos_Method_List ml = sos_Class_type::make(o).get_static_methods();
  656.      agg_iterate (ml, sos_Method m)
  657.      {  display_component (o, m, show);
  658.      }
  659.      agg_iterate_end (ml, m);
  660.       }
  661.    }
  662.    else if (show.cmp)
  663.    {  if(o.is_some (sos_String_type))
  664.       {  omis.insert (NO_OBJECT, FALSE, "");
  665.      omis.print ("*value*=\"");
  666.      omis.print (sos_String::make (o).make_Cstring());
  667.      omis.print ("\"");
  668.       }
  669.       else if (o.is_some (sos_Object_Collection_type))
  670.       {  sos_Object_Collection coll = sos_Object_Collection::make (o);
  671.      int vno = 1;
  672.      agg_iterate (coll, sos_Object co)
  673.      {  char s [20];
  674.         sprintf (s, "get_elem[%d]=", vno);
  675.         omis.insert (co, FALSE, s);
  676.         omis.print (co);
  677.         vno++;
  678.      }
  679.      agg_iterate_end (coll, co);
  680.       }
  681.       else if (o.is_some (sos_Object_sos_Object_Association_type))
  682.       {  sos_Object_sos_Object_Association as =
  683.         sos_Object_sos_Object_Association::make (o);
  684.      int vno = 1;
  685.      agg_iterate_association (as, sos_Object role1, sos_Object role2)
  686.      {  char s [20];
  687.         sprintf (s, "get_role1[%d]=", vno);
  688.         omis.insert (role1, FALSE, s);
  689.         omis.print (role1);
  690.         sprintf (s, "get_role2[%d]=", vno);
  691.         omis.insert (role2, FALSE, s);
  692.         omis.print (role2);
  693.         vno++;
  694.      }
  695.      agg_iterate_association_end (as, role1, role2);
  696.       }
  697.    }
  698. }
  699.  
  700. void display_object_menu (sos_Object o, position pos, what_to_show show)
  701. {  if (o == NO_OBJECT) return;
  702.  
  703.    // determine new window position
  704.  
  705.    object_menu *om = displayed_objects.menu (o);
  706.    if (om AND om->show == show) // object is already displayed
  707.    {  Widget wo = displayed_objects.widget (o);
  708.       XtMoveWidget (wo, pos.x, pos.y);
  709.       XRaiseWindow (XtDisplay (wo), XtWindow (wo));
  710.       ac=0;
  711.       XtSetArg (al[ac], XtNhorizDistance, pos.x); inc_ac();
  712.       XtSetArg (al[ac], XtNvertDistance, pos.y); inc_ac();
  713.       XtSetValues (wo, al, ac);
  714.       XtUnmanageChild (wo);
  715.       XtManageChild (wo);
  716.    }
  717.    else // construct new object widget
  718.    {  omis.clear();
  719.  
  720.       int nr;
  721.       sos_Type tp = o.type();
  722.       if (om)
  723.       {  nr = om->object_nr;
  724.      displayed_objects.remove (om);
  725.       }
  726.       else
  727.      nr = displayed_objects.number+1;
  728.  
  729.       char on [30];
  730.       if (tp.has_type (sos_Extern_type_type))
  731.      sprintf (on, "#%d", nr);
  732.       else
  733.      sprintf (on, "#%d <%d,%d>", nr, int (o.container()), o.offset());
  734.       omis.insert (NO_OBJECT, FALSE, on);
  735.    
  736.       omis.insert (tp, FALSE, "type=");
  737.       omis.print (tp.get_name().make_Cstring());
  738.  
  739.       if (tp.has_type (sos_Class_type_type))
  740.      display_class_instance (o, sos_Class_type::make(tp), show);
  741.       else
  742.       {  omis.insert (NO_OBJECT, FALSE, "*value*=");
  743.      omis.print (o);
  744.       }
  745.  
  746.       object_menu *om = new object_menu;
  747.       om->o = o;
  748.       om->show = show;
  749.       om->object_nr = nr;
  750.       omis.make_object_menu (om);
  751.  
  752.       ac=0;
  753.       XtSetArg (al[ac], XtNnumberStrings, omis.nr_items); inc_ac();
  754.       XtSetArg (al[ac], XtNlist, om->sl); inc_ac();
  755.       XtSetArg (al[ac], XtNverticalList, TRUE); inc_ac();
  756.       XtSetArg (al[ac], XtNforceColumns, TRUE); inc_ac();
  757.       XtSetArg (al[ac], XtNdefaultColumns, 1); inc_ac();
  758.  
  759.       XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  760.       XtSetArg (al[ac], XtNbottom, XtChainTop); inc_ac();
  761.       XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  762.       XtSetArg (al[ac], XtNright, XtChainLeft); inc_ac();
  763.  
  764.       XtSetArg (al[ac], XtNhorizDistance, pos.x); inc_ac();
  765.       XtSetArg (al[ac], XtNvertDistance, pos.y); inc_ac();
  766.  
  767.       XtSetArg (al[ac], XtNborderWidth, 2); inc_ac();
  768.       XtSetArg (al[ac], XtNborderColor, red_pxl); inc_ac();
  769.       XtSetArg (al[ac], XtNforeground, blue_pxl); inc_ac();
  770.  
  771.       char name [20];
  772.       sprintf (name, "object%d", nr);
  773.  
  774.       Widget object_wdgt = XtCreateManagedWidget
  775.                (name, listWidgetClass, form_wdgt, al, ac);
  776.       XtAddCallback (object_wdgt, XtNcallback,
  777.              (XtCallbackProc) object_callback, (caddr_t) om);
  778.       XtAddEventHandler (object_wdgt, ButtonPressMask, FALSE,
  779.              (XtEventHandler) drag_object, NULL);
  780.  
  781.       XRaiseWindow (XtDisplay (object_wdgt), XtWindow (object_wdgt));
  782.       displayed_objects.insert (om, object_wdgt);
  783.    }
  784. }
  785.  
  786. void cmd_cancel_callback (Widget, caddr_t client_data, caddr_t)
  787. {  cmd_menu *cm = (cmd_menu*) client_data;
  788.  
  789.    XtDestroyWidget (cm->main);
  790.    for (int i=0; i<cm->nr_pars; i++)
  791.       delete cm->par_txts [i];
  792.    delete cm->par_txts;
  793.    delete cm->par_wdgts;
  794.    delete cm;
  795. }
  796.  
  797. void cmd_do_callback (Widget, caddr_t client_data, caddr_t)
  798. {  cmd_menu *cm = (cmd_menu*) client_data;
  799.    sos_Param_List pl = cm->m.get_params();
  800.    sos_Object_Array pa = sos_Object_Array::create
  801.                 (TEMP_CONTAINER, 0, cm->nr_pars);
  802.    sos_Bool error = FALSE;
  803.  
  804.    int i=0;
  805.    agg_iterate (pl, sos_Param p)
  806.    {  sos_Type tp = p.get_type_name().make_base_type();
  807.       if (tp.has_type (sos_Enum_type_type))
  808.       {  sos_String_List ll = sos_Enum_type::make (tp).get_literals();
  809.      error = TRUE;
  810.      int lnr = 0;
  811.      agg_iterate (ll, sos_String l)
  812.      {  sos_String str =
  813.            smg_String (cm->par_txts [i]).make_String (TEMP_CONTAINER);
  814.         if (l.equal (str))
  815.         {  pa.set_nth (i, sos_enum_from_sos_Int (lnr, tp));
  816.            error = FALSE;
  817.            str.destroy();
  818.            break;
  819.         }
  820.         else
  821.            str.destroy();
  822.         lnr++;
  823.      }
  824.      agg_iterate_end (ll, l);
  825.       }
  826.       else if (tp.has_type (sos_Extern_type_type))
  827.       {  sos_String s =
  828.         smg_String (cm->par_txts [i]).make_String (TEMP_CONTAINER);
  829.      sos_Object ext = cci_Schema_impl::extern_object_from_string (tp, s);
  830.      if (ext == NO_OBJECT)
  831.         error = TRUE;
  832.      else
  833.         pa.set_nth (i, ext);
  834.       }
  835.       else
  836.       {  int nr = atoi (cm->par_txts [i]);
  837.      if (nr == 0)
  838.         error = TRUE;
  839.      else
  840.      {  object_menu *om = displayed_objects.menu_for_nr (nr);
  841.         if (om == 0)
  842.            error = TRUE;
  843.         else
  844.            pa.set_nth (i, om->o);
  845.      }
  846.       }
  847.       if (error)
  848.       {  char info [40];
  849.      sprintf (info, "parameter %d invalid", i+1);
  850.      display_info(info);
  851.      break;
  852.       }
  853.       i++;
  854.    }
  855.    agg_iterate_end (pl, p);
  856.  
  857.    if (NOT error)
  858.    {  err_block
  859.       {  sos_Object result;
  860.      exec_method (cm->m, cm->o, pa, result);
  861.      XtDestroyWidget (cm->main);
  862.      for (int i=0; i<cm->nr_pars; i++)
  863.         delete cm->par_txts [i];
  864.      delete cm->par_txts;
  865.      delete cm->par_wdgts;
  866.      delete cm;
  867.      display_object_menu
  868.         (result, position::at_widget (cm->main), current_show);
  869.       }
  870.       err_exception
  871.       {  display_info(err_last_raised());
  872.       }
  873.       err_block_end
  874.    }
  875.    pa.destroy();
  876. }
  877.  
  878. void display_cmd_menu (sos_Object o, sos_Method m, int object_nr, position pos)
  879. {  cmd_menu *cm = new cmd_menu;
  880.    Widget w, w1, do_but, cancel_but;
  881.    sos_Param_List pl = m.get_params();
  882.  
  883.    char nm [20], *s, *s1, *txt;
  884.  
  885.    cm->o=o;
  886.    cm->m=m;
  887.    cm->nr_pars = pl.card();
  888.    cm->par_wdgts = new Widget [cm->nr_pars];
  889.    cm->par_txts = new char* [cm->nr_pars];
  890.  
  891.    ac=0;
  892.    XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  893.    XtSetArg (al[ac], XtNbottom, XtChainTop); inc_ac();
  894.    XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  895.    XtSetArg (al[ac], XtNright, XtChainLeft); inc_ac();
  896.  
  897.    XtSetArg (al[ac], XtNhorizDistance, pos.x); inc_ac();
  898.    XtSetArg (al[ac], XtNvertDistance, pos.y); inc_ac();
  899.  
  900.    XtSetArg (al[ac], XtNwidth, 100); inc_ac();
  901.    XtSetArg (al[ac], XtNheight, 100); inc_ac();
  902.    XtSetArg (al[ac], XtNresizable, TRUE); inc_ac();
  903.  
  904.    XtSetArg (al[ac], XtNborderWidth, 2); inc_ac();
  905.    XtSetArg (al[ac], XtNborderColor, red_pxl); inc_ac();
  906.    XtSetArg (al[ac], XtNforeground, blue_pxl); inc_ac();
  907.  
  908.    sprintf (nm, "cmd.main%d", cmd_count);
  909.    cm->main = XtCreateWidget
  910.          (nm, formWidgetClass, form_wdgt, al, ac);
  911.    XtAddEventHandler (cm->main, ButtonPressMask, FALSE,
  912.               (XtEventHandler) drag_object, NULL);
  913.  
  914.    ac=0;
  915.    s = m.get_name().make_Cstring();
  916.    s1 = m.get_result_type().make_type_name().make_Cstring();
  917.    txt = new char [strlen(s)+strlen(s1)+20];
  918.    sprintf (txt, "#%d.%s(...)->%s", object_nr, s, s1);
  919.    XtSetArg (al[ac], XtNlabel, txt); inc_ac();
  920.    XtSetArg (al[ac], XtNborderWidth, 0); inc_ac();
  921.    sprintf (nm, "cmd.hdr%d", cmd_count);
  922.    w = XtCreateManagedWidget
  923.         (nm, labelWidgetClass, cm->main, al, ac);
  924.    delete txt;
  925.    delete s1;
  926.    delete s;
  927.  
  928.    int i = 0;
  929.    agg_iterate (pl, sos_Param p)
  930.    {  sos_Type_name tn = p.get_type_name();
  931.       sos_Type tp = tn.make_base_type();
  932.       int sl;
  933.  
  934.       ac=0;
  935. #ifdef ATT
  936.       if (tp.operator==(sos_Cstring_type) OR tp.has_type (sos_Enum_type_type))
  937. #else
  938.       if (tp == sos_Cstring_type OR tp.has_type (sos_Enum_type_type))
  939. #endif
  940.       {  sl = cmd_string_length;
  941.      XtSetArg (al[ac], XtNscrollHorizontal, TRUE); inc_ac();
  942.      XtSetArg (al[ac], XtNheight, 30); inc_ac();
  943.       }
  944.       else
  945.      sl = cmd_value_length;
  946.  
  947.       cm->par_txts [i] = new char [sl];
  948.       strcpy (cm->par_txts [i], "");
  949.       XtSetArg (al[ac], XtNlength, cmd_string_length); inc_ac();
  950.       XtSetArg (al[ac], XtNstring, cm->par_txts [i]); inc_ac();
  951.       XtSetArg (al[ac], XtNfromVert, w); inc_ac();
  952.       XtSetArg (al[ac], XtNeditType, XawtextEdit); inc_ac();
  953.       sprintf (nm, "cmd.lab%d/%d", cmd_count, i);
  954.       cm->par_wdgts [i] = XtCreateManagedWidget
  955.            (nm, asciiStringWidgetClass, cm->main, al, ac);
  956.       XawTextEnableRedisplay (cm->par_wdgts [i]);
  957.  
  958.       ac=0;
  959.       sos_String pn = p.get_name();
  960.       s = p.get_type_name().make_type_name().make_Cstring();
  961.       if (pn == NO_OBJECT)
  962.      s1 = strdup ("");
  963.       else
  964.      s1 = pn.make_Cstring();
  965.       txt = new char [strlen(s)+strlen(s1)+2];
  966.       sprintf (txt, "%s %s", s, s1);
  967.       XtSetArg (al[ac], XtNlabel, txt); inc_ac();
  968.       XtSetArg (al[ac], XtNborderWidth, 0); inc_ac();
  969.       XtSetArg (al[ac], XtNfromVert, w); inc_ac();
  970.       XtSetArg (al[ac], XtNfromHoriz, cm->par_wdgts [i]); inc_ac();
  971.       sprintf (nm, "cmd.val%d/%d", cmd_count, i);
  972.       w1 = XtCreateManagedWidget
  973.            (nm, labelWidgetClass, cm->main, al, ac);
  974.       delete txt;
  975.       delete s1;
  976.       delete s;
  977.  
  978.       w = cm->par_wdgts [i];
  979.       i++;
  980.    }
  981.    agg_iterate_end (pl, p);
  982.  
  983.    ac=0;
  984.    XtSetArg (al[ac], XtNlabel, "  do  "); inc_ac();
  985.    XtSetArg (al[ac], XtNfromVert, w); inc_ac();
  986.    sprintf (nm, "cmd.do%d", cmd_count);
  987.    do_but = XtCreateManagedWidget
  988.         (nm, commandWidgetClass, cm->main, al, ac);
  989.    XtAddCallback (do_but, XtNcallback,
  990.           (XtCallbackProc) cmd_do_callback, (caddr_t) cm);
  991.  
  992.    ac=0;
  993.    XtSetArg (al[ac], XtNlabel, "cancel"); inc_ac();
  994.    XtSetArg (al[ac], XtNfromVert, w); inc_ac();
  995.    XtSetArg (al[ac], XtNfromHoriz, do_but); inc_ac();
  996.    XtSetArg (al[ac], XtNhorizDistance, 20); inc_ac();
  997.    sprintf (nm, "cmd.cancel%d", cmd_count);
  998.    cancel_but = XtCreateManagedWidget
  999.         (nm, commandWidgetClass, cm->main, al, ac);
  1000.    XtAddCallback (cancel_but, XtNcallback,
  1001.           (XtCallbackProc) cmd_cancel_callback, (caddr_t) cm);
  1002.  
  1003.    XtManageChild (cm->main);
  1004.  
  1005.    cmd_count++;
  1006. }
  1007.  
  1008. // ****************************  Menues  ********************************
  1009.  
  1010. void menu_list_callback (Widget w, caddr_t client_data, caddr_t call_data)
  1011. {  XawListReturnStruct *l = (XawListReturnStruct*) call_data;
  1012.    hdr_cmds hdr_cmd = hdr_cmds (client_data);
  1013.  
  1014.    XawListUnhighlight (w);
  1015.  
  1016.    XtRemoveGrab (menu_header[0]);
  1017.    open_menu = nr_menues;
  1018.    XtUnmapWidget (w);
  1019.  
  1020.    switch (hdr_cmd)
  1021.    {  case hdr_FILE:
  1022.      file_cmds file_cmd = file_cmds (l->list_index);
  1023.      switch (file_cmd)
  1024.      {  case file_ROOT:
  1025.            display_root();
  1026.            break;
  1027.         case file_OBJECT:
  1028.            display_co_menu();
  1029.            break;
  1030.         case file_QUIT:
  1031.            exit (0);
  1032.            break;
  1033.         default:
  1034.            break;
  1035.      }
  1036.      break;
  1037.       case hdr_VIEW:
  1038.      view_cmds view_cmd = view_cmds (l->list_index);
  1039.      switch (view_cmd)
  1040.      {  case view_CMP:
  1041.            current_show.cmp = (sos_Bool)(NOT current_show.cmp);
  1042.            if (current_show.cmp)
  1043.           menu_list_items [hdr_VIEW] [view_CMP] = "hide components";
  1044.            else
  1045.           menu_list_items [hdr_VIEW] [view_CMP] = "show components";
  1046.            break;
  1047.         case view_MET:
  1048.            current_show.met = (sos_Bool)(NOT current_show.met);
  1049.            if (current_show.met)
  1050.           menu_list_items [hdr_VIEW] [view_MET] = "hide methods";
  1051.            else
  1052.           menu_list_items [hdr_VIEW] [view_MET] = "show methods";
  1053.            break;
  1054.         default:
  1055.            break;
  1056.      }
  1057.      break;
  1058.       case hdr_CONTAINER:
  1059.      cnt_cmd = cnt_cmds (l->list_index);
  1060.      if (cnt_cmd == cnt_CREATE)
  1061.      {  display_object_menu
  1062.            (make_sos_Container_object (sos_Container::create()),
  1063.         position::root(), current_show);
  1064.      }
  1065.      else
  1066.         display_cnt_menu();
  1067.      break;
  1068.       default:
  1069.      break;
  1070.    }
  1071. }
  1072.  
  1073. void menu_header_callback (Widget, caddr_t client_data, caddr_t)
  1074. {  int i = (int) client_data;
  1075.    Widget lw = menu_list[i];
  1076.  
  1077.    if (i == open_menu)
  1078.    {  XtRemoveGrab (menu_header[0]);
  1079.       open_menu = nr_menues;
  1080.       XtUnmapWidget (lw);
  1081.    }
  1082.    else
  1083.    {  if (open_menu < nr_menues)
  1084.       {  XtRemoveGrab (menu_list[open_menu]);
  1085.      XtUnmapWidget (menu_list[open_menu]);
  1086.       }
  1087.       else
  1088.       {  for (int j=0; j<nr_menues; j++)
  1089.         XtAddGrab (menu_header[j], FALSE, FALSE);
  1090.       }
  1091.       open_menu = i;
  1092.       XtMapWidget (lw);
  1093.       XRaiseWindow (XtDisplay (lw), XtWindow (lw));
  1094.       XtAddGrab (lw, FALSE, FALSE);
  1095.    }
  1096. }
  1097.  
  1098. void install_header_menues ()
  1099. {  char name[20];
  1100.    Widget w;
  1101.  
  1102.    for (int i=0; i<nr_menues; i++)
  1103.    {  if (i==0) w = NULL;
  1104.       else w = menu_header[i-1];
  1105.  
  1106.       ac=0;
  1107.       XtSetArg (al[ac], XtNborderWidth, 0); inc_ac();
  1108.       XtSetArg (al[ac], XtNlabel, menu_header_items[i]); inc_ac();
  1109.       XtSetArg (al[ac], XtNfromHoriz, w); inc_ac();
  1110.       XtSetArg (al[ac], XtNhorizDistance, 0); inc_ac();
  1111.       XtSetArg (al[ac], XtNvertDistance, 0); inc_ac();
  1112.       XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  1113.       XtSetArg (al[ac], XtNbottom, XtChainTop); inc_ac();
  1114.       XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  1115.       XtSetArg (al[ac], XtNright, XtChainLeft); inc_ac();
  1116.  
  1117.       XtSetArg (al[ac], XtNforeground, red_pxl); inc_ac();
  1118.  
  1119.       sprintf (name, "menu_label%d", i);
  1120.       menu_header[i] = XtCreateManagedWidget
  1121.          (name, commandWidgetClass, app_form_wdgt, al, ac);
  1122.       XtAddCallback (menu_header[i], XtNcallback,
  1123.              (XtCallbackProc) menu_header_callback, (caddr_t) i);
  1124.  
  1125.       ac=0;
  1126.       XtSetArg (al[ac], XtNlist, menu_list_items[i]); inc_ac();
  1127.       XtSetArg (al[ac], XtNverticalList, TRUE); inc_ac();
  1128.       XtSetArg (al[ac], XtNforceColumns, TRUE); inc_ac();
  1129.       XtSetArg (al[ac], XtNdefaultColumns, 1); inc_ac();
  1130.       XtSetArg (al[ac], XtNmappedWhenManaged, FALSE); inc_ac();
  1131.       XtSetArg (al[ac], XtNfromHoriz, w); inc_ac();
  1132.       XtSetArg (al[ac], XtNfromVert, menu_header[i]); inc_ac();
  1133.       XtSetArg (al[ac], XtNhorizDistance, 0); inc_ac();
  1134.       XtSetArg (al[ac], XtNvertDistance, 0); inc_ac();
  1135.       XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  1136.       XtSetArg (al[ac], XtNbottom, XtChainTop); inc_ac();
  1137.       XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  1138.       XtSetArg (al[ac], XtNright, XtChainLeft); inc_ac();
  1139.  
  1140.       XtSetArg (al[ac], XtNborderWidth, 2); inc_ac();
  1141.       XtSetArg (al[ac], XtNborderColor, red_pxl); inc_ac();
  1142.       XtSetArg (al[ac], XtNforeground, green_pxl); inc_ac();
  1143.  
  1144.       sprintf (name, "menu_list%d", i);
  1145.       menu_list[i] = XtCreateManagedWidget
  1146.             (name, listWidgetClass, app_form_wdgt, al, ac);
  1147.       XtAddCallback (menu_list[i], XtNcallback,
  1148.              (XtCallbackProc) menu_list_callback, (caddr_t) i);
  1149.    }
  1150. }
  1151.  
  1152. static void install_ocmd_menu ()
  1153. {  ac=0;
  1154.    XtSetArg (al[ac], XtNlist, ocmd_menu_items); inc_ac();
  1155.    XtSetArg (al[ac], XtNverticalList, TRUE); inc_ac();
  1156.    XtSetArg (al[ac], XtNforceColumns, TRUE); inc_ac();
  1157.    XtSetArg (al[ac], XtNdefaultColumns, 1); inc_ac();
  1158.    XtSetArg (al[ac], XtNmappedWhenManaged, FALSE); inc_ac();
  1159.    XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  1160.    XtSetArg (al[ac], XtNbottom, XtChainTop); inc_ac();
  1161.    XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  1162.    XtSetArg (al[ac], XtNright, XtChainLeft); inc_ac();
  1163.    ocmd_menu = XtCreateManagedWidget
  1164.          ("ocmd", listWidgetClass, form_wdgt, al, ac);
  1165.    XtAddCallback (ocmd_menu, XtNcallback,
  1166.           (XtCallbackProc) ocmd_callback, NULL);
  1167. }
  1168.  
  1169. // **************************  Dialogues  *******************************
  1170.  
  1171. void co_cancel_callback (Widget, caddr_t, caddr_t)
  1172. {  XtRemoveGrab (co_menu_wdgts.main);
  1173.    XtUnmapWidget (co_menu_wdgts.main);
  1174. }
  1175.  
  1176. void co_do_callback (Widget, caddr_t, caddr_t)
  1177. {  XtRemoveGrab (co_menu_wdgts.main);
  1178.    XtUnmapWidget (co_menu_wdgts.main);
  1179.    int cnt, os;
  1180.    cnt = atoi (cnt_string);
  1181.    if (strlen (os_string) > 0)
  1182.       os = atoi (os_string);
  1183.    else
  1184.       os = ROOT_OFFSET;
  1185.  
  1186.    char msg [60];
  1187.    sprintf (msg, "object <%d/%d> does not exist",  cnt, os);
  1188.  
  1189.    err_block
  1190.    {  sos_Object o =
  1191.      sos_Object::make
  1192.         (sos_Typed_id::make
  1193.            (sos_Id::make (sos_Container::make (cnt), os)));
  1194.       display_object_menu (o, position::root(), current_show);
  1195.    }
  1196.    err_exception
  1197.    {  display_info(msg);
  1198.    }
  1199.    err_block_end
  1200. }
  1201.  
  1202. void display_co_menu()
  1203. {  XawTextBlock tb;
  1204.    tb.firstPos = 0;
  1205.    tb.length = 0;
  1206.    tb.ptr = 0;
  1207.    tb.format = FMT8BIT;
  1208.    XawTextReplace (co_menu_wdgts.cnt, 0, strlen (cnt_string), &tb);
  1209.    XawTextReplace (co_menu_wdgts.os, 0, strlen (os_string), &tb);
  1210.  
  1211.    XtMapWidget (co_menu_wdgts.main);
  1212.    XRaiseWindow (XtDisplay (co_menu_wdgts.main),
  1213.          XtWindow (co_menu_wdgts.main));
  1214.  
  1215.    XtAddGrab (co_menu_wdgts.main, TRUE, FALSE);
  1216. }
  1217.  
  1218. void cnt_cancel_callback (Widget, caddr_t, caddr_t)
  1219. {  XtRemoveGrab (cnt_menu_wdgts.main);
  1220.    XtUnmapWidget (cnt_menu_wdgts.main);
  1221. }
  1222.  
  1223. void cnt_do_callback (Widget, caddr_t, caddr_t)
  1224. {  XtRemoveGrab (cnt_menu_wdgts.main);
  1225.    XtUnmapWidget (cnt_menu_wdgts.main);
  1226.  
  1227.    err_block
  1228.    {  sos_Container cnt =sos_Container::make (atoi (cnt_string));
  1229.       switch (cnt_cmd)
  1230.       {  case cnt_OPEN_READ:
  1231.         cnt.open (READING, WAITING);
  1232.         break;
  1233.      case cnt_OPEN_WRITE:
  1234.         cnt.open (WRITING, WAITING);
  1235.         break;
  1236.      case cnt_COMMIT:
  1237.         cnt.commit ();
  1238.         break;
  1239.      case cnt_RESET:
  1240.         cnt.reset ();
  1241.         break;
  1242.      case cnt_CLOSE:
  1243.         cnt.close ();
  1244.         break;
  1245.      case cnt_CREATE:
  1246.         break;
  1247.      case cnt_DESTROY:
  1248.         cnt.destroy ();
  1249.         break;
  1250.      default:
  1251.         break;
  1252.       }
  1253.    }
  1254.    err_exception
  1255.    {  display_info(err_last_raised());
  1256.    }
  1257.    err_block_end
  1258. }
  1259.  
  1260. void display_cnt_menu()
  1261. {  XawTextBlock tb;
  1262.    tb.firstPos = 0;
  1263.    tb.length = 0;
  1264.    tb.ptr = 0;
  1265.    tb.format = FMT8BIT;
  1266.    XawTextReplace (cnt_menu_wdgts.cnt, 0, strlen (cnt_string), &tb);
  1267.  
  1268.    XtMapWidget (cnt_menu_wdgts.main);
  1269.    XRaiseWindow (XtDisplay (cnt_menu_wdgts.main),
  1270.          XtWindow (cnt_menu_wdgts.main));
  1271.  
  1272.    XtAddGrab (cnt_menu_wdgts.main, TRUE, FALSE);
  1273. }
  1274.  
  1275. void install_dialogues ()
  1276. {  Widget cancel_but, do_but, cnt_lab, os_lab;
  1277.  
  1278.    // ******************** co dialogue *************************
  1279.  
  1280.    ac=0;
  1281.    XtSetArg (al[ac], XtNvertDistance, 30); inc_ac();
  1282.    XtSetArg (al[ac], XtNhorizDistance, 30); inc_ac();
  1283.    XtSetArg (al[ac], XtNmappedWhenManaged, FALSE); inc_ac();
  1284.    XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  1285.    XtSetArg (al[ac], XtNbottom, XtChainTop); inc_ac();
  1286.    XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  1287.    XtSetArg (al[ac], XtNright, XtChainLeft); inc_ac();
  1288.    co_menu_wdgts.main = XtCreateManagedWidget
  1289.          ("co.main", formWidgetClass, form_wdgt, al, ac);
  1290.    XtAddEventHandler (co_menu_wdgts.main, ButtonPressMask, FALSE,
  1291.               (XtEventHandler) drag_object, NULL);
  1292.  
  1293.    ac=0;
  1294.    XtSetArg (al[ac], XtNlabel, "container"); inc_ac();
  1295.    XtSetArg (al[ac], XtNborderWidth, 0); inc_ac();
  1296.    cnt_lab = XtCreateManagedWidget
  1297.         ("co.cnt_lab", labelWidgetClass, co_menu_wdgts.main, al, ac);
  1298.  
  1299.    ac=0;
  1300.    XtSetArg (al[ac], XtNlabel, "offset"); inc_ac();
  1301.    XtSetArg (al[ac], XtNborderWidth, 0); inc_ac();
  1302.    XtSetArg (al[ac], XtNfromVert, cnt_lab); inc_ac();
  1303.    os_lab = XtCreateManagedWidget
  1304.         ("co.os_lab", labelWidgetClass, co_menu_wdgts.main, al, ac);
  1305.  
  1306.    strcpy (cnt_string, "");
  1307.    ac=0;
  1308.    XtSetArg (al[ac], XtNlength, cnt_length); inc_ac();
  1309.    XtSetArg (al[ac], XtNstring, cnt_string); inc_ac();
  1310.    XtSetArg (al[ac], XtNfromHoriz, cnt_lab); inc_ac();
  1311.    XtSetArg (al[ac], XtNeditType, XawtextEdit); inc_ac();
  1312.    co_menu_wdgts.cnt = XtCreateManagedWidget
  1313.         ("co.cnt", asciiStringWidgetClass, co_menu_wdgts.main, al, ac);
  1314.    XawTextEnableRedisplay (co_menu_wdgts.cnt);
  1315.  
  1316.    strcpy (os_string, "");
  1317.    ac=0;
  1318.    XtSetArg (al[ac], XtNlength, os_length); inc_ac();
  1319.    XtSetArg (al[ac], XtNstring, os_string); inc_ac();
  1320.    XtSetArg (al[ac], XtNfromVert, co_menu_wdgts.cnt); inc_ac();
  1321.    XtSetArg (al[ac], XtNfromHoriz, cnt_lab); inc_ac();
  1322.    XtSetArg (al[ac], XtNeditType, XawtextEdit); inc_ac();
  1323.    co_menu_wdgts.os = XtCreateManagedWidget
  1324.         ("co.os", asciiStringWidgetClass, co_menu_wdgts.main, al, ac);
  1325.    XawTextEnableRedisplay (co_menu_wdgts.cnt);
  1326.  
  1327.    ac=0;
  1328.    XtSetArg (al[ac], XtNlabel, "  do  "); inc_ac();
  1329.    XtSetArg (al[ac], XtNfromVert, co_menu_wdgts.os); inc_ac();
  1330.    do_but = XtCreateManagedWidget
  1331.         ("co.do", commandWidgetClass, co_menu_wdgts.main, al, ac);
  1332.    XtAddCallback (do_but, XtNcallback,
  1333.           (XtCallbackProc) co_do_callback, NULL);
  1334.  
  1335.    ac=0;
  1336.    XtSetArg (al[ac], XtNlabel, "cancel"); inc_ac();
  1337.    XtSetArg (al[ac], XtNfromVert, co_menu_wdgts.os); inc_ac();
  1338.    XtSetArg (al[ac], XtNfromHoriz, do_but); inc_ac();
  1339.    XtSetArg (al[ac], XtNhorizDistance, 20); inc_ac();
  1340.    cancel_but = XtCreateManagedWidget
  1341.         ("co.cancel", commandWidgetClass, co_menu_wdgts.main, al, ac);
  1342.    XtAddCallback (cancel_but, XtNcallback,
  1343.           (XtCallbackProc) co_cancel_callback, NULL);
  1344.  
  1345.    // ******************* cnt dialogue *************************
  1346.  
  1347.    ac=0;
  1348.    XtSetArg (al[ac], XtNvertDistance, 30); inc_ac();
  1349.    XtSetArg (al[ac], XtNhorizDistance, 30); inc_ac();
  1350.    XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  1351.    XtSetArg (al[ac], XtNbottom, XtChainTop); inc_ac();
  1352.    XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  1353.    XtSetArg (al[ac], XtNright, XtChainLeft); inc_ac();
  1354.    XtSetArg (al[ac], XtNmappedWhenManaged, FALSE); inc_ac();
  1355.    cnt_menu_wdgts.main = XtCreateManagedWidget
  1356.          ("cnt.main", formWidgetClass, form_wdgt, al, ac);
  1357.    XtAddEventHandler (cnt_menu_wdgts.main,
  1358.               ButtonPressMask, FALSE, (XtEventHandler) drag_object, NULL);
  1359.  
  1360.    ac=0;
  1361.    XtSetArg (al[ac], XtNlabel, "container"); inc_ac();
  1362.    XtSetArg (al[ac], XtNborderWidth, 0); inc_ac();
  1363.    cnt_lab = XtCreateManagedWidget
  1364.         ("cnt.cnt_lab", labelWidgetClass, cnt_menu_wdgts.main, al, ac);
  1365.  
  1366.    ac=0;
  1367.    XtSetArg (al[ac], XtNlength, cnt_length); inc_ac();
  1368.    XtSetArg (al[ac], XtNstring, cnt_string); inc_ac();
  1369.    XtSetArg (al[ac], XtNfromHoriz, cnt_lab); inc_ac();
  1370.    XtSetArg (al[ac], XtNeditType, XawtextEdit); inc_ac();
  1371.    cnt_menu_wdgts.cnt = XtCreateManagedWidget
  1372.         ("cnt.cnt", asciiStringWidgetClass, cnt_menu_wdgts.main, al, ac);
  1373.    XawTextEnableRedisplay (cnt_menu_wdgts.cnt);
  1374.  
  1375.    ac=0;
  1376.    XtSetArg (al[ac], XtNlabel, "  do  "); inc_ac();
  1377.    XtSetArg (al[ac], XtNfromVert, cnt_menu_wdgts.cnt); inc_ac();
  1378.    do_but = XtCreateManagedWidget
  1379.         ("cnt.do", commandWidgetClass, cnt_menu_wdgts.main, al, ac);
  1380.    XtAddCallback (do_but, XtNcallback,
  1381.           (XtCallbackProc) cnt_do_callback, NULL);
  1382.  
  1383.    ac=0;
  1384.    XtSetArg (al[ac], XtNlabel, "cancel"); inc_ac();
  1385.    XtSetArg (al[ac], XtNfromVert, cnt_menu_wdgts.cnt); inc_ac();
  1386.    XtSetArg (al[ac], XtNfromHoriz, do_but); inc_ac();
  1387.    XtSetArg (al[ac], XtNhorizDistance, 20); inc_ac();
  1388.    cancel_but = XtCreateManagedWidget
  1389.         ("cnt.cancel", commandWidgetClass, cnt_menu_wdgts.main, al, ac);
  1390.    XtAddCallback (cancel_but, XtNcallback,
  1391.           (XtCallbackProc) cnt_cancel_callback, NULL);
  1392.  
  1393. }
  1394.  
  1395. void display_root()
  1396. {  display_object_menu (root_object, position::root(), current_show);
  1397. }
  1398.  
  1399. void display_info (err_msg msg)
  1400. {  strncpy (info_string, msg, info_length);
  1401.    info_string [info_length] = 0;
  1402.    ac=0;
  1403.    XtSetArg (al[ac], XtNlabel, info_string); inc_ac();
  1404.    XtSetValues (info_line_wdgt, al, ac);
  1405. }
  1406.  
  1407. // *****************************  Main  *********************************
  1408.  
  1409. main (int argc, char *argv[])
  1410. {  Widget        app_shell;
  1411.    Widget        app_view;
  1412.  
  1413.    sos_init (argc, argv);
  1414.  
  1415.    app_shell = XtInitialize ("main", "Gsh", NULL, 0, (Cardinal*) &argc, argv);
  1416.  
  1417.    Display *disp = XtDisplay (app_shell);
  1418.    Colormap cmap = DefaultColormap (disp, 0);
  1419.    XColor color, exact;
  1420.    XAllocNamedColor (disp, cmap, "red", &color, &exact);
  1421.    red_pxl = color.pixel;
  1422.    XAllocNamedColor (disp, cmap, "forest green", &color, &exact);
  1423.    green_pxl = color.pixel;
  1424.    XAllocNamedColor (disp, cmap, "blue", &color, &exact);
  1425.    blue_pxl = color.pixel;
  1426.  
  1427.    ac=0;
  1428.    XtSetArg (al[ac], XtNdefaultDistance, 0); inc_ac();
  1429.    app_form_wdgt = XtCreateManagedWidget
  1430.            ("app_form", formWidgetClass, app_shell, al, ac);
  1431.  
  1432.    install_header_menues ();
  1433.  
  1434.    ac=0;
  1435.    XtSetArg (al[ac], XtNforceBars, TRUE); inc_ac();
  1436.    XtSetArg (al[ac], XtNallowHoriz, TRUE); inc_ac();
  1437.    XtSetArg (al[ac], XtNallowVert, TRUE); inc_ac();
  1438.    XtSetArg (al[ac], XtNuseBottom, TRUE); inc_ac();
  1439.    XtSetArg (al[ac], XtNuseRight, TRUE); inc_ac();
  1440.    XtSetArg (al[ac], XtNheight, 500); inc_ac();
  1441.    XtSetArg (al[ac], XtNwidth, 800); inc_ac();
  1442.    XtSetArg (al[ac], XtNfromVert, menu_header[0]); inc_ac();
  1443.    XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  1444.    XtSetArg (al[ac], XtNbottom, XtChainBottom); inc_ac();
  1445.    XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  1446.    XtSetArg (al[ac], XtNright, XtChainRight); inc_ac();
  1447.    app_view = XtCreateManagedWidget
  1448.            ("app_view", viewportWidgetClass, app_form_wdgt, al, ac);
  1449.  
  1450.    ac=0;
  1451.    XtSetArg (al[ac], XtNdefaultDistance, default_distance); inc_ac();
  1452.    form_wdgt = XtCreateManagedWidget
  1453.            ("form", formWidgetClass, app_view, al, ac);
  1454.  
  1455.    install_dialogues ();
  1456.    install_ocmd_menu ();
  1457.  
  1458.    strcpy (info_string, "");
  1459.    ac=0;
  1460.    XtSetArg (al[ac], XtNlabel, info_string); inc_ac();
  1461.    XtSetArg (al[ac], XtNborderWidth, 0); inc_ac();
  1462.    XtSetArg (al[ac], XtNwidth, 800); inc_ac();
  1463.    XtSetArg (al[ac], XtNjustify, XtJustifyLeft); inc_ac();
  1464.    XtSetArg (al[ac], XtNfromVert, app_view); inc_ac();
  1465.    XtSetArg (al[ac], XtNtop, XtChainTop); inc_ac();
  1466.    XtSetArg (al[ac], XtNbottom, XtChainBottom); inc_ac();
  1467.    XtSetArg (al[ac], XtNleft, XtChainLeft); inc_ac();
  1468.    XtSetArg (al[ac], XtNright, XtChainRight); inc_ac();
  1469.    info_line_wdgt = XtCreateManagedWidget
  1470.         ("info_line", labelWidgetClass, app_form_wdgt, al, ac);
  1471.  
  1472.    XtRealizeWidget (app_shell);
  1473.  
  1474.    if (argc > 3)
  1475.    {  err_raise (err_USE, err_GSH_USAGE, NULL, FALSE);
  1476.       exit (-1);
  1477.    }
  1478.    else if (argc > 1)
  1479.    {  sos_Container ct;
  1480.       sos_Offset os;
  1481.       ct = sos_Container::make (atoi (argv [1]));
  1482.       if (argc > 2)
  1483.      os = atoi (argv [2]);
  1484.       else
  1485.      os = ROOT_OFFSET;
  1486.       if (ct == 0 OR os == 0)
  1487.       {  err_raise (err_USE, err_GSH_USAGE, NULL, FALSE);
  1488.      exit (-1);
  1489.       }
  1490.       err_block
  1491.       {  root_object =
  1492.         sos_Object::make (sos_Typed_id::make (sos_Id::make (ct, os)));
  1493.       }
  1494.       err_exception
  1495.       {  err_raise (err_USE, err_GSH_INVALID_ROOT, NULL, FALSE);
  1496.      exit (-1);
  1497.       }
  1498.       err_block_end
  1499.    }
  1500.    else
  1501.       root_object = sos_Object_Directory::root();
  1502.    
  1503.    display_root();
  1504.  
  1505.    XtMainLoop ();
  1506.  
  1507.    exit (0);
  1508. }
  1509.