<<>>
    <<VTablesImpl.mesa>>
        <<Copyright Ó 1985, 1987, 1992 by Xerox Corporation.  All rights reserved.>>
        <<created by Russ Atkinson>>
        <<Doug Wyatt, January 21, 1987 11:19:49 pm PST>>
        <<Russ Atkinson (RRA) March 12, 1987 6:14:46 pm PST>>

        DIRECTORY
            Buttons USING [Button, ButtonProc, Create, SetDisplayStyle], 
            Imager USING [black, MaskBox, SetColor],
            Labels USING [Create, SetDisplayStyle], 
            Rope USING  [Flatten, ROPE, Size],
            RuntimeError USING [BoundsFault], 
            VFonts USING [defaultFont, Font, FontHeight, StringWidth],
            ViewerClasses USING [DestroyProc, PaintProc, Viewer, ViewerClass, ViewerClassRec], 
            ViewerOps USING [BlinkViewer, CreateViewer, DestroyViewer, EstablishViewerPosition, PaintViewer, RegisterViewerClass], 
            VTables USING [Border, FullBorder, NullBorder, VTable];

    VTablesImpl: CEDAR MONITOR LOCKS data USING data: TableData
        IMPORTS Buttons, Imager, Labels, Rope, RuntimeError, VFonts, ViewerOps
        EXPORTS VTables
        = BEGIN OPEN VTables;

        ROPE: TYPE = Rope.ROPE;
        Viewer: TYPE = ViewerClasses.Viewer;

        TableData: TYPE = REF TableDataRep; 
        TableDataRep: TYPE = MONITORED RECORD  [
            rows, columns: NAT Ź 0, 
            installed, locked, staticSize: BOOL Ź FALSE, 
            live: BOOL Ź TRUE, 
            condition: CONDITION, 
            xRuleWidth: INTEGER Ź 1, 
            yRuleWidth: INTEGER Ź 1, 
            rowWidths: WidthSeq Ź NIL, 
            colWidths: WidthSeq Ź NIL, 
            width: INTEGER Ź 0, 
            height: INTEGER Ź 0,
            request: INTEGER Ź 0, 
            rowSeq: RowSeq]; 

        RowSeq: TYPE = REF RowSeqRep;
        RowSeqRep: TYPE = RECORD [
            rowData: SEQUENCE nRows: NAT OF RowData];

        RowData: TYPE = REF RowDataRep; 
        RowDataRep: TYPE = RECORD [colData: SEQUENCE nCols: NAT OF Entry]; 
        Entry: TYPE = RECORD [
            border: Border, useMaxSize: BOOL,
            xoff,yoff: Offset, viewer: Viewer] Ź NullEntry;
        NullEntry: Entry = [NullBorder, TRUE, 0, 0, NIL];
        Offset: TYPE = INTEGER;

        textXoff: Offset Ź 4;  -- hack for $Text x offset
        textYoff: Offset Ź 1;  -- hack for $Text y offset

        wHack: INTEGER Ź 12;  -- hack for entry size calculated by text
        hHack: INTEGER Ź 3;  -- hack for entry size calculated by text

        WidthSeq: TYPE = REF WidthSeqRep; 
        WidthSeqRep: TYPE = RECORD [widths: SEQUENCE size: NAT OF INTEGER]; 

        AcquireLock: ENTRY PROC [data: TableData, painting: BOOL Ź FALSE] RETURNS [BOOL] = {
            <<acquire the lock on the data; if requireInstalled then we wait for installation as well; return the live flag; if FALSE is 
            returned, the lock is not held>>
            ENABLE UNWIND => NULL;
            IF data # NIL THEN WHILE data.live DO
                IF painting AND NOT data.installed THEN {data.request Ź data.request + 1; EXIT};
                IF NOT data.locked THEN {data.locked Ź TRUE; RETURN [TRUE]};
                WAIT data.condition;
                ENDLOOP;
            RETURN [FALSE];
            };

        ReleaseLock: ENTRY PROC [data: TableData, installed: BOOL] = {
            <<release the data lock; if install, then set the installed flag as well; then notify everyone else that the world is OK>>
            data.locked Ź FALSE;
            data.installed Ź installed;
            BROADCAST data.condition;
            };

        SetInstalled: ENTRY PROC [data: TableData, installed: BOOL] = {
            data.installed Ź installed;
            BROADCAST data.condition;
            };

        NewRowSeq: PROC [rows,columns: NAT] RETURNS [RowSeq] = {
            rowSeq: RowSeq Ź NEW[RowSeqRep[rows]];
            FOR i: NAT IN [0..rows) DO 
                rowSeq[i] Ź NEW[RowDataRep[columns]]
                ENDLOOP;
            RETURN [rowSeq];
            };

        NewWidthSeq: PROC [width: NAT] RETURNS [ws: WidthSeq] = {
            ws Ź NEW[WidthSeqRep[width]]; 
            FOR i: NAT IN [0..width) DO 
                ws[i] Ź 0
                ENDLOOP
            }; 

        RecalculateWidths: PROC [data: TableData] = {
            rowWidths: WidthSeq Ź data.rowWidths;
            colWidths: WidthSeq Ź data.colWidths;
            FOR row: NAT IN [0..data.rows) DO
                rowWidths[row] Ź 0;
                FOR col: NAT IN [0..data.columns) DO
                    ent: Entry Ź data.rowSeq[row][col];
                    v: Viewer Ź ent.viewer;
                    IF row = 0 THEN colWidths[col] Ź 0;
                    IF v # NIL THEN {
                        w: INTEGER Ź v.ww + ABS[ent.xoff];
                        h: INTEGER Ź v.wh + ABS[ent.yoff];
                        IF w > colWidths[col] THEN colWidths[col] Ź w;
                        IF h > rowWidths[row] THEN rowWidths[row] Ź h;
                        };
                    ENDLOOP;
                ENDLOOP;
            };

        Create: PUBLIC PROC [
        columns, rows: INTEGER Ź 1, name: ROPE Ź NIL, parent: Viewer Ź NIL,
        xRuleWidth: INTEGER Ź 1, yRuleWidth: INTEGER Ź 1,
        x, y, w, h: INTEGER Ź 0, scrollable: BOOL Ź FALSE]
        RETURNS [table: VTable Ź NIL] = TRUSTED {
            data: TableData Ź NEW[TableDataRep];
            IF columns <= 0 OR rows <= 0 THEN RETURN [NIL]; 
            IF name = NIL THEN name Ź " "; 
            data.rows Ź rows;
            data.columns Ź columns;
            data.rowSeq Ź NewRowSeq[rows, columns];
            data.rowWidths Ź NewWidthSeq[rows];
            data.colWidths Ź NewWidthSeq[columns]; 
            data.xRuleWidth Ź xRuleWidth; 
            data.yRuleWidth Ź yRuleWidth;
            data.staticSize Ź w > 0 OR h > 0;
            data.width Ź w;
            data.height Ź h; 
            IF parent = NIL THEN
                parent Ź 
                    ViewerOps.CreateViewer [
                        flavor: $Container,
                        info: [name: name, column: right, iconic: TRUE],
                        paint: TRUE]; 
            table Ź 
                ViewerOps.CreateViewer [
                    flavor: $VTable,
                    info: [
                        name: name, parent: parent, wx: x, wy: y, ww: w, 
                        wh: h, data: data, border: FALSE, scrollable: scrollable],
                    paint: FALSE]
            }; 

        SetRowsAndColumns: PUBLIC PROC [table: VTable, rows, columns: NAT Ź 0] = TRUSTED {
            <<sets the number of rows and columns; can be used to either grow or shrink the table>>
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                IF rows # data.rows OR columns # data.columns THEN {
                    ENABLE UNWIND => ReleaseLock[data, FALSE];
                    newRowSeq: RowSeq Ź NewRowSeq[rows, columns];
                    SetInstalled[data, FALSE];
                    IF rows # data.rows THEN {
                        newRowWidths: WidthSeq Ź NewWidthSeq[rows];
                        FOR i: NAT IN [0..MIN[rows, data.rows]) DO
                            newRowWidths[i] Ź data.rowWidths[i];
                            ENDLOOP;
                        data.rowWidths Ź newRowWidths;
                        };
                    IF columns # data.columns THEN {
                        newColWidths: WidthSeq Ź NewWidthSeq[columns];
                        FOR i: NAT IN [0..MIN[columns, data.columns]) DO
                            newColWidths[i] Ź data.colWidths[i];
                            ENDLOOP;
                        data.colWidths Ź newColWidths;
                        };
                    FOR row: NAT IN [0..data.rows) DO
                        FOR col: NAT IN [0..data.columns) DO
                            oldEntry: Entry Ź data.rowSeq[row][col];
                            IF row < rows AND col < columns
                                THEN {
                                    <<copy the entry (if any) from the old world>>
                                    newRowSeq[row][col] Ź oldEntry;
                                    }
                                ELSE {
                                    <<delete the old viewer>>
                                    IF oldEntry.viewer # NIL THEN
                                        ViewerOps.DestroyViewer[oldEntry.viewer, FALSE];
                                    };
                            ENDLOOP;
                        ENDLOOP;
                    data.rows Ź rows;
                    data.columns Ź columns;
                    data.rowSeq Ź newRowSeq;  -- make this the last gasp
                    };
                ReleaseLock[data, data.installed];
                };
            };  

        Install: PUBLIC PROC [table: VTable, paint: BOOL Ź TRUE] = TRUSTED {
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                ENABLE UNWIND => ReleaseLock[data, FALSE];
                rows: NAT Ź data.rows; 
                columns: NAT Ź data.columns; 
                minX: INTEGER Ź 0; 
                minY: INTEGER Ź 0; 
                maxX: INTEGER Ź minX; 
                maxY: INTEGER Ź minY; 
                xRule: CARDINAL Ź data.xRuleWidth; 
                yRule: CARDINAL Ź data.yRuleWidth; 
                rowWidths: WidthSeq Ź data.rowWidths; 
                colWidths: WidthSeq Ź data.colWidths;
                w: INTEGER Ź table.ww;
                h: INTEGER Ź table.wh;

                RecalculateWidths[data];

                <<determine the row spacing>>
                minY Ź xRule; 
                FOR i: NAT IN [0..rows) DO 
                    row: RowData Ź data.rowSeq[i]; 
                    rowWidth: INTEGER Ź rowWidths[i];
                    minX Ź yRule; 
                    FOR j: NAT IN [0..columns) DO 
                        e: Entry Ź row[j]; 
                        v: Viewer Ź e.viewer; 
                        colWidth: INTEGER Ź colWidths[j];
                        IF v # NIL THEN {
                            vw: INTEGER Ź v.ww;
                            vh: INTEGER Ź v.wh;
                            IF e.useMaxSize THEN {
                                vw Ź colWidth-ABS[e.xoff];
                                vh Ź rowWidth-ABS[e.yoff];
                                }; 
                            ViewerOps.EstablishViewerPosition[v, minX+e.xoff, minY+e.yoff, vw, vh];
                            };
                        minX Ź minX + colWidth + yRule
                        ENDLOOP; 
                    minY Ź minY + rowWidth + xRule
                    ENDLOOP; 
                data.width Ź minX;   
                data.height Ź minY;
                IF NOT data.staticSize THEN {
                    w Ź data.width; h Ź data.height}; 
                ViewerOps.EstablishViewerPosition[table, table.wx, table.wy, w, h]; 
                ReleaseLock[data, TRUE];
                IF paint OR data.request # 0 THEN ViewerOps.PaintViewer[table, client];
                };
            }; 

        GetTableEntry: PUBLIC PROC [table: VTable, row, column: NAT Ź 0]
        RETURNS [v: Viewer Ź NIL] = TRUSTED {
            <<retrieve the viewer at the given row and column>>
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                IF row >= data.rows OR column >= data.columns THEN ReleaseAndFault[data];
                v Ź data.rowSeq[row][column].viewer;
                ReleaseLock[data, data.installed];
                };
            }; 

        SwapTableEntries: PUBLIC PROC
        [table: VTable, row1, column1, row2, column2: NAT Ź 0, swapBorders: BOOL Ź FALSE]
        = TRUSTED {
            <<swap the given table entries>>
            data: TableData Ź NARROW[table.data];
            v: Viewer Ź NIL;
            IF data # NIL AND AcquireLock[data] THEN {
                IF row1 >= data.rows OR column1 >= data.columns
                OR row2 >= data.rows OR column2 >= data.columns THEN
                    ReleaseAndFault[data];
                {
                    e1: Entry Ź data.rowSeq[row1][column1];
                    e2: Entry Ź data.rowSeq[row2][column2];
                    IF swapBorders
                        THEN {
                            data.rowSeq[row1][column1] Ź e2;
                            data.rowSeq[row2][column2] Ź e1}
                        ELSE {
                            data.rowSeq[row1][column1].viewer Ź e2.viewer;
                            data.rowSeq[row2][column2].viewer Ź e1.viewer}};
                ReleaseLock[data, FALSE];
                };
            }; 

        SetTableEntry: PUBLIC PROC [
        table: VTable, row, column: NAT Ź 0,
        name: ROPE Ź NIL, flavor: ATOM Ź NIL,
        proc: Buttons.ButtonProc Ź NIL, clientData: REF Ź NIL,
        w, h: INTEGER Ź 0, xoff, yoff: INTEGER Ź 0,
        border: Border Ź FullBorder, font: VFonts.Font Ź NIL,
        displayStyle: ATOM Ź NIL, useMaxSize: BOOL Ź FALSE] = TRUSTED {
            v: Viewer Ź NIL; 
            parent: Viewer Ź table; 
            data: TableData Ź NARROW[table.data]; 
            flat: ROPE Ź name.Flatten[]; 
            textH, textW: INTEGER Ź 0;
            old: Entry Ź NullEntry;
            new: Entry Ź NullEntry;
            IF data # NIL AND AcquireLock[data] THEN {
                IF row >= data.rows OR column >= data.columns THEN
                    ReleaseAndFault[data];
                old Ź data.rowSeq[row][column];
                IF font = NIL THEN font Ź VFonts.defaultFont;
                IF flat.Size[] # 0 THEN  {
                    textW Ź VFonts.StringWidth[flat, font];
                    textH Ź VFonts.FontHeight[font];
                    };
                SetInstalled[data, FALSE];  -- do this here!
                {
                    ENABLE UNWIND => ReleaseLock[data, FALSE];
                    IF flavor = NIL THEN flavor Ź $Label; 
                    IF proc # NIL THEN flavor Ź $Button;
                    IF name = NIL THEN name Ź "";
                    IF textW > w THEN w Ź textW + wHack;
                    IF textH > h THEN h Ź textH + hHack;
                    new.xoff Ź xoff;
                    new.yoff Ź yoff;
                    new.useMaxSize Ź useMaxSize;
                    SELECT flavor FROM 
                        $Button => {
                            v Ź 
                                Buttons.Create [
                                    info: [name: name, parent: parent, wx: 0, wy: 0, ww: w, wh: h, border: FALSE], 
                                    proc: proc,
                                    clientData: clientData, 
                                    fork: TRUE,
                                    paint: FALSE,
                                    font: font]; 
                            IF displayStyle # NIL THEN
                                Buttons.SetDisplayStyle[v, displayStyle, FALSE];
                            };
                        $Label => {
                            v Ź 
                                Labels.Create [
                                    info: [parent: parent, name: name, wx: 0, wy: 0, ww: w, wh: h, 
                                    border: FALSE], font: font, paint: FALSE]; 
                            IF displayStyle # NIL THEN
                                Labels.SetDisplayStyle[v, displayStyle, FALSE];
                            };
                        $Text => {
                            h Ź h - textYoff; -- make height of text, labels & buttons similar
                            v Ź ViewerOps.CreateViewer [
                                flavor: $Text, 
                                info: [parent: parent, wx: 0, wy: 0, ww: w, wh: h, scrollable: FALSE, border: FALSE],
                                paint: FALSE];
                            v.class.set[v, name, FALSE];
                            new.xoff Ź textXoff + xoff;
                            new.yoff Ź textYoff + yoff;
                            };
                        $Viewer => 
                            WITH clientData SELECT FROM
                                vv: Viewer => v Ź vv;
                                ENDCASE;
                        ENDCASE => 
                            v Ź ViewerOps.CreateViewer [
                                flavor: flavor,
                                info: [name: name, parent: parent, wx: 0, wy: 0, ww: w, wh: h, data: clientData, border: FALSE]]; 
                    IF old.viewer # v AND old.viewer # NIL THEN
                        ViewerOps.DestroyViewer[old.viewer, FALSE]; 
                    new.viewer Ź v;
                    new.border Ź border;
                    data.rowSeq[row][column] Ź new;
                    };
                ReleaseLock[data, FALSE];
                };
            }; 

        GetEntryBorder: PUBLIC PROC [table: VTable, row, column: NAT Ź 0]
        RETURNS [border: Border Ź NullBorder] = {
            <<get the current table entry at the given row and column>>
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                IF row >= data.rows OR column >= data.columns THEN ReleaseAndFault[data];
                border Ź data.rowSeq[row][column].border;
                ReleaseLock[data, data.installed];
                };
            }; 

        SetEntryBorder: PUBLIC PROC
        [table: VTable, row, column: NAT Ź 0, border: Border Ź FullBorder] = {
            <<get the current table entry at the given row and column>>
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                IF row >= data.rows OR column >= data.columns THEN ReleaseAndFault[data];
                data.rowSeq[row][column].border Ź border;
                ReleaseLock[data, FALSE];
                };
            }; 

        GetEntryOffset: PUBLIC PROC [table: VTable, row, column: NAT Ź 0]
        RETURNS [xoff,yoff: INTEGER Ź 0] = {
            <<get the current offsets of the given entry>>
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                IF row >= data.rows OR column >= data.columns THEN ReleaseAndFault[data];
                xoff Ź data.rowSeq[row][column].xoff;
                yoff Ź data.rowSeq[row][column].yoff;
                ReleaseLock[data, data.installed];
                };
            }; 

        SetEntryOffset: PUBLIC PROC
        [table: VTable, row, column: NAT Ź 0, xoff,yoff: INTEGER Ź 0] = {
            <<set the current table border at the given row and column; reinstallation is required >>
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                IF row >= data.rows OR column >= data.columns THEN ReleaseAndFault[data];
                data.rowSeq[row][column].xoff Ź xoff;
                data.rowSeq[row][column].yoff Ź yoff;
                ReleaseLock[data, FALSE];
                };
            }; 

        GetRowsAndColumns: PUBLIC PROC [table: VTable] RETURNS [rows, columns: NAT Ź 0] = {
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                rows Ź data.rows;
                columns Ź data.columns;
                ReleaseLock[data, data.installed];
                };
            }; 

        ExchangeRows: PUBLIC PROC [table: VTable, row1,row2: NAT Ź 0] = {
            <<exchange the two given rows; reinstallation is required>>
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                IF row1 >= data.rows OR row2 >= data.rows THEN ReleaseAndFault[data];
                {-- exchange the rows
                    temp: RowData Ź data.rowSeq[row1];
                    data.rowSeq[row1] Ź data.rowSeq[row2];
                    data.rowSeq[row2] Ź temp};
                ReleaseLock[data, FALSE];
                };
            };

        ExchangeColumns: PUBLIC PROC [table: VTable, column1,column2: NAT Ź 0] = {
            <<exchange the two given columns; reinstallation is required>>
            data: TableData Ź NARROW[table.data];
            IF data # NIL AND AcquireLock[data] THEN {
                IF column1 >= data.columns OR column2 >= data.columns THEN
                    ReleaseAndFault[data];
                FOR row: NAT IN [0..data.rows) DO
                    temp: Entry Ź data.rowSeq[row][column1];
                    data.rowSeq[row][column1] Ź data.rowSeq[row][column2];
                    data.rowSeq[row][column2] Ź temp;
                    ENDLOOP;
                ReleaseLock[data, FALSE];
                };
            };

        <<paint and destroy procedures>>

        TablePainter: ViewerClasses.PaintProc = TRUSTED {
            <<[self: ViewerClasses.Viewer, context: Imager.Context, whatChanged: REF ANY, clear: BOOL] RETURNS [quit: BOOL _ FALSE]>>
            <<Just paint the rules for the table; the children will be painted after this painting.>>
            table: VTable Ź self;
            WITH self.data SELECT FROM
                data: TableData => IF AcquireLock[data, TRUE] THEN {
                    ENABLE UNWIND => ReleaseLock[data, FALSE];
                    xPos: INTEGER Ź 0;
                    xLim: INTEGER Ź data.width; 
                    yPos: INTEGER Ź 0;
                    yLim: INTEGER Ź data.height; 
                    rows: NAT Ź data.rows; 
                    columns: NAT Ź data.columns; 
                    xWidth: INTEGER Ź data.xRuleWidth; 
                    yWidth: INTEGER Ź data.yRuleWidth;
                    Imager.SetColor[context, Imager.black]; 
                    <<>>
                    <<paint the horizontals>>
                    <<>>
                    FOR row: NAT DECREASING IN [0..rows] DO
                        yLast: INTEGER Ź yPos + xWidth;
                        xPos Ź 0;
                        FOR col: NAT IN [0..columns) DO
                            prev: Border Ź
                                IF row = rows THEN NullBorder ELSE data.rowSeq[row][col].border;
                            this: Border Ź
                                IF row = 0 THEN NullBorder ELSE data.rowSeq[row-1][col].border;
                            xLast: INTEGER Ź xPos + data.colWidths[col] + yWidth;
                            IF prev.down OR this.up THEN {
                                <<include this edge>>
                                Imager.MaskBox[context, [xPos, yPos, xLast+yWidth, yLast]]};
                            xPos Ź xLast;
                            ENDLOOP;
                        IF row = 0 THEN EXIT;
                        yPos Ź yLast + data.rowWidths[row-1];
                        ENDLOOP; 
                    <<>>
                    <<paint the verticals>>
                    <<>>
                    xPos Ź 0;
                    FOR col: NAT IN [0..columns] DO 
                        xLast: INTEGER Ź xPos + yWidth;
                        yPos Ź 0;
                        FOR row: NAT DECREASING IN [0..rows) DO 
                            prev: Border Ź
                                IF col = 0 THEN
                                    NullBorder ELSE
                                    data.rowSeq[row][col-1].border;
                            this: Border Ź
                                IF col = columns
                                    THEN NullBorder
                                    ELSE data.rowSeq[row][col].border;
                            yLast: INTEGER Ź yPos + data.rowWidths[row] + xWidth;
                            IF prev.right OR this.left THEN {
                                <<include this edge>>
                                Imager.MaskBox[context, [xPos, yPos, xLast, yLast + xWidth]]};
                            yPos Ź yLast;
                            ENDLOOP; 
                        IF col = columns THEN EXIT;
                        xPos Ź xLast + data.colWidths[col];
                        ENDLOOP;
                    data.request Ź 0;
                    ReleaseLock[data, TRUE];
                    RETURN [FALSE];
                    };
                ENDCASE;
            RETURN [TRUE];  -- don't try to paint the children!
            }; 

        TableDestroy: ViewerClasses.DestroyProc = {
            <<[self: Viewer]>>
            WITH self.data SELECT FROM
                data: TableData => IF AcquireLock[data] THEN {
                    data.live Ź FALSE;
                    self.data Ź NIL;
                    ReleaseLock[data, FALSE];
                    };
                ENDCASE;
            };

    <<other procedures>>

        MakeViewerClass: PROC = TRUSTED {
            vTableClass: ViewerClasses.ViewerClass Ź NEW[ViewerClasses.ViewerClassRec];
            vTableClass.icon Ź tool; 
            vTableClass.paint Ź TablePainter;
            vTableClass.destroy Ź TableDestroy; 
            vTableClass.topDownCoordSys Ź TRUE; 
            ViewerOps.RegisterViewerClass[$VTable, vTableClass]
            }; 

        ReleaseAndFault: PROC [data: TableData] = TRUSTED {
            ReleaseLock[data, data.installed];
            ERROR RuntimeError.BoundsFault;
            };

        DummyButtonProc: Buttons.ButtonProc = {
            <<[parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]>>
            WITH parent SELECT FROM
                v: ViewerClasses.Viewer => ViewerOps.BlinkViewer[v];
                ENDCASE;
            }; 

        instance: Viewer Ź NIL; 
        TestInstance: PROC [useText: BOOL Ź TRUE] = {
            instance Ź Create[3, 3, "test"]; 
            SetTableEntry[instance, 0, 0, "0-0 button *", $Button, DummyButtonProc]; 
            IF useText THEN
                SetTableEntry[instance, 0, 1, "0-1 text **", $Text]; 
            SetTableEntry[instance, 0, 2, "0-2 label ***"]; 
            SetTableEntry[instance, 1, 0, "1-0 label ****"];
            SetTableEntry[instance, 1, 1, "1-1 button *", $Button, DummyButtonProc]; 
            IF useText THEN
                SetTableEntry[instance, 1, 2, "1-2 text **", $Text]; 
            IF useText THEN
                SetTableEntry[instance, 2, 0, "2-0 text ***", $Text]; 
            SetTableEntry[instance, 2, 1, "2-1 label ****"];
            SetTableEntry[instance, 2, 2, "2-2 button ****", $Button, DummyButtonProc];
            SetEntryBorder[instance, 2, 2, NullBorder]; 
            Install[instance]
            };

        MakeViewerClass[]

        END.