home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume4 / xgen / part03 / spreadsheet.c < prev   
C/C++ Source or Header  |  1989-06-29  |  21KB  |  879 lines
  1. #define MAX_NUM_ARGS 20
  2. #define MAX_NUMBER_COLUMNS 10
  3. #define SIZE_OF_INPUT_STRING 50
  4. #define SIZE_OF_SCROLL_STRING 1000
  5. #define MAX_NUM_SPREADSHEETS 20
  6. #include <stdio.h>
  7. #include <X11/IntrinsicP.h>
  8. #include <X11/Intrinsic.h>
  9. #include <X11/CompositeP.h>
  10. #include <X11/CommandP.h>
  11. #include <X11/LabelP.h>
  12. #include <X11/StringDefs.h>
  13. #include <X11/Shell.h>
  14. #include <X11/Form.h>
  15. #include <X11/Core.h>
  16. #include <X11/Viewport.h>
  17. #include <X11/VPaned.h>
  18. #include <X11/Text.h>
  19. #include <X11/AsciiText.h>
  20. #include <X11/AsciiTextP.h>
  21.  
  22. #include "application.h"
  23.  
  24. void nothing()
  25. {
  26.     return;
  27. }
  28.  
  29. extern Widget top_level;
  30.  
  31. static char space_string[] = "                            ";
  32. extern  XtTranslations input_text_translations;
  33. static XtTranslations  scroll_text_translations;
  34. static XtTranslations  spread_input_translations;
  35.  
  36.  
  37. struct _spreadsheet {
  38.     Widget input_text;
  39.     Widget scroll_text;
  40.     int scrolltext_width;         /* number of characters */
  41.     int column_width[MAX_NUMBER_COLUMNS];
  42.     int number_of_columns;
  43.     char input_string[SIZE_OF_INPUT_STRING];
  44.     char scroll_string[SIZE_OF_SCROLL_STRING];
  45.     long cursor_position;
  46.     int pres_column;
  47.     int total_width;
  48. };
  49.  
  50. struct _spreadsheet_info {
  51.     Widget widget_ptr;
  52.     struct _spreadsheet *spreadsheet;
  53. };
  54.  
  55. static struct _spreadsheet_info 
  56. spreadsheet_info[MAX_NUM_SPREADSHEETS];
  57. void check_length();
  58.  
  59. void bell()
  60. {
  61.     XBell( XtDisplay(top_level), 50 );
  62. }
  63.  
  64. XtTranslations parse_spreadsheet_transl()
  65. {
  66.  
  67.     void copy_to_scroll();
  68.     void update_cursor_position();
  69.  
  70.     static XtActionsRec actionlist[] =
  71.     {
  72.         {"Nothing", nothing},
  73.         {"Bell", bell},
  74.         {"Copy_To_Scroll", copy_to_scroll},
  75.         {"Update_Cursor_Position", update_cursor_position}
  76.     };    
  77.  
  78.  
  79.     static char Input_Text_Translations[] =
  80.     "Ctrl<Key>N:           Bell() \n\
  81.      <Key>0xff54:           Bell() \n\
  82.      Ctrl<Key>P:            Bell() \n\
  83.      <Key>0xff52:           Bell() \n\
  84.      Ctrl<Key>V:            Bell() \n\
  85.      Meta<Key>V:            Bell() \n\
  86.      Ctrl<Key>Z:            Bell() \n\
  87.      Meta<Key>Z:            Bell() \n\
  88.      Ctrl<Key>J:            Bell() \n\
  89.      <Key>0xff0a:           Bell() \n\
  90.      Ctrl<Key>O:            Bell() \n\
  91.      Ctrl<Key>M:            Bell() \n\
  92.      Ctrl<Key>L:            Bell() \n\
  93.      Meta<Key>I:            Bell()  \n\
  94.      <Key>0xff0d:           Bell() \n\
  95.      Shift<Btn1Up>:              Help()";
  96.  
  97.     static char Spread_Input_Translations[] =
  98.     "<Key>0xff0d:               Copy_To_Scroll()";
  99.  
  100.     static char Scroll_Text_Translations[] =
  101.     "Ctrl<Key>N:               Update_Cursor_Position(3)\n\
  102.       Ctrl<Key>P:               Update_Cursor_Position(4)\n\
  103.       Ctrl<Key>F:               Update_Cursor_Position(1)\n\
  104.       Ctrl<Key>B:               Update_Cursor_Position(2)\n\
  105.       Button1<PtrMoved>:        extend-adjust() \n\
  106.       Button3<PtrMoved>:        extend-adjust() \n\
  107.       <BtnDown>:                Nothing()\n\
  108.       <Key>:                    Nothing()\n\
  109.       Shift<Key>:               Nothing()";
  110.  
  111.  
  112.     input_text_translations = XtParseTranslationTable(
  113.         Input_Text_Translations );
  114.  
  115.     scroll_text_translations = XtParseTranslationTable(
  116.         Scroll_Text_Translations );
  117.  
  118.     spread_input_translations = XtParseTranslationTable(
  119.         Spread_Input_Translations );
  120.  
  121.     XtAddActions( actionlist, 4);
  122.  
  123.     return( input_text_translations);
  124. }
  125.  
  126. Widget  create_spreadsheet( resources , outer_form,
  127. prev_widget, pres_cmd_arg )
  128. struct resource *resources;
  129. Widget outer_form;
  130. Widget prev_widget;
  131. struct _rec_cmd_line_arg **pres_cmd_arg;
  132. {
  133.  
  134.     Widget label,
  135.         label2,
  136.         form,
  137.         form2,
  138.         vpane;
  139.  
  140.     struct resource *pres_resource;
  141.  
  142.     Arg label_args[MAX_NUM_ARGS];
  143.     Arg label2_args[MAX_NUM_ARGS];
  144.     Arg scroll_args[MAX_NUM_ARGS];
  145.     Arg vpane_args[MAX_NUM_ARGS];
  146.     Arg form_args[MAX_NUM_ARGS];
  147.     Arg text_args[MAX_NUM_ARGS];
  148.     Arg args[MAX_NUM_ARGS];
  149.     XFontStruct *font;
  150.     char string[STR_LEN];
  151.     char *temp, *label_ptr, *number;
  152.     char *column_label;
  153.     char scrollspace_label[STR_LEN];
  154.     int label_length,
  155.     number_length,
  156.     leading_spaces,
  157.     trailing_spaces;
  158.     int num_label_args = 0,
  159.     num_label2_args = 0,
  160.     num_vpane_args = 0,
  161.     num_scroll_args = 0,
  162.     num_form_args = 0,
  163.     num_text_args = 0,
  164.     num_args = 0;
  165.     int max_column_width = 0;
  166.     int column,
  167.     pixel;
  168.  
  169.     char *help_msg = NULL;
  170.  
  171.     struct _spreadsheet *spreadsheet;
  172.  
  173.     struct _grouped_arg *pres_grouped_arg,
  174.     *prev_grouped_arg;
  175.  
  176.     *pres_cmd_arg = (struct _rec_cmd_line_arg *)(
  177.         malloc(sizeof(struct _rec_cmd_line_arg)));
  178.  
  179.     spreadsheet = (struct _spreadsheet *)malloc( sizeof( struct _spreadsheet ));
  180.  
  181.     *(spreadsheet->scroll_string) = '\0';
  182.     *(spreadsheet->input_string) = '\0';
  183.  
  184.     spreadsheet->scrolltext_width = 0;
  185.  
  186.     pres_resource = resources;
  187.  
  188.  
  189.     while( pres_resource != NULL )
  190.     {
  191.         if( !strcmp( pres_resource->name, "labelbackground") )
  192.         {
  193.             pixel = get_pixel( pres_resource->value );
  194.             XtSetArg( label_args[num_label_args], XtNbackground,
  195.                 pixel );   
  196.             num_label_args++;
  197.             XtSetArg( form_args[num_form_args], XtNbackground,
  198.                 pixel ); 
  199.             num_form_args++;
  200.             goto next;
  201.         }
  202.  
  203.  
  204.         if( !strcmp( pres_resource->name, "labelforeground") )
  205.         {
  206.             pixel = get_pixel( pres_resource->value );
  207.             XtSetArg( label_args[num_label_args], XtNforeground,
  208.                 pixel );  
  209.             num_label_args++;
  210.             goto next;
  211.         }
  212.  
  213.         if( !strcmp( pres_resource->name, "labelfont" ) )
  214.         {
  215.             font = XLoadQueryFont( XtDisplay(top_level), 
  216.                 pres_resource->value );
  217.             XtSetArg( label_args[num_label_args], XtNfont,
  218.                 font);  
  219.             num_label_args++;
  220.             goto next;
  221.         }
  222.  
  223.         if( !strcmp( pres_resource->name, "label" ))
  224.         {
  225.             XtSetArg( label_args[num_label_args], XtNlabel,
  226.                 pres_resource->value );  
  227.             num_label_args++;
  228.             goto next;
  229.         }
  230.  
  231.  
  232.         if( !strcmp(pres_resource->name, "textbackground") )
  233.         {
  234.             pixel = get_pixel( pres_resource->value );
  235.             XtSetArg( text_args[num_text_args], XtNbackground,
  236.                 pixel);  
  237.             num_text_args++;
  238.             goto next;
  239.         }
  240.  
  241.         if( !strcmp(pres_resource->name, "textfont") )
  242.         {
  243.             font = XLoadQueryFont( XtDisplay(top_level),
  244.                 pres_resource->value );
  245.             XtSetArg( text_args[num_text_args], XtNfont,
  246.                 font); 
  247.             num_text_args++;
  248.             goto next;
  249.         }
  250.  
  251.         if( !strcmp( pres_resource->name, "textforeground") )
  252.         {
  253.             pixel = get_pixel( pres_resource->value );
  254.             XtSetArg( text_args[num_text_args], XtNforeground,
  255.                 pixel );  
  256.             num_text_args++;
  257.             goto next;
  258.         }
  259.  
  260.         if( !strcmp(pres_resource->name, "titlebackground") )
  261.         {
  262.             pixel = get_pixel( pres_resource->value );
  263.             XtSetArg( label2_args[num_label2_args], XtNbackground,
  264.                 pixel);  
  265.             num_label2_args++;
  266.             goto next;
  267.         }
  268.  
  269.         /*        if( !strcmp(pres_resource->name, "titlefont") )
  270.           {
  271.             font = XLoadQueryFont( XtDisplay(top_level),
  272.                                   pres_resource->value );
  273.             XtSetArg( label2_args[num_label2_args], XtNfont,
  274.                      font); num_label2_args++;
  275.             goto next;
  276.           }*/
  277.  
  278.         if( !strcmp( pres_resource->name, "titleforeground") )
  279.         {
  280.             pixel = get_pixel( pres_resource->value );
  281.             XtSetArg( label2_args[num_label2_args], XtNforeground,
  282.                 pixel );  
  283.             num_label2_args++;
  284.             goto next;
  285.         }
  286.  
  287.  
  288.         if( !strcmp( pres_resource->name, "scrollheight") )
  289.         {
  290.             XtSetArg( scroll_args[num_scroll_args], XtNheight,
  291.                 atoi(pres_resource->value) );
  292.             num_scroll_args++;
  293.             goto next;
  294.         }
  295.  
  296.         if( !strcmp( pres_resource->name, "scrollbackground" ))
  297.         {
  298.             pixel = get_pixel( pres_resource->value );
  299.             XtSetArg( scroll_args[num_scroll_args], XtNbackground,
  300.                 pixel );  
  301.             num_scroll_args++;
  302.             goto next;
  303.         }
  304.  
  305.         if( !strcmp( pres_resource->name, "scrollforeground" ))
  306.         {
  307.             pixel = get_pixel( pres_resource->value );
  308.             XtSetArg( scroll_args[num_scroll_args], XtNforeground,
  309.                 pixel );   
  310.             num_scroll_args++;
  311.             goto next;
  312.         }
  313.  
  314.         if( !strcmp( pres_resource->name, "scrollfont" ))
  315.         {
  316.             font = XLoadQueryFont( XtDisplay( top_level),
  317.                 pres_resource->value );
  318.             XtSetArg( scroll_args[num_scroll_args], XtNfont,
  319.                 font);  
  320.             num_scroll_args++;
  321.             XtSetArg( label2_args[num_label2_args], XtNfont,
  322.                 font); 
  323.             num_label2_args++;
  324.             goto next;
  325.         }
  326.  
  327.  
  328.         if( !strcmp( pres_resource->name, "borderwidth" ))
  329.         {
  330.             XtSetArg( vpane_args[num_vpane_args], XtNborderWidth,
  331.                 atoi( pres_resource->value )); 
  332.             num_vpane_args++;
  333.             goto next;
  334.         }
  335.  
  336.         if( !strcmp( pres_resource->name, "bordercolor") )
  337.         {
  338.             pixel = get_pixel( pres_resource->value );
  339.             XtSetArg( vpane_args[num_vpane_args], XtNborderColor,
  340.                 pixel) ; 
  341.             num_vpane_args++;
  342.             goto next;
  343.         }
  344.  
  345.         if( !strcmp( pres_resource->name, "columns"))
  346.         {
  347.             column_label = scrollspace_label;
  348.             strcpy( column_label, "  " );
  349.             column_label += 2;
  350.  
  351.             column = 0;
  352.             temp = pres_resource->value;
  353.  
  354.             pres_grouped_arg =
  355.                 (struct _grouped_arg *)malloc(
  356.                 sizeof( struct _grouped_arg));
  357.  
  358.             (*pres_cmd_arg)->grouped_arg = 
  359.                 pres_grouped_arg;
  360.  
  361.             while( *temp  != '\0')
  362.             {
  363.                 pres_grouped_arg =
  364.                     (struct _grouped_arg *)malloc(
  365.                     sizeof( struct _grouped_arg));
  366.  
  367.                 if( column == 0)
  368.                     (*pres_cmd_arg)->grouped_arg =
  369.                         pres_grouped_arg;
  370.  
  371.                 else
  372.                     prev_grouped_arg->next = 
  373.                         pres_grouped_arg;
  374.  
  375.                 /* skip leading spaces */
  376.                 while ( *temp  == ' ')
  377.                     temp++;
  378.  
  379.                 label_ptr = temp;
  380.  
  381.                 /* find length of label */
  382.                 while( *temp  != ':' &&
  383.                     *temp  != ' ')
  384.                     temp++;
  385.  
  386.                 label_length = temp-label_ptr;
  387.  
  388.                 strncpy( string, label_ptr, label_length);
  389.                 *(string + label_length ) = '\0';
  390.  
  391.                 (pres_grouped_arg)->name_quark = XrmStringToQuark(string) ;
  392.  
  393.                 /* skip trailing spaces  */
  394.                 while( *temp  == ' ' )
  395.                     temp++;
  396.  
  397.                 /* check for syntax error
  398.                 if( *temp != ':' ); /* error */
  399.  
  400.                 temp++;
  401.  
  402.                 /* skip leading spaces */
  403.                 while( *temp == ' ' )
  404.                     temp++;
  405.  
  406.                 number = temp;
  407.  
  408.                 while( *temp != ' ' &&
  409.                     *temp != '\0' )
  410.                     temp++;
  411.  
  412.                 while( *temp == ' ' )
  413.                     temp++;
  414.  
  415.  
  416.                 number_length = temp - number;
  417.  
  418.                 strncpy( string, number, number_length );
  419.  
  420.                 spreadsheet->column_width[column] = atoi( string );
  421.                 if( max_column_width < 
  422.                     spreadsheet->column_width[column])
  423.                     max_column_width = spreadsheet->
  424.                         column_width[column];
  425.                 if( column == 0)
  426.                     pres_grouped_arg->value = 
  427.                         spreadsheet->scroll_string;
  428.                 else
  429.                     pres_grouped_arg->value =
  430.                         prev_grouped_arg->value + 
  431.                         spreadsheet->column_width[column-1] + 2;
  432.  
  433.                 spreadsheet->scrolltext_width += spreadsheet->column_width[column];
  434.  
  435.                 if( ((long)label_length) > spreadsheet->column_width[column])
  436.                     label_length = spreadsheet->column_width[column];
  437.  
  438.                 leading_spaces = spreadsheet->column_width[column]/2 -
  439.                     label_length/2;
  440.  
  441.                 strncpy( column_label, space_string,
  442.                     leading_spaces);
  443.  
  444.                 column_label += leading_spaces;
  445.  
  446.  
  447.  
  448.  
  449.  
  450.                 strncpy( column_label, label_ptr, label_length );
  451.  
  452.                 *(column_label + label_length + 1) = '\0';
  453.  
  454.  
  455.                 trailing_spaces = spreadsheet->column_width[column] -
  456.                     leading_spaces - label_length + 2;
  457.  
  458.                 spreadsheet->scrolltext_width += 2 ;
  459.  
  460.                 column_label += label_length;
  461.  
  462.                 strncpy( column_label,
  463.                     space_string, trailing_spaces );
  464.  
  465.                 column_label += trailing_spaces;
  466.  
  467.                 column++;
  468.  
  469.                 prev_grouped_arg = pres_grouped_arg;
  470.             }
  471.  
  472.             pres_grouped_arg->next = NULL;
  473.  
  474.             *(column_label ) = '\0';
  475.  
  476.             spreadsheet->number_of_columns = column;
  477.             (*pres_cmd_arg)->num_columns = column;
  478.  
  479.             (*pres_cmd_arg)->scrolltext_width = spreadsheet->
  480.                 scrolltext_width;
  481.  
  482.             XtSetArg(label2_args[num_label2_args],
  483.                 XtNlabel, scrollspace_label );
  484.             num_label2_args++;
  485.  
  486.             if (font == NULL )
  487.             {
  488.                 fprintf( stderr, "In shell %s scrolltext %s:%s. No such font. Using internal default\n");
  489.                 font = XLoadQueryFont( XtDisplay(top_level),
  490.                     "fixed" );
  491.             }
  492.  
  493.             XtSetArg(scroll_args[num_scroll_args],
  494.                 XtNwidth,
  495.                 XTextWidth(font,scrollspace_label,
  496.                 strlen( scrollspace_label )) );
  497.             num_scroll_args++;
  498.  
  499.  
  500.             goto next;
  501.         }
  502.  
  503.         if( !strcmp( pres_resource->name, "horizdistance"))
  504.         {
  505.             XtSetArg(vpane_args[num_vpane_args], 
  506.                 XtNhorizDistance,  
  507.                 atoi(pres_resource->value)); 
  508.             num_vpane_args++;
  509.             goto next;
  510.         }
  511.  
  512.         if( !strcmp( pres_resource->name, "vertdistance"))
  513.         {
  514.             XtSetArg(vpane_args[num_vpane_args], 
  515.                 XtNvertDistance,
  516.                 atoi(pres_resource->value)); 
  517.             num_vpane_args++;
  518.             goto next;
  519.         }
  520.  
  521.         if( !strcmp( pres_resource->name, "help"))
  522.         {
  523.             help_msg = pres_resource->value;
  524.             goto next;
  525.         }
  526.  
  527. next: 
  528.         pres_resource = pres_resource->next;
  529.  
  530.     }
  531.  
  532.     XtSetArg( vpane_args[num_vpane_args], XtNfromVert, 
  533.         prev_widget); 
  534.     num_vpane_args++;
  535.  
  536.     XtSetArg( vpane_args[num_vpane_args], XtNgripIndent, -30 );
  537.     num_vpane_args++;
  538.     vpane = XtCreateManagedWidget("", vPanedWidgetClass,
  539.         outer_form, vpane_args, num_vpane_args );
  540.  
  541.     XtSetArg(form_args[num_form_args], XtNdefaultDistance, 0 );
  542.     num_form_args++;
  543.     form = XtCreateManagedWidget("", formWidgetClass,
  544.         vpane, form_args, num_form_args );
  545.  
  546.     XtSetArg( label_args[num_label_args], XtNborderWidth, 0);
  547.     num_label_args++;
  548.  
  549.     label = XtCreateManagedWidget("", labelWidgetClass,
  550.         form, label_args, num_label_args );
  551.  
  552.     XtSetArg(text_args[num_text_args], XtNfromHoriz, label );
  553.     num_text_args++;
  554.     *(spreadsheet->input_string) = '\0';
  555.     XtSetArg(text_args[num_text_args], XtNstring, 
  556.         spreadsheet->input_string);
  557.     num_text_args++;
  558.     XtSetArg(text_args[num_text_args], XtNeditType, XttextEdit);
  559.     num_text_args++;
  560.     XtSetArg(text_args[num_text_args], XtNtextOptions, editable );
  561.     num_text_args++;
  562.     XtSetArg(text_args[num_text_args], XtNlength, max_column_width);
  563.     num_text_args++;
  564.     XtSetArg(text_args[num_text_args], XtNwidth, 
  565.         max_column_width * (font->max_bounds).width );
  566.     num_text_args++;
  567.     XtSetArg(text_args[num_text_args], XtNfont, font); 
  568.     num_text_args++;
  569.     spreadsheet->input_text = XtCreateManagedWidget("", 
  570.         asciiStringWidgetClass,
  571.         form, text_args, num_text_args );
  572.     enter_hash_help( spreadsheet->input_text, help_msg);
  573.     (*pres_cmd_arg)->input_text_widget = spreadsheet->input_text;
  574.     XtOverrideTranslations( spreadsheet->input_text, input_text_translations);
  575.  
  576.     XtOverrideTranslations( spreadsheet->input_text,
  577.         spread_input_translations);
  578.     XtSetArg(label2_args[num_label2_args], XtNjustify,
  579.         XtJustifyLeft); 
  580.     num_label2_args++;
  581.     label2 = XtCreateManagedWidget("", labelWidgetClass,
  582.         vpane, label2_args, num_label2_args );
  583.  
  584.     XtSetArg( scroll_args[num_scroll_args], XtNeditType,
  585.         XttextEdit );  
  586.     num_scroll_args++;
  587.     XtSetArg( scroll_args[num_scroll_args], XtNtextOptions,
  588.         scrollVertical|editable);  
  589.     num_scroll_args++;
  590.     *(spreadsheet->scroll_string) = '\0';
  591.     XtSetArg( scroll_args[num_scroll_args], XtNstring,
  592.         spreadsheet->scroll_string); 
  593.     num_scroll_args++;
  594.     (*pres_cmd_arg)->scroll_string = spreadsheet->scroll_string;
  595.  
  596.     XtSetArg( scroll_args[num_scroll_args], XtNlength,
  597.         1000); 
  598.     num_scroll_args++;
  599.     spreadsheet->scroll_text = XtCreateManagedWidget("", asciiStringWidgetClass,
  600.         vpane, scroll_args, num_scroll_args );
  601.     (*pres_cmd_arg)->text_widget = spreadsheet->scroll_text;
  602.  
  603.     XtOverrideTranslations(  spreadsheet->scroll_text,
  604.         scroll_text_translations );
  605.  
  606.     spreadsheet->cursor_position = 0;
  607.     spreadsheet->pres_column = 0;
  608.  
  609.     enter_spreadsheet( spreadsheet, vpane);
  610.  
  611.     return(vpane);
  612. }
  613.  
  614. void copy_to_scroll(w)
  615. Widget w;
  616. {
  617.     Arg args[3];
  618.     XtTextBlock text;
  619.     int replace_end;
  620.     int temp;
  621.     XtArgVal cursor;
  622.     void update_input_string();
  623.  
  624.     struct _spreadsheet *spreadsheet,
  625.     *get_spreadsheet_info();
  626.  
  627.     spreadsheet = get_spreadsheet_info(XtParent(XtParent(w)));
  628.  
  629.     temp = strlen( spreadsheet->input_string );
  630.     if ( temp > spreadsheet->column_width[
  631.           spreadsheet->pres_column] )
  632.         temp = spreadsheet->column_width[spreadsheet->
  633.                      pres_column];
  634.     XtSetArg( args[0], XtNinsertPosition,
  635.         &cursor);
  636.     XtGetValues(spreadsheet->scroll_text, args, 1);
  637.     spreadsheet->cursor_position = (int)cursor;
  638.  
  639.     while( temp<(spreadsheet->column_width[
  640.             spreadsheet->pres_column] + 2) )
  641.     {
  642.         *(spreadsheet->input_string + temp ) = ' ';
  643.         temp++;
  644.     }
  645.  
  646.     if ( spreadsheet->pres_column+1 >= 
  647.         spreadsheet->number_of_columns)
  648.         *(spreadsheet->input_string + temp -1 ) = '\n';
  649.  
  650.     text.firstPos = 0;
  651.     text.ptr = spreadsheet->input_string;
  652.     text.length = temp;
  653.  
  654.     replace_end = (spreadsheet->cursor_position +
  655.         temp )>strlen(spreadsheet->scroll_string)?
  656.         strlen(spreadsheet->scroll_string):
  657.         spreadsheet->cursor_position + temp;
  658.  
  659.     XtTextReplace ( spreadsheet->scroll_text, 
  660.         spreadsheet->cursor_position,
  661.         replace_end, &text );
  662.  
  663.     spreadsheet->cursor_position += spreadsheet->
  664.         column_width[spreadsheet->pres_column] + 2;
  665.  
  666.     spreadsheet->pres_column += 1;
  667.  
  668.     if(spreadsheet->pres_column + 1> spreadsheet->number_of_columns)
  669.         spreadsheet->pres_column = 0;
  670.     XtSetArg( args[0], XtNinsertPosition, spreadsheet->cursor_position);
  671.     XtSetValues( spreadsheet->scroll_text, args, 1);
  672.  
  673.     update_input_string(spreadsheet);
  674.  
  675. }
  676.  
  677.  
  678. void update_cursor_position(w, event, params, num_params)
  679. Widget w;
  680. XEvent  *event;
  681. String *params;
  682. Cardinal *num_params;
  683. {
  684.     Arg args[3];
  685.     int temp;
  686.     void update_input_string();
  687.     XtArgVal cursor;
  688.  
  689.     struct _spreadsheet *spreadsheet,
  690.     *get_spreadsheet_info();
  691.  
  692.     spreadsheet = get_spreadsheet_info(XtParent(w));
  693.  
  694.     XtSetArg( args[0], XtNinsertPosition,
  695.         &cursor);
  696.     XtGetValues(w, args, 1);
  697.     spreadsheet->cursor_position = (int)cursor;
  698.     if( **params == '1' )
  699.     {
  700.         spreadsheet->cursor_position += 
  701.             spreadsheet->column_width[spreadsheet->pres_column] + 2;
  702.  
  703.         if( spreadsheet->cursor_position > 
  704.             strlen( spreadsheet->scroll_string ))
  705.         {
  706.             spreadsheet->cursor_position -= 
  707.                 spreadsheet->column_width[
  708.                  spreadsheet->pres_column] + 2;
  709.             return;
  710.         }
  711.  
  712.         spreadsheet->pres_column++;
  713.  
  714.         if ( spreadsheet->pres_column +1 > 
  715.             spreadsheet->number_of_columns )
  716.             spreadsheet->pres_column = 0;
  717.  
  718.     }
  719.  
  720.     if(  **params == '2' )
  721.     {
  722.         temp = spreadsheet->pres_column;
  723.  
  724.         spreadsheet->pres_column--;
  725.  
  726.         if ( spreadsheet->pres_column < 0 )
  727.             spreadsheet->pres_column = 
  728.                 spreadsheet->number_of_columns - 1;
  729.  
  730.         spreadsheet->cursor_position -= 
  731.             spreadsheet->column_width[spreadsheet->pres_column] 
  732.             + 2;
  733.  
  734.         if( spreadsheet->cursor_position < 0)
  735.         {
  736.             spreadsheet->cursor_position += 
  737.                 spreadsheet->column_width[
  738.              spreadsheet->pres_column] + 2;
  739.             spreadsheet->pres_column = temp;
  740.             return;
  741.         }
  742.  
  743.     }
  744.  
  745.     if( **params == '3' )
  746.     {
  747.         spreadsheet->cursor_position += 
  748.             spreadsheet->scrolltext_width;
  749.  
  750.         if( spreadsheet->cursor_position > 
  751.             (long)(strlen(spreadsheet->scroll_string)))
  752.         {
  753.             spreadsheet->cursor_position -= 
  754.                 spreadsheet->scrolltext_width;
  755.             return;
  756.         }
  757.  
  758.     }
  759.  
  760.     if( **params == '4' )
  761.     {
  762.         spreadsheet->cursor_position -= 
  763.             spreadsheet->scrolltext_width;
  764.  
  765.         if( spreadsheet->cursor_position < 0 )
  766.         {
  767.             spreadsheet->cursor_position += 
  768.                 spreadsheet->scrolltext_width;
  769.             return;
  770.         }
  771.     }
  772.  
  773.     XtSetArg( args[0], XtNinsertPosition, 
  774.         spreadsheet->cursor_position );
  775.  
  776.  
  777.     XtSetValues( spreadsheet->scroll_text, args, 1 );
  778.  
  779.     update_input_string(spreadsheet);
  780. }
  781.  
  782. void update_input_string(spreadsheet)
  783. struct _spreadsheet *spreadsheet;
  784. {
  785.     char *temp;
  786.     XtTextBlock text;
  787.     Arg args[2];
  788.     char string[50];
  789.     int length ;
  790.  
  791.  
  792.     temp = (char *)((long)(spreadsheet->scroll_string) + 
  793.         spreadsheet->cursor_position);
  794.  
  795.  
  796.     while( *( temp ) != ' '
  797.         && *( temp ) != '\0')
  798.         temp ++;
  799.  
  800.     /*   strncpy( string, scroll_string+cursor_position
  801.        , temp-cursor_position);
  802.  /*  *( string + temp-cursor_position ) = '\0';
  803. */
  804.  
  805.     text.length = (long)temp - spreadsheet->
  806.         cursor_position - 
  807.         (long)spreadsheet->scroll_string;
  808.     text.ptr = (char *)((long)spreadsheet->scroll_string + 
  809.         spreadsheet->cursor_position);
  810.     text.firstPos = 0;
  811.     temp = spreadsheet->input_string;
  812.     while( *(temp) != '\0')
  813.         temp++;
  814.  
  815.     XtTextReplace( spreadsheet->input_text, 0, (long)temp - 
  816.         (long)spreadsheet->input_string ,
  817.         &text );
  818.     XtSetArg( args[0], XtNinsertPosition, 0);
  819.     XtSetArg( args[1], XtNlength, spreadsheet->column_width[
  820.                spreadsheet->pres_column] );
  821.     XtSetValues( spreadsheet->input_text, args, 1);
  822.  
  823. }
  824.  
  825. enter_spreadsheet( spreadsheet, widget_ptr )
  826. struct _spreadsheet *spreadsheet;
  827. Widget widget_ptr;
  828. {
  829.     static int i= 0;
  830.     int key;
  831.  
  832.     if( i == 0 )
  833.     {
  834.         for ( i == 0 ; i<MAX_NUM_SPREADSHEETS ; i++ )
  835.         {
  836.             spreadsheet_info[i].widget_ptr = NULL;
  837.         }
  838.     }
  839.  
  840.     key = ((long) widget_ptr)%MAX_NUM_SPREADSHEETS;
  841.  
  842.     while( spreadsheet_info[key].widget_ptr != NULL)
  843.         key++;
  844.  
  845.     spreadsheet_info[key].widget_ptr = widget_ptr;
  846.     spreadsheet_info[key].spreadsheet = spreadsheet;
  847.  
  848.     return;
  849. }
  850.  
  851.  
  852.  
  853. struct _spreadsheet *get_spreadsheet_info(w)
  854. Widget w;
  855. {
  856.  
  857.     int key;
  858.  
  859.     key = ((long)w)%MAX_NUM_SPREADSHEETS;
  860.  
  861.     while(w != spreadsheet_info[key].widget_ptr)
  862.         key++;
  863.  
  864.     return(spreadsheet_info[key].spreadsheet );
  865.  
  866. }
  867. /*
  868. void check_length(w, event, params, num_params)
  869.      Widget w;
  870.      XEvent *event;
  871.      String *params;
  872.      Cardinal *num_params;
  873. {
  874.   XKeyEvent *keyevent;
  875.   keyevent = (XKeyEvent *)event;
  876.   keyevent->keycode = XKeysymToKeycode(0xFFB1);
  877. }
  878. */
  879.