In this article, we will address two new system services used by the HELP CUSP code in the previous article. VMS has a set of services called SMG (Screen Management). SMG provides an abstraction away from various DEC terminals, such as VT100, VT220, VT320, VT420, and the VT500 series. We won't be replicating SMG for UOS because SMG is older technology associated with character-cell monofont devices. Instead, UOS has DMG services (Display Management) which supports HTML text and graphics, as well as character cell terminals. In the future, we may write a few SMG wrappers to the DMG services, but I think that trying to create an entire working SMG service is next to pointless since it is oriented to archaic technology; trying to generalize it fully to DMG is a waste of time.

const Max_Key_Mapping = 49 ;

const Key_Mapping : array[ 0..Max_Key_Mapping, 0..1 ] of string =
          (
            ( 'A', 'UP' ),
            ( '[A', 'UP' ),
            ( 'OA', 'UP' ),
            ( 'B', 'DOWN' ),
            ( '[B', 'DOWN' ),
            ( 'OB', 'DOWN' ),
            ( 'C', 'RIGHT' ),
            ( '[C', 'RIGHT' ),
            ( 'OC', 'RIGHT' ),
            ( 'D', 'LEFT' ),
            ( '[D', 'LEFT' ),
            ( 'OD', 'LEFT' ),
            ( 'OP', 'PF1' ),
            ( 'OQ', 'PF2' ),
            ( 'OR', 'PF3' ),
            ( 'OS', 'PF4' ),
            ( '[1~', 'HOME' ), // FIND
            ( '[2~', 'INSERT' ), // INSERT HERE
            ( '[3~', 'DELETE' ), // REMOVE
            ( '[4~', 'SELECT' ),
            ( '[5~', 'PAGEUP' ), // PREV SCREEN
            ( '[6~', 'PAGEDOWN' ), // NEXT SCREEN
            ( '[7~', 'HOME' ),
            ( '[H', 'HOME' ),
            ( '[8~', 'END' ),
            ( '[10~', 'F0' ),
            ( '[11~', 'F1' ), // HOLD
            ( '[1P', 'F1' ),
            ( '[12~', 'F2' ), // PRINT
            ( '[1Q', 'F2' ),
            ( '[13~', 'F3' ), // SETUP
            ( '[1R', 'F3' ),
            ( '[14~', 'F4' ), // SESSION
            ( '[1S', 'F4' ),
            ( '[15~', 'F5' ), // BREAK
            ( '[17~', 'F6' ),
            ( '[18~', 'F7' ),
            ( '[19~', 'F8' ),
            ( '[20~', 'F9' ),
            ( '[21~', 'F10' ),
            ( '[23~', 'F11' ), // ESC
            ( '[24~', 'F12' ), // BS
            ( '[25~', 'F13' ), // LF
            ( '[26~', 'F14' ),
            ( '[28~', 'F15' ), // HELP
            ( '[29~', 'F16' ), // DO
            ( '[31~', 'F17' ),
            ( '[32~', 'F18' ),
            ( '[33~', 'F19' ),
            ( '[34~', 'F20' )
          ) ;

function DMG_Get_Key( SRB, Res, Len : int64 ) : int64 ; 

var S, S1, S2 : string ;
    I : int64 ;
    L : integer ;
    U : TUnicode_String ;

begin // DMG_Get_Key
    Result := 0 ;
    S := Get_String( PSRB( SRB )^ ) ;
    if( length( S ) = 0 ) then // Null string
    begin
        if( Len <> 0 ) then
        begin
            PInt64( Len )^ := 0 ;
        end ;
        Write_User( '' ) ;
        exit ;
    end ;

    if( copy( S, 1, 1 ) = ESC ) then // Possible escape sequence
    begin
        for L := 0 to Max_Key_Mapping do
        begin
            S1 := Key_Mapping[ L, 0 ] ;
            S2 := Key_Mapping[ L, 1 ] ;
            if( copy( S, 2, length( S1 ) ) = S1 ) then
            begin
                S := S2 ;
                if( Len <> 0 ) then
                begin
                    PInt64( Len )^ := length( S1 ) + 1 ;
                end ;
                Write_User( S ) ;
                exit ;
            end ;
        end ;
    end ;

    // Next character is simply the first character of the string...
    U := TUnicode_String.Create ;
    U.Assign_From_String( S, TT_UTF8 ) ;
    U.Length := 1 ;
    S := U.As_String( TT_UTF8 ) ;
    Write_User( S ) ;
    U.Free ;
    if( Len <> 0 ) then
    begin
        PInt64( Len )^ := length( S ) ;
    end ;
end ; // DMG_Get_Key

    procedure Write_User( S : string ) ;

    begin
        if( Res <> 0 ) then
        begin
            if( PSRB( Res )^.Length < length( S ) ) then
            begin
                setlength( S, PSRB( Res )^.Length ) ;
                Result := UOSErr_Buffer_Overflow ;
            end ;
            PSRB( Res )^.Length := length( S ) ;
            if( PSRB( Res )^.Buffer <> 0 ) then
            begin
                move( PChar( S )[ 0 ], PChar( PSRB( Res )^.Buffer )[ 0 ], length( S ) ) ;
            end ;
        end ;
    end ;

function Get_Key( S : string ) : string ;

var Res : TSRB ;
    SRB : TSRB ;
    R : string ;

begin
    Set_String( S, SRB ) ;
    R := S ;
    Set_String( R, Res ) ;
    DMG_Get_Key( int64( @SRB ), int64( @Res ), 0 ) ;
end ;

The next service, Put_Formatted_Output, is used to write HTML text. As we discussed in a past article, there is raw output and cooked output. Raw output is that processed by the terminal (or other output device) itself. Cooked output is handled by the terminal driver in the FIP, which takes care of various translations required to make output look correct on terminals with less features (such as using spaces to simulate tabs). The Put_Output service simply passes text on to the terminal driver.

Put_Formatted_Output, however, is another level of output data cooking that handles converting HTML tags into the appropriate mechanism to best represent the HTML on the output device. For terminals that can only handle plain text, this service will convert the HTML to plain text. On other terminals, special effects may be applied based on the HTML tags. On a PC screen, the HTML is rendered exactly. On some printers, the data may be converted to Postscript. This service does the necessary work and then passes the modified text/commands on to the output device. You can think of this as three layers in the process of cooking output: Put_Formatted_Output passes processed (cooked) text on to the terminal driver via Put_Output. The terminal driver then further processes the text and passes it on to the physical output device.

Most output should be done via Put_Formatted_Output. However, if you want raw output, Put_Output should be used instead. When would raw output be used? This might be used for a terminal that has special processing of output and UOS has no filter for that terminal. In that case, the program would have to make use of the features for that specific device. In fact, this is what an output filter does. Filters will be discussed in the future.

function LIB_Put_Formatted_Output( F, SRB : int64 ) : int64 ;

var Fil : TCOM_UOS_File ;
    S : string ;

begin
    // Setup...
    Result := 0 ;
    Fil := TCOM_UOS_File( pointer( F ) ) ;
    S := Get_String( PSRB( pointer( SRB ) )^ ) ;

    //TODO: For now, we do plain text output...
    S := From_HTML( S, -1 ) ;

    //TODO: For now, convert to ASCII...
    U := TUnicode_String.Create ;
    U.Assign_From_String( D, TT_UTF8 ) ;
    S := U.As_String( TT_ASCII7 ) ;
    U.Free ;

    // Write string...
    Fil.Write( S ) ;
    UEC := Fil.Get_IO_Error ;
    if( UEC <> nil ) then
    begin
        Result := UEC.Get_Error ;
    end ;
end ;

function Put_Formatted_Output( F : TCOM_UOS_File ; const S : string ) : int64 ;

var P : string ;
    SRB : TSRB ;

begin
    P := S ;
    Set_String( P, SRB ) ;
    Result := LIB_Put_Formatted_Output( int64( @F ), int64( @SRB ) ) ;
end ;