Programmer 7500/MAX_PROGRAMMERS.iso/PASCAL/MADTRB2.ZIP/S_INPUT1.INC

Text File | 1986-03-01 | 26.1 KB | 568 lines

{ S_INPUT1.INC }

{ *************************************************************************** }
{ *                                                                         * }
{ *                TURBO SCREEN INPUT PRE-PROCESSOR TOOLKIT                 * }
{ *                                                                         * }
{ *               SCROLLING INPUT SUBPROGRAM INCLUDE FILE  #1               * }
{ *                                                                         * }
{ *                             Version  1.07                               * }
{ *                                                                         * }
{ *                                                                         * }
{ *    This is the first include file for the scrolling window page         * }
{ *    module.  This file wust be used in conjunction with the include      * }
{ *    file 'S_Input2.Inc' .                                                * }
{ *                                                                         * }
{ *    Note that further documentation on scrolling input page support can  * }
{ *    be found in the documentation file 'Tsipp.Doc'.                      * }
{ *                                                                         * }
{ *    Note that this subprogram is written so that for every scrolling     * }
{ *    page, the top, bottom, and left edge of the scrolling window are     * }
{ *    constant and only the right edge of the scrolling window can vary    * }
{ *    for each scrolling input page.                                       * }
{ *                                                                         * }
{ *    Inorder to have complete mobility with the location of the scrolling * }
{ *    window for every scrolling input page, change the constants which    * }
{ *    specify the location of the top, bottom, and left edge of the        * }
{ *    scrolling window into functions, similar to the two functions        * }
{ *    defining the right edge of the scrolling window.                     * }
{ *                                                                         * }
{ *************************************************************************** }



Const { Scrolling Input Page Constants }

  S_I_ENTRY_LIMIT=20;                { number of input data rows in the scrolling window }

  TOP_EDGE_OF_OUTER_SCROLL_WINDOW=13;   { top physical screen row of the outer window used in scrolling input }
                                        { data up, down, left, and right.  This value can range from 1 to 24. }
  BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW=23;{ bottom physical screen row of the outer window used in scrolling input }
                                        { data up, down, left, and right.  This value can range from 2 to 25. }
  LEFT_EDGE_OF_OUTER_SCROLL_WINDOW=4;   { left physical screen row of the outer window used in scrolling input }
                                        { data up, down, left, and right. }

  TOP_EDGE_OF_INNER_SCROLL_WINDOW=18;   { top physical screen row of the inner window used in scrolling input }
                                        { data up, down, left, and right.  This value can range from 1 to 245. }
  BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW=22;{ bottom physical screen row of the inner window used in scrolling input }
                                        { data up, down, left, and right.  This value can range from 2 to 25. }
  LEFT_EDGE_OF_INNER_SCROLL_WINDOW=7;   { left physical screen row of the inner window used in scrolling input }
                                        { data up, down, left, and right. }

  MAX_LEFT_COL=1;                    { leftmost input data column that the scrolling window can access and display }
                                     { This value is normally 1. }

  MAX_NUM_OF_S_I_PROMPT_COLS=7;      { maximum number of column prompts in the scrolling window }
                                     { Usually this number is found to be MaxRightCol-MAX_LEFT_COL+1 }

  MAX_NUM_OF_S_I_DATA_COLS=6;        { maximum number of columns in the input data array }
                                     { Usually this number is found to be MaxRightCol-MAX_LEFT_COL, or one less than }
                                     { MAX_NUM_OF_S_I_PROMPT_COL since the first column is usually an index column. }

  COL_WIDTH=10;                      { physical width of screen columns that are displayed within the scrolling window }
                                     { All columns that are displayed within the scroll window are of the same width }

  MAX_SIZE_OF_S_I_PROMPT=9;          { maximum size of column prompt heading string entry.  Must be one less than }
                                     { COL_WIDTH for no overlap to occur with column prompt headings. }

  MAX_SIZE_OF_S_I_ENTRY=7;           { maximum size of input data entry string.  Must be one less than COL_WIDTH for }
                                     { no overlap to occur with adjacent columns. }



Type { Scrolling Input Page Data Structure }

  S_I_ColPrompts=                    { record type used for S_I column template used to }
    Record                           { store specific information about a particular column heading. }
      Prompt1,                       { Note that this prompt record type allows only three lines per column heading. }
      Prompt2,
      Prompt3:String[MAX_SIZE_OF_S_I_PROMPT];
      InputDataType:Integer;         { allowable input data type for a particular input column }
    End; { S_I_PageRecord }

  S_I_Prompts=                       { S_I column prompt template used to store the column }
    Array[1..MAX_NUM_OF_S_I_PROMPT_COLS] of S_I_ColPrompts; { prompts for a particular S_I Page }

  Typical_S_I_Page=                  { an record data type which stores }
    Record                           { for each scrolling input page: }
      Image:TextScreenPtr;           { a scrolling input page screen image }
      Prompts:S_I_Prompts;           { a record of the column prompts for each page }
    End; { Typical_G_I_Page }

  S_I_DataEntryPtr=^S_I_DataEntry;             { pointer to an input data string entry }
  S_I_DataEntry=String[MAX_SIZE_OF_S_I_ENTRY]; { data string type used for storing input data entries }



Var { Scrolling Input Page Data Structure Variables }

  S_I_Pages:
    Array[1..MAX_NUM_OF_S_I_PAGES] Of Typical_S_I_Page;           { an array constructed of the data type Typical }
                                                                  { scrolling input page }

  S_I_Data:                                                       { three dimensional array for storing input data from }
    Array[1..MAX_NUM_OF_S_I_DATA_COLS,                            { the S_I_Pages }
          1..S_I_ENTRY_LIMIT,
          1..MAX_NUM_OF_S_I_PAGES] Of S_I_DataEntryPtr;



Procedure Read_S_I_Files;

{ This procedure reads the scrolling input screen page images and templates
  and stores them into the proper S_I_Pages[S_I_Page] record.  Note that
  S_I_Page screen page images are stored under the file names
  'S_I_##.Col(or Mon)', where ## refers to the S_I_Page number, 'Col' refers
  to a color screen page, and 'Mon' refers to a monochrome screen page.  Note
  that S_I_Page templates are stored under the file names 'S_I_##.@@@', where
  ## refers to the S_I_Page number and '@@@' refers to template file
  extension constant previously defined in the file 'Main.Mod'.

  Note that the template records are pointed to by the template array (an
  array of pointers) and if there are not enough records from the template
  file to fill the template array of pointers for a particular menu page,
  those empty array pointers are set to Nil. }

Var
  S_I_Page:Integer;                    { an index to a particular S_I_Page }
  Column:Integer;                      { an index to a particular S_I_Page template column entry }
  Page:String[2];                      { a string used in determining the current S_I_Page file number }
  S_I_TemplateFile:File Of S_I_ColPrompts; { S_I_Page file template type }

Begin   { Read_S_I_Files }
  For S_I_Page:=1 To MAX_NUM_OF_S_I_PAGES Do
    With S_I_Pages[S_I_Page] Do
      Begin

        { determine file number portion of S_I_Page file name }
        Str(S_I_Page,Page);            { convert integer file number into a string }
        If S_I_Page<=9 Then
          Page:='0'+Page;

        { initializing screen page pointer }
        Image:=Nil;

        { read S_I_Page screen image }
        ReadScreenPageFromFile('S_I_'+Page,Image);

      End; { With S_I_Pages[S_I_Page] }

  { read S_I_Page template }
  Assign(S_I_TemplateFile,'S_Input'+TEMPLATE_FILE_NAME_EXTENSION); { assign to a disk file }
  Reset(S_I_TemplateFile);         { open the file for reading }
  For S_I_Page:=1 To MAX_NUM_OF_S_I_PAGES Do
    For Column:=1 To MAX_NUM_OF_S_I_PROMPT_COLS Do
      Read(S_I_TemplateFile,S_I_Pages[S_I_Page].Prompts[Column]); { read record off of disk }
  Close(S_I_TemplateFile);         { close the file }

End;    { Read_S_I_Files }



Procedure Init_S_I_DataEntries;

{ This procedure initializes the scrolling input page input data array. }

Var
  Page:Integer;                        { an index to a particular S_I_Page }
  Row:Integer;                         { an index to a particular S_I_Page column }
  Col:Integer;                         { an index to a particular S_I_Page row }

Begin   { Init_S_I_DataEntries }
  For Page:=1 To MAX_NUM_OF_S_I_PAGES Do        { pages }
    For Row:=1 To S_I_ENTRY_LIMIT Do            { rows }
      For Col:=1 To MAX_NUM_OF_S_I_DATA_COLS Do { columns }
        Begin
          New(S_I_Data[Col,Row,Page]); { allocate space in heap for input data }
          S_I_Data[Col,Row,Page]^:='';
        End; { For Col }
End;    { Init_S_I_DataEntries }



Procedure DisposeOf_S_I_DynamicMemory;

{ This procedure releases all the dynamically allocated memory used in the
  scrolling input pages back to the operating system. }

Var
  S_I_Page:Integer;                    { an index to a particular S_I_Page }
  Row:Integer;                         { an index to a particular S_I_Page column }
  Col:Integer;                         { an index to a particular S_I_Page row }

Begin   { DisposeOf_S_I_DynamicMemory }
  For S_I_Page:=1 To MAX_NUM_OF_S_I_PAGES Do      { pages }
    Begin
      With S_I_Pages[S_I_Page] Do
        Dispose(Image);                           { dispose screen page image }
      For Row:=1 To S_I_ENTRY_LIMIT Do            { rows }
        For Col:=1 To MAX_NUM_OF_S_I_DATA_COLS Do { columns }
          Dispose(S_I_Data[Col,Row,S_I_Page]);    { dispose of data entry }
    End; { For S_I_Page }
End;    { DisposeOf_S_I_DynamicMemory }



Function RightEdgeOfOuterScrollWindow:Integer;

{ This function returns an integer value which describes the location of the
  far right physical edge of the outer scrolling data window.  This function is
  necessary since the scrolling window can change in width for each particular
  scrolling page. Note that the case statement below only supports 4 scrolling
  input pages, but can easily be added to inorder to support additional
  pages. }

Begin   { RightEdgeOfOuterScrollWindow }
  Case S_I_Page Of
    1 : Begin
          RightEdgeOfOuterScrollWindow:=48; { 3 data columns displayed }
        End;   { page 1 }
    2 : Begin
          RightEdgeOfOuterScrollWindow:=28; { 1 data column displayed }
        End;   { page 2 }
    3 : Begin
          RightEdgeOfOuterScrollWindow:=77; { 6 data columns displayed }
        End;   { page 3 }
    4 : Begin
          RightEdgeOfOuterScrollWindow:=48; { 3 data columns displayed }
        End;   { page 4 }
  End; { Case Page }
End;    { RightEdgeOfOuterScrollWindow }



Function RightEdgeOfInnerScrollWindow:Integer;

{ This function returns an integer value which describes the location of the
  far right physical edge of the inner scrolling data window.  This function is
  necessary since the scrolling window can change in width for each particular
  scrolling page. Note that the case statement below only supports 4 scrolling
  input pages, but can easily be added to inorder to support additional
  pages. }

Begin   { RightEdgeOfInnerScrollWindow }
  Case S_I_Page Of
    1 : Begin
          RightEdgeOfInnerScrollWindow:=46; { 3 data columns displayed }
        End;   { page 1 }
    2 : Begin
          RightEdgeOfInnerScrollWindow:=26; { 1 data column displayed }
        End;   { page 2 }
    3 : Begin
          RightEdgeOfInnerScrollWindow:=75; { 6 data columns displayed }
        End;   { page 3 }
    4 : Begin
          RightEdgeOfInnerScrollWindow:=46; { 3 data columns displayed }
        End;   { page 4 }
  End; { Case Page }
End;    { RightEdgeOfInnerScrollWindow }



Function MaxRightCol:Integer;

{ This function returns an integer value which describes the maximum right
  input data column that the current scolling data window can access and
  display data, corresponding to the current scrolling input page.  This
  function is necessary since each scrolling page can access a different amount
  of data columns.  Note that the case statement below only supports 4
  scrolling input pages, but can easily be added to inorder to support
  additional pages.  Note also that MaxRightCol does not necessarily correspond
  to the number of actual columns being displayed.  For example, the first
  column on the screen might be a row identifier value and thus there would be
  1 more column displayed in the scrolling window than this function would have
  us believe. }

Begin   { MaxRightCol }
  Case S_I_Page Of
    1 : Begin
          MaxRightCol:=5;              { maximum of 5 data columns can be accessed }
        End;   { page 1 }
    2 : Begin
          MaxRightCol:=3;              { maximum of 3 data columns can be accessed }
        End;   { page 2 }
    3 : Begin
          MaxRightCol:=6;              { maximum of 6 data columns can be accessed }
        End;   { page 3 }
    4 : Begin
          MaxRightCol:=3;              { maximum of 3 data columns can be accessed }
        End;   { page 4 }
  End; { Case S_I_Page }
End;    { MaxRightCol }



Procedure HighlightSpecial_S_I_Prompts(    CurrentLeftMostDataCol,
                                           CurrentRightMostDataCol:Integer);

{ This procedure highlights the special quick input keystrokes for specific
  S_I_Page prompts.  Note that the case statement below only supports 4
  scrolling input pages, but can easily be added to inorder to support
  additional pages. }

Begin   { HighlightSpecial_S_I_Prompts }
  Case S_I_Page Of
    1 : Begin
          If CurrentLeftMostDataCol=1 Then
            Begin
              Window(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                     TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
                     RightEdgeOfOuterScrollWindow,
                     BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
              TextColor(QuickInputHighlightColor);
              TextBackground(InputWindowColor);
              GotoXY(15,4);
                Write('I');
              GotoXY(17,4);
                Write('C');
              GotoXY(19,4);
                Write('D');
              GotoXY(21,4);
                Write('L');
            End; { If CurrentLeftMostDataCol }
        End; { page 1 }
    2 : Begin
          If CurrentLeftMostDataCol=1 Then
            Begin
              Window(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                     TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
                     RightEdgeOfOuterScrollWindow,
                     BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
              TextColor(QuickInputHighlightColor);
              TextBackground(InputWindowColor);
              GotoXY(15,4);
                Write('I');
              GotoXY(17,4);
                Write('C');
              GotoXY(19,4);
                Write('D');
              GotoXY(21,4);
                Write('L');
            End; { If CurrentLeftMostDataCol }
        End; { page 2 }
    3 : Begin
          If CurrentLeftMostDataCol=1 Then
            Begin
              Window(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                     TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
                     RightEdgeOfOuterScrollWindow,
                     BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
              TextColor(QuickInputHighlightColor);
              TextBackground(InputWindowColor);
              GotoXY(15,4);
                Write('I');
              GotoXY(17,4);
                Write('C');
              GotoXY(19,4);
                Write('D');
              GotoXY(21,4);
                Write('L');
            End; { If CurrentLeftMostDataCol }
        End; { page 3 }
    4 : Begin
          If CurrentLeftMostDataCol=1 Then
            Begin
              Window(LEFT_EDGE_OF_OUTER_SCROLL_WINDOW,
                     TOP_EDGE_OF_OUTER_SCROLL_WINDOW,
                     RightEdgeOfOuterScrollWindow,
                     BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW);
              TextColor(QuickInputHighlightColor);
              TextBackground(InputWindowColor);
              GotoXY(15,4);
                Write('I');
              GotoXY(17,4);
                Write('C');
              GotoXY(19,4);
                Write('D');
              GotoXY(21,4);
                Write('L');
            End; { If CurrentLeftMostDataCol }
        End; { page 4 }
  End; { Case S_I_Page }
End;    { HighlightSpecial_S_I_Prompts }



Procedure ShiftScrollWindowDataSidewaysModule(    NewInputCol,
                                                  CurrentTopMostDataRow  :Integer;
                                              Var CurrentLeftMostDataCol,
                                                  CurrentRightMostDataCol:Integer);

{ *************************************************************************** }
{ *                                                                         * }
{ *                SHIFT SCROLL WINDOW DATA SIDEWAYS MODULE                 * }
{ *                                                                         * }
{ *    This module is used by the procedures CurseLeft, CurseRight, and     * }
{ *    CarriageReturn.  This module shifts the data that is being displayed * }
{ *    in the scrolling window to the right or left, depending upon the     * }
{ *    value passed in NewInputCol.  Thus the scrolling window can scroll   * }
{ *    data sideways, acting like a viewport onto a spreadsheet.            * }
{ *                                                                         * }
{ *************************************************************************** }

Var
  DataCol:Integer;                     { index variable to a screen column to be displayed on the screen }
  OldLeftMostDataCol:Integer;          { an index to the previous left most data column }



  Procedure ShiftDataColHorizontally(    Column,
                                         OldLeftMostDataCol,
                                         NewLeftMostDataCol:Integer);

  { This procedure horizontally shifts the passed Column of data and
    corresponding prompt from its previous position with respect to the passed
    OldLeftMostDataCol to its new position with respect to the passed
    NewLeftMostDataCol by moving portions of the video buffer to new locations
    within the video buffer. }

  Var
    ColorMonitorImage:Array[1..25,1..80,1..2] Of Char Absolute $B800:0000;
      { an overlayed map of the color video memory addresses }
    MonoMonitorImage:Array[1..25,1..80,1..2] Of Char Absolute $B000:0000;
      { an overlayed map of the monochrome video memory addresses }
    ScreenRow:Integer;                 { an index used in moving the data column }

  Begin   { ShiftDataColHorizontally }
    If MonitorType=7 Then { monochrome adapter and monochrome monitor }
      For ScreenRow:=TOP_EDGE_OF_OUTER_SCROLL_WINDOW+1 To BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW Do
        Move(MonoMonitorImage[ScreenRow,
                              LEFT_EDGE_OF_INNER_SCROLL_WINDOW+((Column-OldLeftMostDataCol+1)*COL_WIDTH),
                              1],
             MonoMonitorImage[ScreenRow,
                              LEFT_EDGE_OF_INNER_SCROLL_WINDOW+((Column-NewLeftMostDataCol+1)*COL_WIDTH),
                              1],
             COL_WIDTH*2-1)
    Else { color or enhanced color adapter and color or monochrome monitor }
      For ScreenRow:=TOP_EDGE_OF_OUTER_SCROLL_WINDOW+1 To BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW Do
        Move(ColorMonitorImage[ScreenRow,
                               LEFT_EDGE_OF_INNER_SCROLL_WINDOW+((Column-OldLeftMostDataCol+1)*COL_WIDTH),
                               1],
             ColorMonitorImage[ScreenRow,
                               LEFT_EDGE_OF_INNER_SCROLL_WINDOW+((Column-NewLeftMostDataCol+1)*COL_WIDTH),
                               1],
             COL_WIDTH*2-1);
  End;    { ShiftDataColHorizontally }



  Procedure RemoveDataColPromptAndDataEntries(    Column:Integer);

  { This procedure removes the data column prompt (or descriptor) and its
    corresponding data entries from the current scrolling window for the passed
    Column index. }

  Begin   { RemoveDataColPromptAndDataEntries }
    TextBackground(InputWindowColor);

    { remove data column prompt from scroll window }
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW+((Column-CurrentLeftMostDataCol+1)*COL_WIDTH),
           TOP_EDGE_OF_OUTER_SCROLL_WINDOW+1,
           LEFT_EDGE_OF_INNER_SCROLL_WINDOW+((Column-CurrentLeftMostDataCol+1)*COL_WIDTH)+COL_WIDTH-1,
           TOP_EDGE_OF_INNER_SCROLL_WINDOW-2);
    ClrScr;

    { remove corresponding data entries from scroll window }
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW+((Column-CurrentLeftMostDataCol+1)*COL_WIDTH),
           TOP_EDGE_OF_INNER_SCROLL_WINDOW,
           LEFT_EDGE_OF_INNER_SCROLL_WINDOW+((Column-CurrentLeftMostDataCol+1)*COL_WIDTH)+COL_WIDTH-1,
           BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);
    ClrScr;

  End;    { RemoveDataColPromptAndDataEntries }



  Procedure DisplayDataColPromptAndDataEntries(    Column:Integer);

  { This procedure displays the data column prompt (or descriptor) and
    corresponding data entries in the current scrolling window for the passed
    Column index. }

  Var
    Row:Integer;                       { a counter index to a data row }

  Begin   { DisplayDataColPromptAndDataEntries }
    TextColor(ForegroundColor);
    TextBackground(InputWindowColor);

    { define portion of screen that column prompt is to be displayed in }
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
           TOP_EDGE_OF_OUTER_SCROLL_WINDOW+1,
           RightEdgeOfInnerScrollWindow,
           TOP_EDGE_OF_INNER_SCROLL_WINDOW-2);

    { display column prompt, this routine assumes that there are only three lines to each column heading }
    GotoXY(((Column-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,1);  { column prompt heading }
      Write(S_I_Pages[S_I_Page].Prompts[Column+1].Prompt1);
    GotoXY(((Column-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,2);  { column prompt heading }
      Write(S_I_Pages[S_I_Page].Prompts[Column+1].Prompt2);
    GotoXY(((Column-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,3);  { column prompt heading }
      Write(S_I_Pages[S_I_Page].Prompts[Column+1].Prompt3);

    { define portion of screen that input data is to be displayed in }
    Window(LEFT_EDGE_OF_INNER_SCROLL_WINDOW,
           TOP_EDGE_OF_INNER_SCROLL_WINDOW,
           RightEdgeOfInnerScrollWindow,
           BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW);

    { display corresponding column data }
    For Row:=1 To (BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW-TOP_EDGE_OF_INNER_SCROLL_WINDOW+1) Do
      Begin
        GotoXY(((Column-CurrentLeftMostDataCol+1)*COL_WIDTH)+1,Row); { goto front of data entry }
        Write(S_I_Data[Column,(CurrentTopMostDataRow+Row-1),S_I_Page]^); { write data entry }
      End; { For Row }

  End;    { DisplayDataColPromptAndDataEntries }



Begin   { ShiftScrollWindowDataSidewaysModule }
  OldLeftMostDataCol:=CurrentLeftMostDataCol;

  { check for carriage return }
  If NewInputCol=MAX_LEFT_COL Then
    Begin { carriage return }
      CurrentRightMostDataCol:=MAX_LEFT_COL+CurrentRightMostDataCol-CurrentLeftMostDataCol;
      CurrentLeftMostDataCol:=MAX_LEFT_COL;
      If OldLeftMostDataCol<=CurrentRightMostDataCol Then
        Begin
          For DataCol:=CurrentRightMostDataCol DownTo OldLeftMostDataCol Do
            ShiftDataColHorizontally(DataCol,OldLeftMostDataCol,CurrentLeftMostDataCol);
          For DataCol:=OldLeftMostDataCol-1 DownTo CurrentLeftMostDataCol Do
            Begin
              RemoveDataColPromptAndDataEntries(DataCol);
              DisplayDataColPromptAndDataEntries(DataCol);
            End; { For DataCol }
        End { If OldLeftMostDataCol }
      Else
        For DataCol:=CurrentRightMostDataCol DownTo CurrentLeftMostDataCol Do
          Begin
            RemoveDataColPromptAndDataEntries(DataCol);
            DisplayDataColPromptAndDataEntries(DataCol);
          End; { Else }
    End; { carriage return }

  { check for curse to the left }
  If NewInputCol<CurrentLeftMostDataCol Then
    Begin { curse left }
      CurrentLeftMostDataCol:=NewInputCol;
      CurrentRightMostDataCol:=CurrentRightMostDataCol-1;
      For DataCol:=CurrentRightMostDataCol DownTo OldLeftMostDataCol Do
        ShiftDataColHorizontally(DataCol,OldLeftMostDataCol,CurrentLeftMostDataCol);
      RemoveDataColPromptAndDataEntries(CurrentLeftMostDataCol);
      DisplayDataColPromptAndDataEntries(CurrentLeftMostDataCol);
    End; { curse left }

  { check for curse to the right }
  If NewInputCol>CurrentRightMostDataCol Then
    Begin { curse right }
      CurrentLeftMostDataCol:=CurrentLeftMostDataCol+1;
      CurrentRightMostDataCol:=NewInputCol;
      For DataCol:=CurrentLeftMostDataCol To CurrentRightMostDataCol-1 Do
        ShiftDataColHorizontally(DataCol,OldLeftMostDataCol,CurrentLeftMostDataCol);
      RemoveDataColPromptAndDataEntries(CurrentRightMostDataCol);
      DisplayDataColPromptAndDataEntries(CurrentRightMostDataCol);
    End; { curse right }

End;    { ShiftScrollWindowDataSidewaysModule }