home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / MODEM / MUFUS32R.ZIP / MUFMTASK.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-08-17  |  23.3 KB  |  500 lines
  1. UNIT MufMTask;
  2.  
  3. INTERFACE
  4.  
  5. USES
  6.    Dos,   Crt, MufGlobs;
  7.  
  8. (* EXPORTS *)
  9.  
  10.    FUNCTION IsTimeSharingActive : BOOLEAN;
  11.    PROCEDURE TurnOnTimeSharing;
  12.    PROCEDURE TurnOffTimeSharing;
  13.    PROCEDURE GiveUpTime( NSlices : INTEGER );
  14.    PROCEDURE Sync_Screen( S_Pos: INTEGER; NChars : INTEGER );
  15.    PROCEDURE Sync_Entire_Screen;
  16.  
  17. IMPLEMENTATION
  18.                                    (* Ensure multitasking defined       *)
  19. {$DEFINE MTASK}
  20.                                    (* Multitasker interface routines    *)
  21.  
  22. (*--------------------------------------------------------------------------*)
  23. (*             PIBMDOS.PAS --- Multitasker interface routines               *)
  24. (*--------------------------------------------------------------------------*)
  25. (*                                                                          *)
  26. (*  Author:  Philip R. Burns                                                *)
  27. (*                                                                          *)
  28. (*  Date:    Version 1.0: January, 1986.   DoubleDos support.               *)
  29. (*           Version 2.0: April, 1986.     Add DesqView support.            *)
  30. (*           Version 3.0: July, 1986.      Add TopView/Windows support.     *)
  31. (*           Version 3.1: September, 1986. Update for TaskView support.     *)
  32. (*           Version 3.2: December, 1986.  Distinguish TaskView/DesqView.   *)
  33. (*           Version 4.0: January, 1988.   Fix bogus TopView update, add    *)
  34. (*                                         check for Novell to stop lockup. *)
  35. (*                                                                          *)
  36. (*  Systems: MS DOS or PC DOS with DoubleDos/DesqView/TopView/Windows       *)
  37. (*           installed.                                                     *)
  38. (*                                                                          *)
  39. (*  History: These routines provide a simple interface for PibTerm          *)
  40. (*           with SoftLogic's DoubleDos multitasking executive,             *)
  41. (*           Quarterdeck's DesqView multitasker, IBM's TopView,             *)
  42. (*           MicroSoft's Windows, and Sunny Hill's TaskView.                *)
  43. (*           (Windows is handled as a Topview-emulating product.  This is   *)
  44. (*           also true for TaskView and DesqView, but those programs do     *)
  45. (*           not require the explicit screen updates TopView requires.      *)
  46. (*                                                                          *)
  47. (*           If you have another multitasker, you should be able to         *)
  48. (*           replace these routines fairly easily with similar-acting       *)
  49. (*           ones for your multitasker.  Use the global types defined       *)
  50. (*           for MultiTasker and MultiTaskerType.                           *)
  51. (*                                                                          *)
  52. (*           Note also that the routine Get_Screen_Address in Pibscren.pas  *)
  53. (*           needs to know about multitaskers.                              *)
  54. (*                                                                          *)
  55. (*           With DoubleDos, it is necessary to reobtain the display buffer *)
  56. (*           address every time the screen memory is written to.  With      *)
  57. (*           DesqView, this is unnecessary.  With TopView and Windows,      *)
  58. (*           it is necessary to inform them that the screen has changed.    *)
  59. (*           TaskView works like DesqView.                                  *)
  60. (*                                                                          *)
  61. (*--------------------------------------------------------------------------*)
  62. (*                                                                          *)
  63. (*           Please leave messages on Gene Plantz's BBS (312) 882 4145      *)
  64. (*           or Ron Fox's BBS (312) 940 6496.                               *)
  65. (*                                                                          *)
  66. (*--------------------------------------------------------------------------*)
  67.  
  68. (*--------------------------------------------------------------------------*)
  69. (*           IsNovellActive  --- Checks if Novell network is active         *)
  70. (*--------------------------------------------------------------------------*)
  71.  
  72. FUNCTION IsNovellActive : BOOLEAN;
  73.  
  74. (*--------------------------------------------------------------------------*)
  75. (*                                                                          *)
  76. (*    Function: IsNovellActive                                              *)
  77. (*                                                                          *)
  78. (*    Purpose:  Checks if Novell network active                             *)
  79. (*                                                                          *)
  80. (*    Calling Sequence:                                                     *)
  81. (*                                                                          *)
  82. (*       Novell_On := IsNovellActive : BOOLEAN;                             *)
  83. (*                                                                          *)
  84. (*          Novell_On --- TRUE if Novell network is active.                 *)
  85. (*                                                                          *)
  86. (*    Calls:  MsDos                                                         *)
  87. (*                                                                          *)
  88. (*--------------------------------------------------------------------------*)
  89.  
  90. VAR
  91.    Regs : Registers;
  92.  
  93. BEGIN (* IsNovellActive *)
  94.  
  95.    Regs.CX := 0;
  96.    Regs.AL := 0;
  97.                                    (* Request workstation ID.          *)
  98.                                    (* This should be ignored if Novell *)
  99.                                    (* network software isn't active.   *)
  100.    Regs.AH := $DC;
  101.  
  102.    MsDos( Regs );
  103.                                    (* If we got back a non-zero station *)
  104.                                    (* ID, then Novell must be loaded.   *)
  105.  
  106.    IsNovellActive := ( Regs.AL <> 0 );
  107.  
  108. END   (* IsNovellActive *);
  109.  
  110. (*--------------------------------------------------------------------------*)
  111. (*           IsTimeSharingActive --- Checks if multitasker is active        *)
  112. (*--------------------------------------------------------------------------*)
  113.  
  114. FUNCTION IsTimeSharingActive : BOOLEAN;
  115.  
  116. (*--------------------------------------------------------------------------*)
  117. (*                                                                          *)
  118. (*    Function: IsTimeSharingActive                                         *)
  119. (*                                                                          *)
  120. (*    Purpose:  Checks if multitasker is active                             *)
  121. (*                                                                          *)
  122. (*    Calling Sequence:                                                     *)
  123. (*                                                                          *)
  124. (*       Ts_On := IsTimeSharingActive : BOOLEAN;                            *)
  125. (*                                                                          *)
  126. (*          Ts_On --- TRUE if multitasker is active.                        *)
  127. (*                                                                          *)
  128. (*    Calls:  MsDos                                                         *)
  129. (*                                                                          *)
  130. (*--------------------------------------------------------------------------*)
  131.  
  132. VAR
  133.    Regs : Registers;
  134.  
  135. (*--------------------------------------------------------------------------*)
  136.  
  137. FUNCTION Get_TopView_Screen_Address : BOOLEAN;
  138.  
  139. VAR
  140.    SegS : INTEGER;
  141.    SegO : INTEGER;
  142.  
  143. BEGIN (* Get_TopView_Screen_Address *)
  144.  
  145.    Regs.Di := 0;
  146.    Regs.Ax := $FE00;
  147.    Regs.Es := SEG( DesqView_Screen^ );
  148.  
  149.    SegO    := 0;
  150.    SegS    := Regs.Es;
  151.  
  152.    INTR( $10 , Regs );
  153.  
  154.    DesqView_Screen := PTR( Regs.Es , Regs.Di );
  155.  
  156.    Get_TopView_Screen_Address := ( ( Regs.Es <> SegS ) OR ( Regs.Di <> SegO ) );
  157.  
  158. END   (* Get_TopView_Screen_Address *);
  159.  
  160. (*--------------------------------------------------------------------------*)
  161.  
  162. BEGIN (* IsTimeSharingActive *)
  163.                                    (* Assume timesharing not active *)
  164.    IsTimeSharingActive := FALSE;
  165.    MultiTasker         := MultiTasker_None;
  166.  
  167.                                    (* Determine if color or mono screen *)
  168.    Regs.Ax := 15 SHL 8;
  169.    INTR( $10 , Regs );
  170.                                    (* Get initial screen address    *)
  171.    IF ( Regs.AL <> 7 ) THEN
  172.       DesqView_Screen := PTR( Color_Screen_Address , 0 )
  173.    ELSE
  174.       DesqView_Screen := PTR( Mono_Screen_Address  , 0 );
  175.  
  176.                                    (* If Novell network not active, *)
  177.                                    (* check if DoubleDos is active. *)
  178.    IF ( NOT IsNovellActive ) THEN
  179.       BEGIN
  180.                                    (* If DDos is active, $E4 should *)
  181.                                    (* return a non-zero value in Al *)
  182.          Regs.Ax := $E400;
  183.  
  184.          MsDos( Regs );
  185.  
  186.          IF ( Regs.Al <> 0 ) THEN
  187.             BEGIN
  188.                IsTimeSharingActive := TRUE;
  189.                MultiTasker         := DoubleDos;
  190.                EXIT;
  191.             END;
  192.  
  193.       END;
  194.                                    (* See if DesqView is active.        *)
  195.                                    (* We do a time/date call with       *)
  196.                                    (* DESQ as date.  If DesqView is     *)
  197.                                    (* active, this will be accepted.    *)
  198.                                    (* If not, it returns as invalid.    *)
  199.                                    (* While we're at it, get the        *)
  200.                                    (* display buffer address, which     *)
  201.                                    (* never changes.                    *)
  202.                                    (*                                   *)
  203.                                    (* NOTE:  Newer versions of TaskView *)
  204.                                    (*        also accept this DesqView  *)
  205.                                    (*        call, so we must check the *)
  206.                                    (*        TopView number to differ-  *)
  207.                                    (*        entiate them.              *)
  208.    Regs.Ax := $2B01;
  209.    Regs.Cx := $4445;  (*'DE'*)
  210.    Regs.Dx := $5351;  (*'SQ'*)
  211.    MsDos( Regs );
  212.  
  213.    IF ( Regs.Al <> $FF ) THEN
  214.       IF Get_TopView_Screen_Address THEN
  215.          BEGIN
  216.  
  217.             IsTimeSharingActive := TRUE;
  218.  
  219.                                    (* Distinguish TaskView from TopView *)
  220.             Regs.Ax := $1022;
  221.             Regs.Bx := 0;
  222.             INTR( $15 , Regs );
  223.  
  224.             IF ( Regs.Bx = 1 ) THEN
  225.                MultiTasker         := TaskView
  226.             ELSE
  227.                MultiTasker         := DesqView;
  228.  
  229.             EXIT;
  230.  
  231.          END;
  232.                                    (* Check for TaskView or TopView.  We do   *)
  233.                                    (* a request for a TopView version number. *)
  234.                                    (* If BX comes back $0001, this must be    *)
  235.                                    (* TaskView.  Anything non-zero indicates  *)
  236.                                    (* TopView or a compatible program.        *)
  237.                                    (* Note:  This catches older TaskView      *)
  238.                                    (*        versions which don't understand  *)
  239.                                    (*        the DesqView call.               *)
  240.    Regs.Ax := $1022;
  241.    Regs.Bx := 0;
  242.    INTR( $15 , Regs );
  243.  
  244.    IF ( Regs.Bx <> 0 ) THEN
  245.       BEGIN
  246.  
  247.          IF ( Regs.Bx = 1 ) THEN
  248.             MultiTasker         := TaskView
  249.          ELSE
  250.             MultiTasker         := TopView;
  251.  
  252.          IF ( NOT Get_TopView_Screen_Address ) THEN
  253.             MultiTasker := Multitasker_None
  254.          ELSE
  255.             IsTimeSharingActive := TRUE;
  256.  
  257.       END;
  258.  
  259. END   (* IsTimeSharingActive *);
  260.  
  261. (*--------------------------------------------------------------------------*)
  262. (*    TurnOnTimeSharing --- allow timesharing to proceed                    *)
  263. (*--------------------------------------------------------------------------*)
  264.  
  265. PROCEDURE TurnOnTimeSharing;
  266.  
  267. (*--------------------------------------------------------------------------*)
  268. (*                                                                          *)
  269. (*    Procedure:  TurnOnTimeSharing;                                        *)
  270. (*                                                                          *)
  271. (*    Purpose:    Activates timesharing                                     *)
  272. (*                                                                          *)
  273. (*    Calling Sequence:                                                     *)
  274. (*                                                                          *)
  275. (*       TurnOnTimeSharing;                                                 *)
  276. (*                                                                          *)
  277. (*    Calls:  MsDos                                                         *)
  278. (*                                                                          *)
  279. (*--------------------------------------------------------------------------*)
  280.  
  281. VAR
  282.    Regs : Registers;
  283.  
  284. BEGIN (* TurnOnTimeSharing *)
  285.  
  286.    CASE MultiTasker OF
  287.                                    (* If DDos is active, $EB turns  *)
  288.                                    (* on timesharing                *)
  289.       DoubleDos:   BEGIN
  290.                       Regs.Ax := $EB00;
  291.                       MsDos( Regs );
  292.                    END;
  293.  
  294.                                    (* Int 15H for TopView family products *)
  295.       DesqView,
  296.       TopView,
  297.       MSWindows,
  298.       TaskView:    BEGIN
  299.                       Regs.Ax := $101C;
  300.                       INTR( $15 , Regs );
  301.                    END;
  302.  
  303.       ELSE;
  304.  
  305.    END (* CASE *);
  306.  
  307. END   (* TurnOnTimeSharing *);
  308.  
  309. (*--------------------------------------------------------------------------*)
  310. (*        TurnOffTimeSharing --- suspend timesharing under DoubleDos        *)
  311. (*--------------------------------------------------------------------------*)
  312.  
  313. PROCEDURE TurnOffTimeSharing;
  314.  
  315. (*--------------------------------------------------------------------------*)
  316. (*                                                                          *)
  317. (*    Procedure:  TurnOffTimeSharing;                                       *)
  318. (*                                                                          *)
  319. (*    Purpose:    Suspends timesharing                                      *)
  320. (*                                                                          *)
  321. (*    Calling Sequence:                                                     *)
  322. (*                                                                          *)
  323. (*       TurnOffTimeSharing;                                                *)
  324. (*                                                                          *)
  325. (*    Calls:  MsDos                                                         *)
  326. (*                                                                          *)
  327. (*--------------------------------------------------------------------------*)
  328.  
  329. VAR
  330.    Regs : Registers;
  331.  
  332. BEGIN (* TurnOffTimeSharing *)
  333.  
  334.    CASE MultiTasker OF
  335.                                    (* If DDos is active, $EA suspends *)
  336.                                    (* timesharing                     *)
  337.       DoubleDos:   BEGIN
  338.                       Regs.Ax := $EA00;
  339.                       MsDos( Regs );
  340.                    END;
  341.                                    (* Int 15H for TopView family products *)
  342.       DesqView,
  343.       TopView,
  344.       MSWindows,
  345.       TaskView:    BEGIN
  346.                       Regs.Ax := $101B;
  347.                       INTR( $15 , Regs );
  348.                    END;
  349.  
  350.      ELSE;
  351.  
  352.    END (* CASE *);
  353.  
  354. END   (* TurnOffTimeSharing *);
  355.  
  356. (*--------------------------------------------------------------------------*)
  357. (*            GiveUpTime --- gives away time slices to other task           *)
  358. (*--------------------------------------------------------------------------*)
  359.  
  360. PROCEDURE GiveUpTime( NSlices : INTEGER );
  361.  
  362. (*--------------------------------------------------------------------------*)
  363. (*                                                                          *)
  364. (*    Procedure:  GiveUpTime;                                               *)
  365. (*                                                                          *)
  366. (*    Purpose:    Gives away time slices to other tasks                     *)
  367. (*                                                                          *)
  368. (*    Calling Sequence:                                                     *)
  369. (*                                                                          *)
  370. (*       GiveUpTime( NSlices :  INTEGER );                                  *)
  371. (*                                                                          *)
  372. (*          NSlices --- # of slices (55 ms) to give away, if DoubleDos.     *)
  373. (*                                                                          *)
  374. (*    Calls:  MsDos                                                         *)
  375. (*                                                                          *)
  376. (*--------------------------------------------------------------------------*)
  377.  
  378. VAR
  379.    Regs : Registers;
  380.  
  381. BEGIN (* GiveUpTime *)
  382.  
  383.    IF ( TimeSharingActive AND ( NSlices > 0 ) ) THEN
  384.       CASE MultiTasker OF
  385.                                    (* Function EE gives time to other part. *)
  386.          DoubleDos:   BEGIN
  387.                          Regs.Ah := $EE;
  388.                          Regs.Al := NSlices;
  389.                          MsDos( Regs );
  390.                       END;
  391.  
  392.          DesqView,
  393.          TopView,
  394.          MSWindows,
  395.          TaskView:    BEGIN
  396.                          INLINE(
  397.                                  $B8/$00/$10 { MOV     AX,$1000 ;Give up time}
  398.                                  /$CD/$15    { INT     $15}
  399.                                );
  400.                       END;
  401.  
  402.          ELSE;
  403.  
  404.       END;
  405.  
  406. END   (* GiveUpTime *);
  407.  
  408. (*--------------------------------------------------------------------------*)
  409. (*    Sync_Screen --- Synchronizes multitasker screen with hardware screen  *)
  410. (*--------------------------------------------------------------------------*)
  411.  
  412. PROCEDURE Sync_Screen( S_Pos: INTEGER; NChars : INTEGER );
  413.  
  414. (*--------------------------------------------------------------------------*)
  415. (*                                                                          *)
  416. (*    Procedure:  Sync_Screen;                                              *)
  417. (*                                                                          *)
  418. (*    Purpose:    Synchronizes multitasker and hardware screens             *)
  419. (*                                                                          *)
  420. (*    Calling Sequence:                                                     *)
  421. (*                                                                          *)
  422. (*       Sync_Screen( S_Pos : INTEGER; NChars: INTEGER );                   *)
  423. (*                                                                          *)
  424. (*    Calls:  INTR                                                          *)
  425. (*                                                                          *)
  426. (*    Remarks:                                                              *)
  427. (*                                                                          *)
  428. (*       This facility is required by the TopView-family products.          *)
  429. (*                                                                          *)
  430. (*--------------------------------------------------------------------------*)
  431.  
  432. BEGIN (* Sync_Screen *)
  433.  
  434.    IF ( NChars > 0 ) THEN
  435.       IF Write_Screen_Memory THEN
  436.          IF ( MultiTasker = TopView ) THEN
  437.             BEGIN
  438.  
  439. INLINE(
  440.   $55/                      {         PUSH    BP                      ;Save BP in case of clobber}
  441.   $C4/$3E/>DESQVIEW_SCREEN/ {         LES     DI,[>DesqView_Screen]   ;Pick up screen address}
  442.   $8B/$8E/>NCHARS/          {         MOV     CX,[BP+>NChars]         ;Get update length in bytes}
  443.   $8B/$86/>S_POS/           {         MOV     AX,[BP+>S_Pos]          ;Get offset of area to update}
  444.   $01/$F8/                  {         ADD     AX,DI                   ;Add to offset of screen memory}
  445.   $89/$C7/                  {         MOV     DI,AX                   ;Starting address of update}
  446.   $B4/$FF/                  {         MOV     AH,$FF                  ;TopView synchronize screen}
  447.   $CD/$10/                  {         INT     $10                     ;Video interrupt}
  448.   $5D);                     {         POP     BP                      ;Restore BP}
  449.  
  450.             END;
  451.  
  452. END   (* Sync_Screen *);
  453.  
  454. (*--------------------------------------------------------------------------*)
  455. (* Sync_Entire_Screen --- Synchronizes multitasker screen with hardware     *)
  456. (*--------------------------------------------------------------------------*)
  457.  
  458. PROCEDURE Sync_Entire_Screen;
  459.  
  460. (*--------------------------------------------------------------------------*)
  461. (*                                                                          *)
  462. (*    Procedure:  Sync_Entire_Screen;                                       *)
  463. (*                                                                          *)
  464. (*    Purpose:    Synchronizes multitasker and hardware screens             *)
  465. (*                                                                          *)
  466. (*    Calling Sequence:                                                     *)
  467. (*                                                                          *)
  468. (*       Sync_Entire_Screen;                                                *)
  469. (*                                                                          *)
  470. (*    Calls:  INTR                                                          *)
  471. (*                                                                          *)
  472. (*    Remarks:                                                              *)
  473. (*                                                                          *)
  474. (*       This facility is used by the TopView-family products when the      *)
  475. (*       entire screen has been updated.                                    *)
  476. (*                                                                          *)
  477. (*--------------------------------------------------------------------------*)
  478.  
  479. BEGIN (* Sync_Entire_Screen *)
  480.  
  481.    IF Write_Screen_Memory THEN
  482.       IF ( MultiTasker  = TopView ) THEN
  483.          BEGIN
  484.  
  485.             INLINE(
  486.   $55                       { PUSH    BP                    ;Save BP in case of clobber}
  487.   /$C4/$3E/>DESQVIEW_SCREEN { LES     DI,[>DesqView_Screen] ;Pick up screen address}
  488.   /$8B/$0E/>SCREEN_LENGTH   { MOV     CX,[>Screen_Length]   ;Get update length in bytes}
  489.   /$D1/$E9                  { SHR     CX,1                  ;Update length in words}
  490.   /$B4/$FF                  { MOV     AH,$FF                ;TopView synchronize screen}
  491.   /$CD/$10                  { INT     $10                   ;Video interrupt}
  492.   /$5D                      { POP     BP                    ;Restore BP}
  493.                   );
  494.  
  495.          END;
  496.  
  497. END   (* Sync_Entire_Screen *);
  498.  
  499. END   (* PibMTask *).
  500.