home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / msdos / pibterm / pibt41s3.arc / PIBSCRN3.MOD < prev    next >
Encoding:
Text File  |  1988-01-29  |  22.7 KB  |  550 lines
  1. (*----------------------------------------------------------------------*)
  2. (*                Save_Screen --- Save current screen image             *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Save_Partial_Screen( VAR Saved_Screen_Pointer : Saved_Screen_Ptr;
  6.                                    X1                   : INTEGER;
  7.                                    Y1                   : INTEGER;
  8.                                    X2                   : INTEGER;
  9.                                    Y2                   : INTEGER  );
  10.  
  11. (*----------------------------------------------------------------------*)
  12. (*                                                                      *)
  13. (*     Procedure:  Save_Partial_Screen                                  *)
  14. (*                                                                      *)
  15. (*     Purpose:    Saves part of current screen image                   *)
  16. (*                                                                      *)
  17. (*     Calling Sequence:                                                *)
  18. (*                                                                      *)
  19. (*        Save_Partial_Screen( VAR Saved_Screen_Pointer :               *)
  20. (*                                      Saved_Screen_Ptr;               *)
  21. (*                                 X1                   : INTEGER;      *)
  22. (*                                 Y1                   : INTEGER;      *)
  23. (*                                 X2                   : INTEGER;      *)
  24. (*                                 Y2                   : INTEGER  );   *)
  25. (*                                                                      *)
  26. (*           Saved_Screen_Pointer  --- pointer to record receiving      *)
  27. (*                                     screen image, window location,   *)
  28. (*                                     and current cursor location.     *)
  29. (*           (X1,Y1)               --- upper left hand corner of area   *)
  30. (*                                     to be saved.                     *)
  31. (*           (X2,Y2)               --- lower right hand corner of area  *)
  32. (*                                     to be saved.                     *)
  33. (*                                                                      *)
  34. (*     Calls:   Move                                                    *)
  35. (*              Upper_Left                                              *)
  36. (*                                                                      *)
  37. (*     Remarks:                                                         *)
  38. (*                                                                      *)
  39. (*        This version checks for stack overflow.                       *)
  40. (*                                                                      *)
  41. (*        Note that text modes can be handled through the BIOS, but     *)
  42. (*        graphics modes always go directly to screen memory -- a       *)
  43. (*        problem to fix sometime in the future.                        *)
  44. (*                                                                      *)
  45. (*----------------------------------------------------------------------*)
  46.  
  47. VAR
  48.    GetMem_Length: WORD;
  49.    Graphics_Mode: BOOLEAN;
  50.    X            : INTEGER;
  51.    Y            : INTEGER;
  52.    SaveX        : INTEGER;
  53.    SaveY        : INTEGER;
  54.    Regs         : Registers;
  55.    S_Pos        : INTEGER;
  56.    F_Pos        : INTEGER;
  57.    L            : INTEGER;
  58.    SVal         : STRING[10];
  59.    SVal2        : STRING[10];
  60.    Vid_Mode     : INTEGER;
  61.    Screen_APtr  : Screen_Ptr;
  62.    EGA_GMode    : BOOLEAN;
  63.  
  64. BEGIN  (* Save_Partial_Screen *)
  65.                                    (* Figure if graphics mode or text  *)
  66.    SaveX := WhereX;
  67.    SaveY := WhereY;
  68.  
  69.    Vid_Mode      := Current_Video_Mode;
  70.    Graphics_Mode := ( Vid_Mode >= MedRes_GraphMode ) AND
  71.                     ( Vid_Mode <> Mono_TextMode );
  72.    L             := SIZEOF( Saved_Screen_Type ) - SIZEOF( Screen_Type );
  73.    EGA_GMode     := ( Vid_Mode = EGA_GraphMode );
  74.  
  75.    IF Graphics_Mode THEN
  76.       BEGIN
  77.          IF EGA_GMode THEN
  78.             IF Really_Save_EGA THEN
  79.                GetMem_Length := EGA_Graphics_Scr_Length + L
  80.             ELSE
  81.                GetMem_Length := L
  82.          ELSE
  83.             GetMem_Length := Graphics_Screen_Length + L;
  84.          F_Pos         := 1;
  85.       END
  86.    ELSE
  87.       BEGIN
  88.          F_Pos         := ( Y1 - 1 ) * Max_Screen_Col + X1;
  89.          S_Pos         := ( Y2 - 1 ) * Max_Screen_Col + X2;
  90.          GetMem_Length := ( S_Pos - F_Pos + 1 ) * 2 + L;
  91.       END;
  92.                                    (* Overwrite last screen if no room *)
  93.                                    (* This needs to be fixed later     *)
  94.  
  95.    IF ( Current_Saved_Screen >= Max_Saved_Screen ) THEN
  96.       Saved_Screen_Pointer := Saved_Screen_List[ Max_Saved_Screen ]
  97.    ELSE
  98.       BEGIN
  99.          INC( Current_Saved_Screen );
  100.          GETMEM( Saved_Screen_Pointer , GetMem_Length );
  101.          Saved_Screen_List[ Current_Saved_Screen ] := Saved_Screen_Pointer;
  102.       END;
  103.  
  104.  
  105.    IF ( Saved_Screen_Pointer = NIL ) THEN
  106.       BEGIN
  107.          WRITELN;
  108.          WRITELN('Not enough memory to save screen, display will be');
  109.          WRITELN('incorrect from now on.  PibTerm may also abort shortly.');
  110.          Press_Any;
  111.       END
  112.    ELSE WITH Saved_Screen_Pointer^ DO
  113.       BEGIN
  114.  
  115.          IF ( NOT Graphics_Mode ) THEN
  116.             BEGIN
  117.  
  118.                Upper_Left( Window_X1, Window_Y1 );
  119.  
  120.                Window_X2     := Lower_Right_Column;
  121.                Window_Y2     := Lower_Right_Row;
  122.  
  123.                Screen_Row    := SaveY;
  124.                Screen_Column := SaveX;
  125.  
  126.                Screen_X1     := PRED( X1 );
  127.                Screen_Y1     := PRED( Y1 );
  128.  
  129.                Screen_X2     := PRED( X2 );
  130.                Screen_Y2     := PRED( Y2 );
  131.  
  132.             END
  133.          ELSE
  134.             BEGIN
  135.  
  136.                Window_X1     := 0;
  137.                Window_Y1     := 0;
  138.  
  139.                IF ( Vid_Mode >= HiRes_GraphMode ) THEN
  140.                   Window_X2  := 639
  141.                ELSE
  142.                   Window_X2  := 319;
  143.  
  144.                IF EGA_GMode THEN
  145.                   Window_Y2  := 349
  146.                ELSE
  147.                   Window_Y2  := 199;
  148.  
  149.                Screen_X1     := 0;
  150.                Screen_Y1     := 0;
  151.  
  152.                Screen_X2     := 639;
  153.  
  154.                IF EGA_GMode THEN
  155.                   Screen_Y2  := 349
  156.                ELSE
  157.                   Screen_Y2  := 199;
  158.  
  159.                Screen_Row    := Graphics_YPos;
  160.                Screen_Column := Graphics_XPos;
  161.  
  162.             END;
  163.  
  164.          Screen_Size := GetMem_Length - L;
  165.          If_BIOS     := NOT Write_Screen_Memory;
  166.          Video_Mode  := Vid_Mode;
  167.  
  168.                                    (* Freeze screen for DoubleDos *)
  169.  
  170.          IF ( MultiTasker = DoubleDos ) THEN
  171.             BEGIN
  172.                TurnOffTimeSharing;
  173.                Get_Screen_Address( DesqView_Screen );
  174.             END;
  175.  
  176.          IF Graphics_Mode THEN
  177.             BEGIN
  178.  
  179.                IF ( MultiTasker = DoubleDos ) THEN
  180.                   Screen_APtr := DesqView_Screen
  181.                ELSE
  182.                   IF EGA_GMode THEN
  183.                      Screen_APtr := PTR( EGA_Screen_Address , 0 )
  184.                   ELSE
  185.                      Screen_APtr := PTR( Color_Screen_Address , 0 );
  186.  
  187.                IF ( Screen_Size > 0 ) THEN
  188.                   MOVE( Screen_APtr^.Screen_Image[1],
  189.                         Screen_Image[1], Screen_Size );
  190.  
  191.             END
  192.          ELSE IF Write_Screen_Memory THEN
  193.             IF Wait_For_Retrace THEN
  194.                MoveFromScreen( DesqView_Screen^.Screen_Image[F_Pos * 2 - 1],
  195.                                Screen_Image[1], Screen_Size SHR 1 )
  196.             ELSE
  197.                MOVE( DesqView_Screen^.Screen_Image[F_Pos * 2 - 1],
  198.                      Screen_Image[1], Screen_Size )
  199.          ELSE
  200.             BEGIN                  (* Use BIOS (SLOW!!!) *)
  201.  
  202.                S_Pos := 1;
  203.                                    (* Turn off the cursor *)
  204.                CursorOff;
  205.                                    (* Loop over screen area *)
  206.  
  207.                FOR Y := Y1 TO Y2 DO
  208.                   FOR X := X1 TO X2 DO
  209.                      BEGIN
  210.                         ReadCXY( Screen_Image[S_Pos], X, Y, Screen_Image[S_Pos + 1] );
  211.                         S_Pos := S_Pos + 2;
  212.                      END;
  213.                                    (* Restore previous position *)
  214.  
  215.                GoToXY( SaveX, SaveY );
  216.  
  217.                                    (* Turn on the cursor   *)
  218.                CursorOn;
  219.  
  220.             END;
  221.                                    (* Unfreeze screen in DoubleDos *)
  222.  
  223.          IF ( MultiTasker = DoubleDos ) THEN
  224.             TurnOnTimeSharing;
  225.  
  226.          IF Graphics_Mode THEN
  227.             BEGIN
  228.                Set_Text_Mode( Text_Mode );
  229.                IF EGA_Present THEN
  230.                   Set_EGA_Text_Mode( Max_Screen_Line );
  231.                Reset_Global_Colors;
  232.             END;
  233.  
  234.       END;
  235.  
  236. END   (* Save_Partial_Screen *);
  237.  
  238. (*----------------------------------------------------------------------*)
  239. (*              Restore_Screen --- Restore saved screen image           *)
  240. (*----------------------------------------------------------------------*)
  241.  
  242. PROCEDURE Restore_Screen( VAR Saved_Screen_Pointer : Saved_Screen_Ptr );
  243.  
  244. (*----------------------------------------------------------------------*)
  245. (*                                                                      *)
  246. (*     Procedure:  Restore_Screen                                       *)
  247. (*                                                                      *)
  248. (*     Purpose:    Restores previously saved screen image.              *)
  249. (*                                                                      *)
  250. (*     Calling Sequence:                                                *)
  251. (*                                                                      *)
  252. (*        Restore_Screen( VAR Saved_Screen_Pointer: Saved_Screen_Ptr ); *)
  253. (*                                                                      *)
  254. (*           Saved_Screen_Pointer  --- pointer to record with saved     *)
  255. (*                                     screen image, window location,   *)
  256. (*                                     and cursor location.             *)
  257. (*                                                                      *)
  258. (*     Calls:   Window                                                  *)
  259. (*              Move                                                    *)
  260. (*              GoToXY                                                  *)
  261. (*              WriteCXY                                                *)
  262. (*                                                                      *)
  263. (*     Remarks:                                                         *)
  264. (*                                                                      *)
  265. (*        All saved screen pointers from the last saved down to the     *)
  266. (*        argument pointer are popped from the saved screen list.       *)
  267. (*                                                                      *)
  268. (*----------------------------------------------------------------------*)
  269.  
  270. VAR
  271.    X            : BYTE;
  272.    Y            : BYTE;
  273.    I            : INTEGER;
  274.    L            : INTEGER;
  275.    F_Pos        : INTEGER;
  276.    Graphics_Mode: BOOLEAN;
  277.    Regs         : Registers;
  278.    SVal         : AnyStr;
  279.    Vid_Mode     : INTEGER;
  280.    EGA_On       : BOOLEAN;
  281.    Screen_APtr  : Screen_Ptr;
  282.  
  283. BEGIN  (* Restore_Screen *)
  284.                                    (* Don't restore screen if pointer  *)
  285.                                    (* is nil                           *)
  286.  
  287.    IF ( Saved_Screen_Pointer = NIL ) THEN EXIT;
  288.  
  289.                                    (* Figure if graphics mode or text  *)
  290.  
  291.    Vid_Mode      := Current_Video_Mode;
  292.    Graphics_Mode := ( Vid_Mode >= MedRes_GraphMode ) AND
  293.                     ( Vid_Mode <> Mono_TextMode );
  294.    L             := SIZEOF( Saved_Screen_Type ) - SIZEOF( Screen_Type );
  295.    EGA_On        := EGA_Present;
  296.  
  297.    WITH Saved_Screen_Pointer^ DO
  298.       BEGIN
  299.  
  300.          IF ( Video_Mode >= MedRes_GraphMode ) AND
  301.             ( Video_Mode <> Mono_TextMode    ) THEN
  302.             BEGIN  (* Process saved graphics screen *)
  303.  
  304.                IF ( NOT Graphics_Mode ) THEN
  305.                   BEGIN
  306.                                    (* If EGA on, make sure 25 line *)
  307.                                    (* text mode.                   *)
  308.  
  309.                      IF EGA_On THEN
  310.                         Set_EGA_Text_Mode( 25 );
  311.  
  312.                                    (* Set graphics colors          *)
  313.  
  314.                      Set_Graphics_Colors( EGA_On, Video_Mode,
  315.                                           Graphics_ForeGround_Color,
  316.                                           Graphics_BackGround_Color );
  317.  
  318.                   END;
  319.                                    (* Freeze screen for DoubleDos *)
  320.  
  321.                IF ( MultiTasker = DoubleDos ) THEN
  322.                   BEGIN
  323.                      TurnOffTimeSharing;
  324.                      Get_Screen_Address( DesqView_Screen );
  325.                   END;
  326.  
  327.                IF ( Video_Mode = EGA_GraphMode ) THEN
  328.                   Screen_APtr := PTR( EGA_Screen_Address , 0 )
  329.                ELSE
  330.                   Screen_APtr := DesqView_Screen;
  331.  
  332.                IF ( Screen_Size > 0 ) THEN
  333.                   MOVE( Screen_Image, Screen_APtr^.Screen_Image,
  334.                         Screen_Size );
  335.  
  336.                                    (* Unfreeze screen in DoubleDos *)
  337.  
  338.                IF ( MultiTasker = DoubleDos ) THEN
  339.                   TurnOnTimeSharing;
  340.  
  341.                GraphWindow( Window_X1, Window_Y1, Window_X2, Window_Y2 );
  342.  
  343.                Graphics_XPos := Screen_Column;
  344.                Graphics_YPos := Screen_Row;
  345.  
  346.             END    (* Process saved graphics screen *)
  347.          ELSE
  348.             BEGIN   (* Process saved text screen *)
  349.  
  350.                IF Graphics_Mode THEN
  351.                   BEGIN
  352.                      Set_Text_Mode( Text_Mode );
  353.                      IF EGA_On THEN
  354.                         Set_EGA_Text_Mode( Max_Screen_Line );
  355.                      Reset_Global_Colors;
  356.                   END;
  357.  
  358.                IF ( Write_Screen_Memory AND ( NOT IF_Bios ) ) THEN
  359.                   BEGIN
  360.                                    (* Freeze screen for DoubleDos *)
  361.  
  362.                      IF ( MultiTasker = DoubleDos ) THEN
  363.                         BEGIN
  364.                            TurnOffTimeSharing;
  365.                            Get_Screen_Address( DesqView_Screen );
  366.                         END;
  367.                                    (* Restore screen image *)
  368.  
  369.                      F_Pos := ( Screen_Y1 * Max_Screen_Col + Screen_X1 ) * 2 + 1;
  370.  
  371.                      IF Wait_For_Retrace THEN
  372.                         MoveToScreen( Screen_Image[1],
  373.                                       DesqView_Screen^.Screen_Image[F_Pos],
  374.                                       Screen_Size SHR 1 )
  375.                      ELSE
  376.                         MOVE( Screen_Image[1],
  377.                               DesqView_Screen^.Screen_Image[F_Pos],
  378.                               Screen_Size );
  379.  
  380.                                    (* Unfreeze screen in DoubleDos *)
  381.  
  382.                      IF ( MultiTasker = DoubleDos ) THEN
  383.                          TurnOnTimeSharing
  384.  
  385.                                    (* Synchronize screen for TopView *)
  386.  
  387.                      ELSE IF ( MultiTasker = TopView ) THEN
  388.                          Sync_Screen( F_Pos , Screen_Size SHR 1 );
  389.  
  390.                   END
  391.                ELSE
  392.                   BEGIN
  393.                                    (* Turn off the cursor   *)
  394.                      CursorOff;
  395.  
  396.                      I := 1;
  397.                                    (* Loop over screen area *)
  398.  
  399.                      FOR Y := Screen_Y1 TO Screen_Y2 DO
  400.                         FOR X := Screen_X1 TO Screen_X2 DO
  401.                            BEGIN
  402.                               WriteCXY( CHR(Screen_Image[I]), X + 1, Y + 1,
  403.                                         Screen_Image[I+1] );
  404.                               I := I + 2;
  405.                            END;
  406.                                    (* Turn on the cursor *)
  407.                      CursorOn;
  408.  
  409.                   END;
  410.  
  411.                PibTerm_Window( Window_X1, Window_Y1, Window_X2, Window_Y2 );
  412.                GoToXY( Screen_Column, Screen_Row );
  413.  
  414.             END    (* Process saved text screen *);
  415.  
  416.       END;
  417.  
  418.    WHILE ( ( Current_Saved_Screen > 0 ) AND
  419.            ( Saved_Screen_List[ Current_Saved_Screen ] <> Saved_Screen_Pointer ) ) DO
  420.       BEGIN
  421.          IF ( Saved_Screen_List[ Current_Saved_Screen ] <> NIL ) THEN
  422.             BEGIN
  423.                FREEMEM( Saved_Screen_List[ Current_Saved_Screen ] ,
  424.                         Saved_Screen_List[ Current_Saved_Screen ]^.Screen_Size + L );
  425.                Saved_Screen_List[ Current_Saved_Screen ] := NIL;
  426.             END;
  427.          DEC( Current_Saved_Screen );
  428.       END;
  429.  
  430.    IF ( Current_Saved_Screen > 0 ) THEN
  431.       BEGIN
  432.          Saved_Screen_List[ Current_Saved_Screen ] := NIL;
  433.          DEC( Current_Saved_Screen );
  434.       END;
  435.  
  436.    IF ( Saved_Screen_Pointer <> NIL ) THEN
  437.       BEGIN
  438.          FREEMEM( Saved_Screen_Pointer , Saved_Screen_Pointer^.Screen_Size + L );
  439.          Saved_Screen_Pointer := NIL;
  440.       END;
  441.                                    (* Update status line *)
  442.    Current_Status_Time := -1;
  443.  
  444.    IF Do_Status_Time THEN
  445.       Update_Status_Line;
  446.  
  447. END    (* Restore_Screen *);
  448.  
  449. (*----------------------------------------------------------------------*)
  450. (*                Save_Screen --- Save current screen image             *)
  451. (*----------------------------------------------------------------------*)
  452.  
  453. PROCEDURE Save_Screen( VAR Saved_Screen_Pointer : Saved_Screen_Ptr );
  454.  
  455. (*----------------------------------------------------------------------*)
  456. (*                                                                      *)
  457. (*     Procedure:  Save_Screen                                          *)
  458. (*                                                                      *)
  459. (*     Purpose:    Saves entire current screen image                    *)
  460. (*                                                                      *)
  461. (*     Calling Sequence:                                                *)
  462. (*                                                                      *)
  463. (*        Save_Screen( VAR Saved_Screen_Pointer : Saved_Screen_Ptr );   *)
  464. (*                                                                      *)
  465. (*           Saved_Screen_Pointer  --- pointer to record receiving      *)
  466. (*                                     screen image, window location,   *)
  467. (*                                     and current cursor location.     *)
  468. (*                                                                      *)
  469. (*     Calls:   Save_Partial_Screen                                     *)
  470. (*                                                                      *)
  471. (*----------------------------------------------------------------------*)
  472.  
  473. BEGIN (* Save_Screen *)
  474.  
  475.    Save_Partial_Screen( Saved_Screen_Pointer, 1, 1, Max_Screen_Col,
  476.                         Max_Screen_Line );
  477.  
  478. END   (* Save_Screen *);
  479.  
  480. (*----------------------------------------------------------------------*)
  481. (*  Restore_Screen_And_Colors --- Restore saved screen image and colors *)
  482. (*----------------------------------------------------------------------*)
  483.  
  484. PROCEDURE Restore_Screen_And_Colors( VAR Saved_Screen_Pointer : Saved_Screen_Ptr );
  485.  
  486. BEGIN (* Restore_Screen_And_Colors *)
  487.  
  488.    Restore_Screen( Saved_Screen_Pointer );
  489.    Reset_Global_Colors;
  490.  
  491. END   (* Restore_Screen_And_Colors *);
  492.  
  493. (*----------------------------------------------------------------------*)
  494. (*  Draw_Titled_Box --- Save portion of screen and draw a titled box    *)
  495. (*----------------------------------------------------------------------*)
  496.  
  497. PROCEDURE Draw_Titled_Box( VAR Saved_Screen_Pointer : Saved_Screen_Ptr;
  498.                                UpperLeftX           : INTEGER;
  499.                                UpperLeftY           : INTEGER;
  500.                                LowerRightX          : INTEGER;
  501.                                LowerRightY          : INTEGER;
  502.                                Box_Title            : AnyStr );
  503.  
  504. (*----------------------------------------------------------------------*)
  505. (*                                                                      *)
  506. (*     Procedure:  Draw_Titled_Box                                      *)
  507. (*                                                                      *)
  508. (*     Purpose:    Draws a titled frame using PC graphics characters    *)
  509. (*                                                                      *)
  510. (*     Calling Sequence:                                                *)
  511. (*                                                                      *)
  512. (*                                                                      *)
  513. (*        Draw_Titled_Box( VAR Saved_Screen_Pointer : Saved_Screen_Ptr; *)
  514. (*                             UpperLeftX           : INTEGER;          *)
  515. (*                             UpperLeftY           : INTEGER;          *)
  516. (*                             LowerRightX          : INTEGER;          *)
  517. (*                             LowerRightY          : INTEGER;          *)
  518. (*                             Box_Title            : AnyStr );         *)
  519. (*                                                                      *)
  520. (*           UpperLeftX,  UpperLeftY  --- Upper left coordinates        *)
  521. (*           LowerRightX, LowerRightY --- Lower right coordinates       *)
  522. (*           Box_Title                --- Box Title                     *)
  523. (*                                                                      *)
  524. (*     Calls:   Draw_Menu_Frame                                         *)
  525. (*              Save_Partial_Screen                                     *)
  526. (*                                                                      *)
  527. (*----------------------------------------------------------------------*)
  528.  
  529. BEGIN (* Draw_Titled_Box *)
  530.                                    (* Save portion of screen *)
  531.  
  532.    Save_Partial_Screen( Saved_Screen_Pointer,
  533.                         UpperLeftX,
  534.                         UpperLeftY,
  535.                         LowerRightX,
  536.                         LowerRightY           );
  537.  
  538.                                    (* Draw the box *)
  539.  
  540.    Draw_Menu_Frame    ( UpperLeftX,
  541.                         UpperLeftY,
  542.                         LowerRightX,
  543.                         LowerRightY,
  544.                         Menu_Frame_Color,
  545.                         Menu_Title_Color,
  546.                         Menu_Text_Color,
  547.                         Box_Title            );
  548.  
  549. END   (* Draw_Titled_Box *);
  550.