home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 300-399 / ff386.lzh / XLispStat / src1.lzh / IView / dialogs.c < prev    next >
C/C++ Source or Header  |  1990-10-07  |  21KB  |  782 lines
  1. /* dialogs - General Dialog Objects                                    */
  2. /* XLISP-STAT 2.1 Copyright (c) 1990, by Luke Tierney                  */
  3. /* Additions to Xlisp 2.1, Copyright (c) 1989 by David Michael Betz    */
  4. /* You may give out copies of this software; for conditions see the    */
  5. /* file COPYING included with this distribution.                       */
  6.  
  7. #include "xlisp.h"
  8. #include "osdef.h"
  9. #ifdef ANSI
  10. #include "xlproto.h"
  11. #include "xlsproto.h"
  12. #include "iviewproto.h"
  13. #include "Stproto.h"
  14. #else
  15. #include "xlfun.h"
  16. #include "xlsfun.h"
  17. #include "iviewfun.h"
  18. #include "Stfun.h"
  19. #endif ANSI
  20. #include "xlsvar.h"
  21.  
  22. /* forward declarations */
  23. #ifdef ANSI
  24. LVAL simple_dialog_method(int),make_text_item(LVAL),process_items(LVAL);
  25. Point calc_item_size(LVAL,LVAL,int,int),
  26.       calc_item_list_size(LVAL,LVAL,int,int,int);
  27. void calc_size(LVAL),calc_location(LVAL),get_initial_item_values(LVAL,int);
  28. #else
  29. LVAL simple_dialog_method(),make_text_item(),process_items();
  30. Point calc_item_size(),
  31.       calc_item_list_size();
  32. void calc_size(),calc_location(),get_initial_item_values();
  33. #endif
  34.  
  35. /* layout definitions */
  36. # define ITEM_GAP 10
  37. # define SCROLL_MIN 0
  38. # define SCROLL_MAX 100
  39. # define SCROLL_PAGE 5
  40.  
  41. # define has_item_location(i) (slot_value(i, s_location) != NIL)
  42. # define has_item_size(i) (slot_value(i, s_size) != NIL)
  43. # define check_dialog_address(d) valid_dialog_address(slot_value(d, s_hardware_address))
  44.  
  45. /***********************************************************************/
  46. /**                                                                   **/
  47. /**                          Utility Functions                        **/
  48. /**                                                                   **/
  49. /***********************************************************************/
  50.  
  51. int check_point_list(x)
  52.     LVAL x;
  53. {
  54.   return(listp(x) && llength(x) == 2 && fixp(car(x)) && fixp(car(cdr(x))));
  55. }
  56.  
  57. Point ListToPoint(list)
  58.     LVAL list;
  59. {
  60.   Point pt;
  61.   
  62.   if (! check_point_list(list)) xlerror("not a point", list);
  63.   pt.h = getfixnum(car(list));
  64.   pt.v = getfixnum(car(cdr(list)));
  65.   return(pt);
  66. }
  67.  
  68. LVAL PointToList(pt)
  69.     Point pt;
  70. {
  71.   return(integer_list_2((int) pt.h, (int) pt.v));
  72. }
  73.  
  74. /***********************************************************************/
  75. /***********************************************************************/
  76. /**                                                                   **/
  77. /**                         DIALOG-PROTO Methods                      **/
  78. /**                                                                   **/
  79. /***********************************************************************/
  80. /***********************************************************************/
  81.  
  82. /***********************************************************************/
  83. /**                                                                   **/
  84. /**                         Support Functions                         **/
  85. /**                                                                   **/
  86. /***********************************************************************/
  87.  
  88. /* Is this a dialog? */
  89. int dialog_p(x)
  90.     LVAL x;
  91. {
  92.   return (kind_of_p(x, getvalue(s_dialog_proto)));
  93. }
  94.  
  95. /* get a dialog from the stack */
  96. LVAL xsgetdialog()
  97. {
  98.   LVAL x;
  99.   x = xlgetarg();
  100.   if (! dialog_p(x)) xlerror("not a dialog", x);
  101.   return(x);
  102. }
  103.  
  104. static Point calc_item_size(dialog, item, left, top)
  105.     LVAL dialog, item;
  106.     int left, top;
  107. {
  108.   Point sz, loc;
  109.   
  110.   if (! dialog_item_p(item)) xlerror("not a dialog item", item);
  111.   if (slot_value(item, s_dialog) != NIL
  112.       && check_dialog_address(slot_value(item, s_dialog))) 
  113.     xlfail("item is already installed in a dialog");
  114.   sz = ListToPoint(slot_value(item, s_size));
  115.   if (has_item_location(item))
  116.     loc = ListToPoint(slot_value(item, s_location));
  117.   else {
  118.     loc.h = left;
  119.     loc.v = top;
  120.     set_slot_value(item, s_location, PointToList(loc));
  121.   }
  122.   sz.h += loc.h - left;
  123.   sz.v += loc.v - top;
  124.   sz.h = max((int) sz.h, 0);
  125.   sz.v = max((int) sz.v, 0);
  126.   set_slot_value(item, s_dialog, dialog);
  127.   return(sz);
  128. } 
  129.  
  130. static Point calc_item_list_size(dialog, items, left, top, as_column)
  131.     LVAL dialog, items;
  132.     int left, top, as_column;
  133. {
  134.   LVAL item;
  135.   Point sz, pt;
  136.   
  137.   for (sz.h = 0, sz.v = 0; consp(items); items = cdr(items)) {
  138.     item = car(items);
  139.     if consp(item)
  140.       pt = calc_item_list_size(dialog, item, left, top, ! as_column);
  141.     else pt = calc_item_size(dialog, item, left, top);
  142.     if (as_column) {
  143.       sz.h = max((int) sz.h, (int) pt.h);
  144.       sz.v += pt.v + ITEM_GAP;
  145.       top += pt.v + ITEM_GAP;
  146.     }
  147.     else {
  148.       sz.h += pt.h + ITEM_GAP;
  149.       left += pt.h + ITEM_GAP;
  150.       sz.v = max((int) sz.v, (int) pt.v);
  151.     }
  152.   }
  153.   if (as_column) sz.v = max((int) (sz.v - ITEM_GAP), 0);
  154.   else sz.h = max((int) (sz.h - ITEM_GAP), 0);
  155.   
  156.   return(sz);
  157. }
  158.  
  159. static void calc_size(dialog)
  160.     LVAL dialog;
  161. {
  162.   Point sz;
  163.   LVAL size = slot_value(dialog, s_size);
  164.   LVAL items = slot_value(dialog, s_items);
  165.   
  166.   sz = calc_item_list_size(dialog, items, ITEM_GAP, ITEM_GAP, TRUE);
  167.   sz.h += 2 * ITEM_GAP;
  168.   sz.v += 2 * ITEM_GAP;
  169.   if (! check_point_list(size)) {
  170.     set_slot_value(dialog, s_size, PointToList(sz));
  171.   }
  172. }
  173.  
  174. static void calc_location(dialog)
  175.     LVAL dialog;
  176. {
  177.   Point screen, size, location;
  178.   int left, top;
  179.   LVAL loc = slot_value(dialog, s_location);
  180.   
  181.   if (! check_point_list(loc)) {
  182.     StGetScreenSize(&left, &top);
  183.      screen.h = left; screen.v = top; /* needed since components may be shorts */
  184.     size = ListToPoint(slot_value(dialog, s_size));
  185.     location.h = (screen.h - size.h) / 2;
  186.     location.v = (screen.v - size.v) / 2;
  187.     set_slot_value(dialog, s_location, PointToList(location));
  188.   }
  189. }
  190.  
  191. static LVAL simple_dialog_method(which)
  192.     int which;
  193. {
  194.   LVAL dialog, result = NIL;
  195.   
  196.   dialog = xsgetdialog();
  197.   xllastarg();
  198.    
  199.   switch (which) {
  200.   case 'R': DialogRemove(dialog); break;
  201.   case 'A': calc_size(dialog);
  202.             calc_location(dialog);
  203.             DialogAllocate(dialog);
  204.             break;
  205.   case 'a': result = (check_dialog_address(dialog)) ? s_true : NIL; break;
  206.   }
  207.   return(result);
  208. }
  209. /*
  210. extern LVAL s_text_item_proto, sk_new;
  211. extern LVAL copylist();   in headers JKL */
  212.  
  213. static LVAL make_text_item(string)
  214.     LVAL string;
  215. {
  216.   LVAL result;
  217.   
  218.   result = send_message_1L(getvalue(s_text_item_proto), sk_new, string);
  219.   return(result);
  220. }
  221.  
  222. static LVAL process_items(items)
  223.     LVAL items;
  224. {
  225.   LVAL next;
  226.   
  227.   xlprot1(items);
  228.   items = copylist(items);
  229.   for (next = items; consp(next); next = cdr(next)) {
  230.     if (stringp(car(next))) rplaca(next, make_text_item(car(next)));
  231.     else if (consp(car(next))) rplaca(next, process_items(car(next)));
  232.   }
  233.   xlpop();
  234.   return(items);
  235. }
  236.   
  237. /***********************************************************************/
  238. /**                                                                   **/
  239. /**                              Methods                              **/
  240. /**                                                                   **/
  241. /***********************************************************************/
  242.  
  243. /* :ISNEW Method */
  244. LVAL xsdialog_isnew()
  245. {
  246.   LVAL dialog, items;
  247.     
  248.   dialog = xsgetdialog();
  249.   
  250.   items = xlgalist();
  251.   items = process_items(items);
  252.   set_slot_value(dialog, s_items, items);
  253.   
  254.   object_isnew(dialog);
  255.   if (! stringp(slot_value(dialog, s_title)))
  256.     set_slot_value(dialog, s_title, make_string("Dialog"));
  257.  
  258.   if (xsboolkey(sk_show, TRUE)) send_message(dialog, sk_allocate);
  259.   
  260.   return(dialog);
  261. }
  262.  
  263. LVAL xsdialog_allocate()     { return(simple_dialog_method('A')); }
  264. LVAL xsdialog_remove()       { return(simple_dialog_method('R')); }
  265. LVAL xsdialog_allocated_p()  { return(simple_dialog_method('a')); }
  266.  
  267. LVAL xsdialog_default_button()
  268. {
  269.   LVAL dialog,  item;
  270.  
  271.   dialog = xsgetdialog();
  272.   item = xlgetarg();
  273.   xllastarg();
  274.  
  275.   DialogSetDefaultButton(dialog, item);
  276.   
  277.   return (item); 
  278. }
  279.  
  280. /* :MODAL-DIALOG method */
  281. LVAL xsdialog_modal()
  282. {
  283.   LVAL dialog;
  284.     
  285.   dialog = xsgetdialog();
  286.   xllastarg();
  287.   
  288.   return(DialogGetModalItem(dialog));
  289. }
  290.  
  291. /***********************************************************************/
  292. /***********************************************************************/
  293. /**                                                                   **/
  294. /**                      DIALOG-ITEM-PROTO Methods                    **/
  295. /**                                                                   **/
  296. /***********************************************************************/
  297. /***********************************************************************/
  298.  
  299. /* Is this a dialog-item? */
  300. int dialog_item_p(x)
  301.     LVAL x;
  302. {
  303.   return (kind_of_p(x, getvalue(s_dialog_item_proto)));
  304. }
  305.  
  306. /* get a dialog item from the stack */
  307. LVAL xsgetdialogitem()
  308. {
  309.   LVAL x;
  310.   x = xlgetarg();
  311.   if (! dialog_item_p(x)) xlerror("not a dialog item", x);
  312.   return(x);
  313. }
  314.  
  315. static void get_initial_item_values(item, get_first)
  316.     LVAL item;
  317.     int get_first;
  318. {
  319.   LVAL text;
  320.   
  321.   if (get_first) {
  322.     text = xlgastring();
  323.     set_slot_value(item, s_text, text);
  324.   }
  325.   object_isnew(item);
  326. }
  327.  
  328. /* :DO-ACTION Method */
  329. LVAL xsdialog_item_do_action()
  330. { 
  331.   LVAL item, action/*, result rewritten below JKL */;
  332.   item = xsgetdialogitem();
  333.   xllastarg();
  334.   
  335.   action = slot_value(item, s_action);
  336. /*  result = (action != NIL) ? xlapply(pushargs(action, NIL)) : NIL;*/
  337.   return(/*result*/(action != NIL) ? xlapply(pushargs(action, NIL)) : NIL);
  338. }
  339.  
  340. /* :ACTION Method */
  341. LVAL xsdialog_item_action()
  342. {
  343.   LVAL item, action;
  344.   int set;
  345.   
  346.   item = xsgetdialogitem();
  347.   set = moreargs();
  348.   if (set) action = xlgetarg();
  349.   xllastarg();
  350.   
  351.   if (set) set_slot_value(item, s_action, action);
  352.   return(slot_value(item, s_action));
  353. }
  354.  
  355. /***********************************************************************/
  356. /***********************************************************************/
  357. /**                                                                   **/
  358. /**                      BUTTON-ITEM-PROTO Methods                    **/
  359. /**                                                                   **/
  360. /***********************************************************************/
  361. /***********************************************************************/
  362.  
  363. /* Is this a button-item? */
  364. int button_item_p(x)
  365.     LVAL x;
  366. {
  367.   return (kind_of_p(x, getvalue(s_button_item_proto)));
  368. }
  369.  
  370. /* get a button item from the stack */
  371. LVAL xsgetbuttonitem()
  372. {
  373.   LVAL x;
  374.   x = xlgetarg();
  375.   if (! button_item_p(x)) xlerror("not a button item", x);
  376.   return(x);
  377. }
  378.  
  379. /* :ISNEW Method */
  380. LVAL xsbutton_item_isnew()
  381. {
  382.   LVAL item;
  383.   int width, height;
  384.   
  385.   item = xsgetbuttonitem();
  386.   
  387.   get_initial_item_values(item, TRUE);
  388.     
  389.   if (! has_item_size(item)) {
  390.     DialogButtonGetDefaultSize(item, &width, &height);
  391.     set_slot_value(item, s_size, integer_list_2(width, height));
  392.   }
  393.   
  394.   return(item);
  395. }
  396.  
  397. /***********************************************************************/
  398. /***********************************************************************/
  399. /**                                                                   **/
  400. /**                      TOGGLE-ITEM-PROTO Methods                    **/
  401. /**                                                                   **/
  402. /***********************************************************************/
  403. /***********************************************************************/
  404.  
  405. /* Is this a toggle-item? */
  406. int toggle_item_p(x)
  407.     LVAL x;
  408. {
  409.   return (kind_of_p(x, getvalue(s_toggle_item_proto)));
  410. }
  411.  
  412. /* get a toggle item from the stack */
  413. LVAL xsgettoggleitem()
  414. {
  415.   LVAL x;
  416.   x = xlgetarg();
  417.   if (! toggle_item_p(x)) xlerror("not a toggle item", x);
  418.   return(x);
  419. }
  420.  
  421. /* :ISNEW Method */
  422. LVAL xstoggle_item_isnew()
  423. {
  424.   LVAL item;
  425.   int width, height;
  426.   
  427.   item = xsgettoggleitem();
  428.   
  429.   get_initial_item_values(item, TRUE);
  430.     
  431.   if (! has_item_size(item)) {
  432.     DialogToggleGetDefaultSize(item, &width, &height);
  433.     set_slot_value(item, s_size, integer_list_2(width, height));
  434.   }
  435.   
  436.   return(item);
  437. }
  438.  
  439. /* :VALUE Method */
  440. LVAL xstoggle_item_value()
  441. {
  442.   LVAL item, value;
  443.   int set;
  444.    
  445.   item = xsgettoggleitem();
  446.   set = moreargs();
  447.   if (set) value = xlgetarg();
  448.   xllastarg();
  449.   
  450.   return(DialogToggleItemValue(item, set, value));
  451. }
  452.  
  453. /***********************************************************************/
  454. /***********************************************************************/
  455. /**                                                                   **/
  456. /**                       TEXT-ITEM-PROTO Methods                     **/
  457. /**                                                                   **/
  458. /***********************************************************************/
  459. /***********************************************************************/
  460.  
  461. /* Is this a text-item? */
  462. int text_item_p(x)
  463.     LVAL x;
  464. {
  465.   return (kind_of_p(x, getvalue(s_text_item_proto)));
  466. }
  467.  
  468. /* get a text item from the stack */
  469. LVAL xsgettextitem()
  470. {
  471.   LVAL x;
  472.   x = xlgetarg();
  473.   if (! text_item_p(x)) xlerror("not a text item", x);
  474.   return(x);
  475. }
  476.  
  477. /* :ISNEW Method */
  478. LVAL xstext_item_isnew()
  479. {
  480.   LVAL item, edit;
  481.   int width, height;
  482.   
  483.   item = xsgettextitem();
  484.  
  485.   get_initial_item_values(item, TRUE);
  486.     
  487.   if (xlgetkeyarg(sk_editable, &edit) && edit != NIL)
  488.     set_slot_value(item, s_editable, s_true);
  489.     
  490.   if (! has_item_size(item)) {
  491.     DialogTextGetDefaultSize(item, &width, &height);
  492.     set_slot_value(item, s_size, integer_list_2(width, height));
  493.   }
  494.   
  495.   return(item);
  496. }
  497.  
  498. /* :TEXT Method */
  499. LVAL xstext_item_text()
  500. {
  501.   LVAL item;
  502.   int set;
  503.   char *text;
  504.   
  505.   item = xsgettextitem();
  506.   set = moreargs();
  507.   if (set) text = (char *) getstring(xlgastring());
  508.   xllastarg();
  509.   
  510.   return(DialogTextItemText(item, set, text));
  511. }
  512.  
  513. /***********************************************************************/
  514. /***********************************************************************/
  515. /**                                                                   **/
  516. /**                      CHOICE-ITEM-PROTO Methods                    **/
  517. /**                                                                   **/
  518. /***********************************************************************/
  519. /***********************************************************************/
  520.  
  521. /* Is this a choice-item? */
  522. int choice_item_p(x)
  523.     LVAL x;
  524. {
  525.   return (kind_of_p(x, getvalue(s_choice_item_proto)));
  526. }
  527.  
  528. /* get a choice item from the stack */
  529. LVAL xsgetchoiceitem()
  530. {
  531.   LVAL x;
  532.   x = xlgetarg();
  533.   if (! choice_item_p(x)) xlerror("not a choice item", x);
  534.   return(x);
  535. }
  536.  
  537. /* :ISNEW Method */
  538. LVAL xschoice_item_isnew()
  539. {
  540.   LVAL item, text, next;
  541.   int width, height;
  542.   
  543.   item = xsgetchoiceitem();
  544.   text = xlgalist();
  545.   for (next = text; consp(next); next = cdr(next))
  546.     if (! stringp(car(next))) xlerror("not a string", car(next));
  547.   set_slot_value(item, s_text, text);
  548.   
  549.   get_initial_item_values(item, FALSE);
  550.     
  551.   if (! has_item_size(item)) {
  552.     DialogChoiceGetDefaultSize(item, &width, &height);
  553.     set_slot_value(item, s_size, integer_list_2(width, height));
  554.   }
  555.   if (! fixp(slot_value(item, s_value)))
  556.     set_slot_value(item, s_value, cvfixnum((FIXTYPE) 0));
  557.   return(item);
  558. }
  559.  
  560. /* :VALUE Method */
  561. LVAL xschoice_item_value()
  562. {
  563.   LVAL item;
  564.   int value, set;
  565.   
  566.   item = xsgetchoiceitem();
  567.   set = moreargs();
  568.   if (set) value = getfixnum(xlgafixnum());
  569.   xllastarg();
  570.   
  571.   return(DialogChoiceItemValue(item, set, value));
  572. }
  573.  
  574. /***********************************************************************/
  575. /***********************************************************************/
  576. /**                                                                   **/
  577. /**                      SCROLL-ITEM-PROTO Methods                    **/
  578. /**                                                                   **/
  579. /***********************************************************************/
  580. /***********************************************************************/
  581.  
  582. /* Is this a scroll-item? */
  583. int scroll_item_p(x)
  584.     LVAL x;
  585. {
  586.   return (kind_of_p(x, getvalue(s_scroll_item_proto)));
  587. }
  588.  
  589. /* get a scroll item from the stack */
  590. LVAL xsgetscrollitem()
  591. {
  592.   LVAL x;
  593.   x = xlgetarg();
  594.   if (! scroll_item_p(x)) xlerror("not a scroll item", x);
  595.   return(x);
  596. }
  597.  
  598. /* :ISNEW Method */
  599. LVAL xsscroll_item_isnew()
  600. {
  601.   LVAL item, low, high, page;
  602.   int width, height;
  603.   
  604.   item = xsgetscrollitem();
  605.   
  606.   get_initial_item_values(item, FALSE);
  607.   
  608.   if (! xlgetkeyarg(sk_min_value, &low) || ! fixp(low))
  609.     low = cvfixnum((FIXTYPE) SCROLL_MIN);
  610.   set_slot_value(item, s_min_value, low);
  611.   if (! fixp(slot_value(item, s_value)))
  612.     set_slot_value(item, s_value, low);
  613.   if (! xlgetkeyarg(sk_max_value, &high) || ! fixp(high))
  614.     high = cvfixnum((FIXTYPE) SCROLL_MAX);
  615.   set_slot_value(item, s_max_value, high);
  616.   if (! xlgetkeyarg(sk_page_increment, &page) || ! fixp(page))
  617.     page = cvfixnum((FIXTYPE) SCROLL_PAGE);
  618.   set_slot_value(item, s_page_increment, page);
  619.     
  620.   if (! has_item_size(item)) {
  621.     DialogScrollGetDefaultSize(item, &width, &height);
  622.     set_slot_value(item, s_size, integer_list_2(width, height));
  623.   }
  624.   
  625.   return(item);
  626. }
  627.  
  628. /* :VALUE Method */
  629. LVAL xsscroll_item_value()
  630. {
  631.   LVAL item;
  632.   int set, value;
  633.   
  634.   item = xsgetscrollitem();
  635.   set = moreargs();
  636.   if (set) value = getfixnum(xlgafixnum());
  637.   xllastarg();
  638.   
  639.   return(DialogScrollItemValue(item, set, value));
  640. }
  641.  
  642. /* :MAX Method */
  643. LVAL xsscroll_item_max()
  644. {
  645.   LVAL item;
  646.   int set, value;
  647.   
  648.   item = xsgetscrollitem();
  649.   set = moreargs();
  650.   if (set) value = getfixnum(xlgafixnum());
  651.   xllastarg();
  652.   
  653.   return(DialogScrollItemMax(item, set, value));
  654. }
  655.  
  656. /* :MIN Method */
  657. LVAL xsscroll_item_min()
  658. {
  659.   LVAL item;
  660.   int set, value;
  661.   
  662.   item = xsgetscrollitem();
  663.   set = moreargs();
  664.   if (set) value = getfixnum(xlgafixnum());
  665.   xllastarg();
  666.   
  667.   return(DialogScrollItemMin(item, set, value));
  668. }
  669.  
  670. /* :SCROLL-ACTION Method */
  671. LVAL xsscroll_item_action()
  672. { 
  673.   LVAL item, action/*, result rewritten JKL*/;
  674.   
  675.   item = xsgetdialogitem();
  676.   xllastarg();
  677.   
  678.   action = slot_value(item, s_action);
  679. /*  result = (action != NIL) ? xlapply(pushargs(action, NIL)) : NIL;*/
  680.   return(/*result*/(action != NIL) ? xlapply(pushargs(action, NIL)) : NIL);
  681. }
  682.  
  683. /***********************************************************************/
  684. /***********************************************************************/
  685. /**                                                                   **/
  686. /**                       LIST-ITEM-PROTO Methods                     **/
  687. /**                                                                   **/
  688. /***********************************************************************/
  689. /***********************************************************************/
  690.  
  691. /* Is this a list-item? */
  692. int list_item_p(x)
  693.     LVAL x;
  694. {
  695.   return (kind_of_p(x, getvalue(s_list_item_proto)));
  696. }
  697.  
  698. /* get a list item from the stack */
  699. LVAL xsgetlistitem()
  700. {
  701.   LVAL x;
  702.   x = xlgetarg();
  703.   if (! list_item_p(x)) xlerror("not a list item", x);
  704.   return(x);
  705. }
  706.  
  707. /* :ISNEW Method */
  708. LVAL xslist_item_isnew()
  709. {
  710.   LVAL item, data, columns;
  711.   int width, height;
  712.   
  713.   item = xsgetlistitem();
  714.   data = xlgetarg();
  715.   
  716.   if (listp(data)) data = coerce_to_vector(data);
  717.   else data = copyarray(data);
  718.   set_slot_value(item, s_list_data, data);
  719.   
  720.   get_initial_item_values(item, FALSE);
  721.   
  722.   if (! xlgetkeyarg(sk_columns, &columns) || ! fixp(columns)
  723.       || getfixnum(columns) < 1) columns = cvfixnum((FIXTYPE) 1);
  724.   set_slot_value(item, s_columns, columns);
  725.   
  726.   if (! has_item_size(item)) {
  727.     DialogListGetDefaultSize(item, &width, &height);
  728.     set_slot_value(item, s_size, integer_list_2(width, height));
  729.   }
  730.   
  731.   return(item);
  732. }
  733.  
  734. /* :DO-ACTION Method */
  735. LVAL xslist_item_action()
  736. { 
  737.   LVAL item, action, double_click/*, result rewritten JKL*/;
  738.   item = xsgetlistitem();
  739.   double_click = (moreargs() && xlgetarg() != NIL) ? s_true : NIL;
  740.   xllastarg();
  741.   
  742.   action = slot_value(item, s_action);
  743. /*  result = (action != NIL) ? xsfuncall1(action, double_click) : NIL;*/
  744.   return(/*result*/(action != NIL) ? xsfuncall1(action, double_click) : NIL);
  745. }
  746.  
  747. /* :SET-TEXT Method */
  748. LVAL xslist_item_text()
  749. {
  750.   LVAL item, data, index, value;
  751.   char *text;
  752.     
  753.   item = xsgetlistitem();
  754.   index = xlgetarg();
  755.   value = xlgastring();
  756.   text = (char *) getstring(value);
  757.   xllastarg();
  758.  
  759.   data = slot_value(item, s_list_data);
  760.   if (simplevectorp(data))
  761.     setelement(data, rowmajorindex(data, consa(index), FALSE), value);
  762.   else if (arrayp(data))
  763.     setelement(arraydata(data), rowmajorindex(data, index, FALSE), value);
  764.   else xlerror("not an array", data);
  765.   DialogListItemSetText(item, index, text);
  766.   return(NIL);
  767. }
  768.  
  769. /* :SELECTION Method */
  770. LVAL xslist_item_selection()
  771. {
  772.   LVAL item, index;
  773.   int set;
  774.   
  775.   item = xsgetlistitem();
  776.   set = moreargs();
  777.   if (set) index = xlgetarg();
  778.   xllastarg();
  779.   
  780.   return(DialogListItemSelection(item, set, index));
  781. }
  782.