Power-Programmierung/CD1.mdf/pascal/library/dos/nicol/sti_edit/sti_edit.pas

Pascal/Delphi Source File | 1990-11-08 | 26.5 KB | 628 lines

unit STI_EDIT;                              { editor                        }

interface

Uses Crt,                                   { standard TP 5.0 library       }
     Dos,                                   { staandard Dos unit            }
     STI_SCRF,                              { a few screen procedures       }
     STI_STRN,                              { string handling               }
     STI_KEYS,                              { key scanning unit             }
     STI_ED_V,                              { editor variables              }
     STI_ED_F;                              { editor functions              }

procedure  STI_ED(X1,Y1,X2,Y2,TextCol,BorderCol,PromptCol : byte; Border : boolean;
                  Name : string; HelpP,DirP,PassP : pointer);


implementation

{---------------------------------------------------------------------------}

procedure Process_Character(Dummy : Char);

Var
  Dummy1   : string;
  Col,Len  : byte;

begin
  case Dummy of
    #8  : begin                             { BACK SPACE                    }
            Edit_Buffer^.Saved := FALSE;
            One_Char_Left;
            Delete_One_Char;
            Draw_All_Screen;
          end;
    #9  : begin                             { TAB                           }
            Do_Tab;
          end;
    #13 : begin                             { RETURN                        }
            Process_Return_key;
            Edit_Buffer^.Saved := FALSE;
            Draw_All_Screen;
          end;
    #27 : begin                             { ESCAPE                        }
          end
    else
          begin
            Edit_Buffer^.Saved := FALSE;
            Col := Edit_Buffer^.Column;
            Len := length(Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^);
            if Col > Len then
              begin
                Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ :=
                  Copy(Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^,1,Len-1)
                  + MakeStr(Col-Len,32) + #31;
              end;
            Dummy1 := Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^;
            if Edit_Buffer^.Insert then
              begin
                Dummy1 := Copy(Dummy1,1,Col-1) + Dummy + Copy(Dummy1,Col,128);
                if Length(Dummy1) > 128 then
                  begin
                    Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Copy(Dummy1,1,127)+#31;
                    One_Line_Down;
                    Insert_One_Line;
                    Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Copy(Dummy1,128,255);
                    Edit_Buffer^.Column := length(Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^);
                    Edit_Buffer^.SCRX   := Edit_Buffer^.Column;
                  end
                else
                  begin
                    Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy1;
                    One_Char_Right;
                  end;
              end
            else
              begin
                Dummy1[Col] := Dummy;
                Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy1;
                One_Char_Right;
              end;
            Draw_All_Screen;
          end;
  end;{case}
end;

{---------------------------------------------------------------------------}

procedure Process_Control_Characters(CH : KeyRec);

Var
  Dummy    : string;
  CNTRLCH  : char;
  PassCh   : ChrSet;

begin
  CNTRLCH := CH[1];
  case CNTRLCH of
    #16  : begin                            { ^P                            }
             case UpCase(ReadKey) of
               ^P,'P' : begin
                          Print_File;
                          Draw_All_Screen;
                        end;
               ^B,'B' : begin
                          Block_Print;
                          Draw_All_Screen;
                        end;
             end;
           end;
    #19  : begin                            { ^S                            }
             One_Char_Left;
           end;
    #4   : begin                            { ^D                            }
             One_Char_Right;
           end;
    #5   : begin                            { ^E                            }
             One_Line_Up;
           end;
    #24  : begin                            { ^X                            }
             One_Line_Down;
           end;
    #1   : begin                            { ^A                            }
             One_Word_Back;
           end;
    #6   : begin                            { ^F                            }
             One_Word_Forward;
           end;
    #18  : begin                            { ^R                            }
             One_Screen_Up;
             Draw_All_Screen;
           end;
    #3   : begin                            { ^C                            }
             One_Screen_Down;
             Draw_All_Screen;
           end;
    #7   : begin                            { ^G                            }
             Delete_One_Char;
             Draw_All_Screen;
           end;
    #9   : begin                            { ^I                            }
             Edit_Buffer^.Insert := Not(Edit_Buffer^.Insert);
             Put_Top_Line;
             Put_Bottom_Line;
             GotoXY(Edit_Buffer^.X1+Edit_Buffer^.SCRX -1,
                    Edit_Buffer^.Y1+Edit_Buffer^.SCRY -1);
             Delay(100);
           end;
    #11  : begin                            { ^K                            }
             case UpCase(ReadKey) of
               ^D,'D' : Quit_Check;
               ^Q,'Q' : Quit_Check;
               ^S,'S' : begin
                          Save_File(Edit_Buffer^.FileName);
                        end;
               ^B,'B' : begin
                          Block_Mark_Start;
                          Draw_All_Screen;
                        end;
               ^C,'C' : begin
                          Block_Copy;
                          Draw_All_Screen;
                        end;
               ^K,'K' : begin
                          Block_Mark_End;
                          Draw_All_Screen;
                        end;
               ^Y,'Y' : begin
                          Block_Erase;
                          Draw_All_Screen;
                        end;
               ^V,'V' : begin
                          Block_Move;
                          Draw_All_Screen;
                        end;
               ^W,'W' : begin
                          Block_Write;
                          Draw_All_Screen;
                        end;
               ^R,'R' : begin
                          Block_Read;
                          Draw_All_Screen;
                        end;
             end;
           end;
    #17  : begin                            { ^Q                            }
             case UpCase(ReadKey) of
               ^H,'H' : begin
                          Erase_Line_Contents(Edit_Buffer^.Row);
                          Draw_All_Screen;
                        end;
               ^Q,'Q' : begin
                          Search_And_Replace;
                        end;
               ^F,'F' : begin
                          Search;
                        end;
               ^R,'R' : begin
                          Jump_Start_Of_File;
                          Draw_All_Screen;
                        end;
               ^C,'C' : begin
                          Jump_End_Of_File;
                          Draw_All_Screen;
                        end;
             end;
           end;
    #25  : begin                            { ^Y                            }
             Delete_One_Line;
             Draw_All_Screen;
           end;
    #20  : begin                            { ^T                            }
             Erase_One_Word;
             Draw_All_Screen;
           end;
    #12  : begin                            { ^L                            }
             case UpCase(ReadKey) of
               ^U,'U' : begin
                          Dummy := Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^;
                          UpCaseStr2(Dummy);
                          Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy;
                          Draw_All_Screen;
                        end;
               ^D,'D' : begin
                          Dummy := Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^;
                          LoCaseStr2(Dummy);
                          Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy;
                          Draw_All_Screen;
                        end;
               ^C,'C' : begin
                          Dummy := Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^;
                          Centre_String(Dummy,MAX_LEN,' ');
                          Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy;
                          Draw_All_Screen;
                        end;
               ^R,'R' : begin
                          Dummy := Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^;
                          RightTrimStr(Dummy);
                          Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy+#31;
                          Draw_All_Screen;
                        end;
               ^L,'L' : begin
                          Dummy := Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^;
                          LeftTrimStr(Dummy);
                          Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy;
                          Draw_All_Screen;
                        end;
             end;
           end;
    #23  : begin                            { ^W                            }
             case UpCase(ReadKey) of
               ^U,'U' : begin
                          Dummy := Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^;
                          UpCase_One_Word(Dummy,Edit_Buffer^.Column);
                          Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy;
                          Draw_All_Screen;
                        end;
               ^D,'D' : begin
                          Dummy := Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^;
                          LoCase_One_Word(Dummy,Edit_Buffer^.Column);
                          Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := Dummy;
                          Draw_All_Screen;
                        end;
             end;
           end
    else
      begin
        PassCh[1] := byte(CH[1]);
        PassCh[2] := byte(CH[2]);
        PassCh[3] := byte(CH[3]);
        Pass_Chars_On(PassCh);              { pass it on                    }
      end;
  end;{case }
end;

{---------------------------------------------------------------------------}

procedure Process_Special_Key(Dummy : KeyRec); { handle all weird keys      }

Var
  ASCII   :  byte;                             { plain ASCII code           }
  EXTEND  :  byte;                             { F1 etc                     }
  SPECIAL :  byte;                             { SHIFT, CTRL, GRPH          }
  PassCh  :  ChrSet;                           { set to pass on             }

begin
  ASCII     := byte(Dummy[1]);                 { assign ascii code          }
  EXTEND    := byte(Dummy[2]);                 { assign extended code       }
  SPECIAL   := byte(Dummy[3]);                 { assign special code        }
  case SPECIAL of                              { check for CTRL,SHIFT,GRPH  }
    0   : begin                                { nothing                    }
            case EXTEND of
              98  : begin                      { F1                         }
                      Do_Help;
                      Draw_All_Screen;
                    end;
              99  : begin                      { F2                         }
                      Save_File(Edit_Buffer^.FileName);
                      Edit_Buffer^.Saved := TRUE;
                      Draw_All_Screen;
                    end;
              100 : begin                      { F3                         }
                      Load_New_File;
                      Edit_Buffer^.Saved := FALSE;
                      Draw_All_Screen;
                    end;
              101 : begin                      { F4                         }
                      Search;
                      Draw_All_Screen;
                    end;
              102 : begin                      { F5                         }
                      Search_And_Replace;
                      Edit_Buffer^.Saved := FALSE;
                      Draw_All_Screen;
                    end;
              103 : begin                      { F6                         }
                      Block_Mark_Start;
                      Draw_All_Screen;
                    end;
              104 : begin                      { F7                         }
                      Block_Mark_End;
                      Draw_All_Screen;
                    end;
              105 : begin                      { F8                         }
                      Block_Copy;
                      Draw_All_Screen;
                    end;
              106 : begin                      { F9                         }
                      Block_Erase;
                      Draw_All_Screen;
                    end;
              107 : begin                      { F10                        }
                      Quit_Check;
                    end;
              54  : begin                      { ROLL UP                    }
                      One_Screen_Up;
                      Draw_All_Screen;
                    end;
              55  : begin                      { ROLL DOWN                  }
                      One_Screen_Down;
                      Draw_All_Screen;
                    end;
              56  : begin                      { INSERT                     }
                      Edit_Buffer^.Insert := Not(Edit_Buffer^.Insert);
                      Draw_All_Screen;
                      GotoXY(Edit_Buffer^.X1+Edit_Buffer^.SCRX -1,
                             Edit_Buffer^.Y1+Edit_Buffer^.SCRY -1);
                      Delay(100);
                    end;
              57  : begin                      { DELETE                     }
                      Edit_Buffer^.Saved := FALSE;
                      Delete_One_Char;
                      Draw_All_Screen;
                    end;
              62  : begin                      { HOME CLEAR                 }
                      Begin_Of_Line;
                      Draw_All_Screen;
                    end;
              63  : begin                      { HELP                       }
                      Do_Help;
                      Draw_All_Screen;
                    end;
              59  : begin                      { <---                       }
                      One_Char_Left;
                    end;
              60  : begin                      { --->                       }
                      One_Char_Right;
                    end;
              58  : begin                      { UP ARROW                   }
                      One_Line_Up;
                    end;
              61  : begin                      { DOWN ARROW                 }
                      One_Line_Down;
                    end
              else
                begin
                  PassCh[2] := ord(EXTEND);
                  PassCh[1] := ord(ASCII);
                  PassCh[3] := ord(SPECIAL);
                  Pass_Chars_On(PassCh);
                end;
            end;{case of EXTEND}
          end;
    1   : begin                                { CTRL                       }
            case EXTEND of
              0   : begin                      { nothing                    }
                      Process_Control_Characters(char(ASCII));
                    end;
              57  : begin                      { DELETE                     }
                      Erase_One_Word;
                      Draw_All_Screen;
                    end;
              59  : begin                      { <---                       }
                      Begin_Of_Line;
                      Draw_All_Screen;
                    end;
              60  : begin                      { --->                       }
                      End_Of_Line;
                      Draw_All_Screen;
                    end;
              58  : begin                      { UP ARROW                   }
                      One_Screen_Down;
                      Draw_All_Screen;
                    end;
              61  : begin                      { DOWN ARROW                 }
                      One_Screen_Up;
                      Draw_All_Screen;
                    end
              else
                begin
                  PassCh[2] := ord(EXTEND);
                  PassCh[1] := ord(ASCII);
                  PassCh[3] := ord(SPECIAL);
                  Pass_Chars_On(PassCh);
                end;
            end;{case of EXTEND}
          end;
    10  : begin                                { SHIFT                      }
            case EXTEND of
              0   : begin                      { nothing                    }
                      if ASCII = 9 then
                        Reset_TAB
                      else
                        Process_Character(char(ASCII));
                    end;
              54  : begin                      { ROLL UP                    }
                      Jump_End_Of_File;
                      Draw_All_Screen;
                    end;
              55  : begin                      { ROLL DOWN                  }
                      Jump_Start_Of_File;
                      Draw_All_Screen;
                    end;
              56  : begin                      { INSERT                     }
                      Insert_One_Line;
                      Edit_Buffer^.Saved := FALSE;
                      Draw_All_Screen;
                    end;
              57  : begin                      { DELETE                     }
                      Delete_One_Line;
                      Edit_Buffer^.Saved := FALSE;
                      Draw_All_Screen;
                    end;
              174 : begin                      { HOME CLEAR                 }
                      End_Of_Line;
                      Draw_All_Screen;
                    end;
              59  : begin                      { <---                       }
                      One_Word_Back;
                      Draw_All_Screen;
                    end;
              60  : begin                      { --->                       }
                      One_Word_Forward;
                      Draw_All_Screen;
                    end;
              58  : begin                      { UP ARROW                   }
                      if Edit_Buffer^.Row > Edit_Buffer^.SCRY then
                        Edit_Buffer^.Row := (Edit_Buffer^.Row - Edit_Buffer^.SCRY) + 1
                      else
                        Edit_Buffer^.Row := 1;
                      Edit_Buffer^.Column := 1;
                      Edit_Buffer^.SCRX   := 1;
                      Edit_Buffer^.SCRY   := 1;
                      Draw_All_Screen;
                    end;
              61  : begin                      { DOWN ARROW                 }
                      Edit_Buffer^.Row := Edit_Buffer^.Row +
                                            ((Edit_Buffer^.Y2 - Edit_Buffer^.SCRY)-1);
                      Edit_Buffer^.Column := 1;
                      Edit_Buffer^.SCRX   := 1;
                      Edit_Buffer^.SCRY   := Edit_Buffer^.Y2-1;
                      Draw_All_Screen;
                    end
              else
                begin
                  PassCh[2] := ord(EXTEND);
                  PassCh[1] := ord(ASCII);
                  PassCh[3] := ord(SPECIAL);
                  Pass_Chars_On(PassCh);
                end;
            end;{case of EXTEND}
          end;
    100 : begin                                { GRAPH                      }
            PassCh[2] := ord(EXTEND);
            PassCh[1] := ord(ASCII);
            PassCh[3] := ord(SPECIAL);
            Pass_Chars_On(PassCh);
          end;
    101 : begin                                { GRAPH + CTRL               }
            PassCh[2] := ord(EXTEND);
            PassCh[1] := ord(ASCII);
            PassCh[3] := ord(SPECIAL);
            Pass_Chars_On(PassCh);
          end;
    110 : begin                                { GRAPH + SHIFT              }
            PassCh[2] := ord(EXTEND);
            PassCh[1] := ord(ASCII);
            PassCh[3] := ord(SPECIAL);
            Pass_Chars_On(PassCh);
          end;
     11 : begin                                { CTRL + SHIFT               }
            PassCh[2] := ord(EXTEND);
            PassCh[1] := ord(ASCII);
            PassCh[3] := ord(SPECIAL);
            Pass_Chars_On(PassCh);
          end;
    111 : begin                                { CTRL + SHIFT               }
            PassCh[2] := ord(EXTEND);
            PassCh[1] := ord(ASCII);
            PassCh[3] := ord(SPECIAL);
            Pass_Chars_On(PassCh);
          end;
  end;{case for SPECIAL}
end;

{---------------------------------------------------------------------------}

procedure Main_Edit_Loop;                   { main loop of the editor       }

Var
  Dummy : KeyRec;                           { the read key                  }

begin
  Put_Top_Line;                             { draw the top line             }
  Put_Bottom_Line;                          { draw the bottom line          }
  Load_File(Edit_Buffer^.FileName);         { load the file                 }
  Draw_All_Screen;                          { draw the screen               }
  while not(Edit_Buffer^.Done) do           { loop until done               }
    begin
      Dummy := STI_InKey2;                  { get a key                     }
      if Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row] = NIL then
        begin
          new(Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]);
          Edit_Buffer^.TextBuffer^[Edit_Buffer^.Row]^ := '';
        end;
      if (Dummy[2] <> #0) or (Dummy[3] <> #0) then  { check for special     }
        Process_Special_Key(Dummy)          { process a special key         }
      else
        Process_Character(Dummy[1]);        { this is just a normal key     }
    end;
end;

{---------------------------------------------------------------------------}

procedure  STI_ED(X1,Y1,X2,Y2,TextCol,BorderCol,PromptCol : byte; Border : boolean;
                  Name : string; HelpP,DirP,PassP : pointer);

Var
  Loop  : word;
  BREAK : boolean;
  HP1   : HelpProcedure absolute HelpP;
  DP1   : DirectoryFunc absolute DirP;
  PP1   : PassOnProc    absolute PassP;

begin
  if (X1 > 30) or (X1 < 1) then X1 := 1;
  if (X2 > 80) or (X2 < 40) then X2 := 80;
  if (Y1 > 10) or (Y1 < 1) then Y1 := 1;
  if (Y2 > 23) or (Y2 < 15) then Y2 := 23;
  GetCBreak(BREAK);                         { save old CBreak mode          }
  SetCBreak(FALSE);                         { don't stop for CBreak)        }
  New(Edit_Buffer);                         { get the edit buffer memory    }
  New(Edit_Buffer^.TextBuffer);             { get the text buffer memory    }
  Edit_Buffer^.HP          := HP1;          { set the help procedure        }
  Edit_Buffer^.DP          := DP1;          { set the directory procedure   }
  Edit_Buffer^.PP          := PP1;          { set the pass on procedure     }
  Edit_Buffer^.Saved       := TRUE;         { file originally saved         }
  Edit_Buffer^.TabWidth    := 5;            { default tab width             }
  Edit_Buffer^.Block.BC    := 0;            { start of block column         }
  Edit_Buffer^.Block.BL    := 0;            { start of block line           }
  Edit_Buffer^.Block.EC    := 0;            { end of block column           }
  Edit_Buffer^.Block.EL    := 0;            { end of block line             }
  Edit_Buffer^.FileName    := Name;         { set the file name             }
  Edit_Buffer^.X1          := X1;           { set the edit area borders     }
  Edit_Buffer^.X2          := X2;
  Edit_Buffer^.Y1          := Y1;
  Edit_Buffer^.Y2          := Y2;
  Edit_Buffer^.Border      := Border;       { use a border or not           }
  Edit_Buffer^.TextCol     := TextCol;      { set the colors                }
  Edit_Buffer^.BorderCol   := BorderCol;
  Edit_Buffer^.PromptCol   := PromptCol;
  Edit_Buffer^.Done        := FALSE;        { edit end flag                 }
  Edit_Buffer^.Insert      := TRUE;         { default to insert             }
  Edit_Buffer^.Column      := 1;            { initialise row/col etc        }
  Edit_Buffer^.Row         := 1;
  Edit_Buffer^.SCRX        := 1;
  Edit_Buffer^.SCRY        := 1;
  Edit_Buffer^.OldWMin     := WindMin;      { save old window dimentions    }
  Edit_Buffer^.OldWMax     := WindMax;
  Edit_Buffer^.OldX        := WhereX;       { save old screen pos           }
  Edit_Buffer^.OldY        := WhereY;
  Edit_Buffer^.NoLines     := 0;            { number of lines in file       }
  for Loop := 1 to MAX_LEN   do             { loop on width                 }
    begin
      if Loop mod Edit_Buffer^.TabWidth = 0 then
        Edit_Buffer^.TabMarks[Loop] := TRUE
      else                                  { set tab markers               }
        Edit_Buffer^.TabMarks[Loop] := FALSE;
    end;
  for Loop := 1 to MAX_LINES do             { loop on the number of lines   }
    begin
      Edit_Buffer^.TextBuffer^[Loop] := NIL;{ null all lines                }
    end;

  Set_Up_Screen(Edit_Buffer^);              { set up the screen             }
  Main_Edit_Loop;                           { do the actual editing         }
  Restore_Screen(Edit_Buffer^);             { restore the screen            }
  GotoXY(Edit_Buffer^.OldX,                 { restore old screen position   }
         Edit_Buffer^.OldY);

  Erase_Buffer;
  WindMin := Edit_Buffer^.OldWMin;          { restore old window size       }
  WindMax := Edit_Buffer^.OldWMax;
  GotoXY(Edit_Buffer^.OldX,Edit_Buffer^.OldY); { restore cursor position    }
  Dispose(Edit_Buffer^.TextBuffer);         { no need for text buffer       }
  Dispose(Edit_Buffer);                     { no need for edit buffer too   }
  SetCBreak(BREAK);                         { reset old mode                }
end;

{---------------------------------------------------------------------------}

begin
end.