<<>>
    <<XTkXBiScrollerImpl.mesa>>
        <<Copyright Ó 1992, 1993 by Xerox Corporation.  All rights reserved.>>
        <<Created by Christian Jacobi, June 9, 1992 6:45 pm PDT>>
        <<Christian Jacobi, September 17, 1993 10:32 am PDT>>
        <<>>
    DIRECTORY 
        Real,
        Xl,
        XTk,
        XTkBiScrollerFrame,
        XTkFriends,
        XTkXBiScroller,
        XTkXScroller;

    XTkXBiScrollerImpl: CEDAR MONITOR 
        IMPORTS Real, Xl, XTkXScroller, XTkBiScrollerFrame, XTk, XTkFriends
        EXPORTS XTkXBiScroller =
    BEGIN OPEN XTkXBiScroller;

    stateChanged: PUBLIC ATOM Ź $XBiScrollerState;

    xBiScrollerClass: PUBLIC XTk.Class ~ CreateXBiScrollerClass[];
        CreateXBiScrollerClass: PROC [] RETURNS [XTk.Class] = {
            class: XTk.ImplementorClass ~ XTkFriends.CreateClass[[super: XTkBiScrollerFrame.biScrollerFrameClass, key: $xBiScroller, 
            initInstPart: XBiScrollerInitInstPart, wDataNum: 1]];
            RETURN [class];
            };

    CreateXBiScroller: PUBLIC PROC [widgetSpec: XTk.WidgetSpec Ź [], child: XTk.Widget Ź NIL, insideSize: Xl.Size Ź [XTk.dontUse, 
    XTk.dontUse], vsbar, hsbar: BOOL] RETURNS [XBiScroller] = {
        widgetSpec.class Ź XTkFriends.InitClassField[widgetSpec.class, xBiScrollerClass];
        BEGIN
            xBiScroller: XTk.Widget Ź XTkBiScrollerFrame.CreateBiScrollerFrame[widgetSpec, NIL, insideSize, vsbar, hsbar];
            xbsd: XBSData Ź GetXBiScrollerData[xBiScroller];
            IF child#NIL THEN ReplaceChild[xBiScroller, child, TRUE];
            XTkBiScrollerFrame.SetScrollProc[xBiScroller, Scroll];
            XTkXScroller.SetBindXY[xbsd.dummyChild, NOT hsbar, NOT vsbar];
            RETURN [xBiScroller];
            END;
        };

    IsXBiScroller: PUBLIC PROC [widget: XTk.Widget] RETURNS [BOOL] = {
        RETURN [XTk.HasClass[widget, xBiScrollerClass]]
        }; 

    XBSData: TYPE = REF XBSDataRec;
    XBSDataRec: TYPE = RECORD [
        dummyChild: XTk.Widget Ź NIL, --direct child of biscroller, parent of real child
        pos: Xl.Point Ź [0, 0],
        filterPair: REF FilterPair Ź NIL
        ];

    GetXBiScrollerData: PROC [widget: XTk.Widget] RETURNS [XBSData] = INLINE {
        RETURN [ NARROW[XTkFriends.InstPart[widget, xBiScrollerClass]] ];
        };

    XBiScrollerInitInstPart: XTk.InitInstancePartProc = {
        xbsd: XBSData ~ NEW[XBSDataRec Ź []];
        XTkFriends.AssignInstPart[widget, xBiScrollerClass, xbsd];
        xbsd.dummyChild Ź XTkXScroller.CreateXScroller[];
        XTkBiScrollerFrame.ReplaceChild[widget, xbsd.dummyChild];
        XTk.RegisterNotifier[xbsd.dummyChild, XTk.postConfigureLRKey, CheckChildState, widget];
        XTk.RegisterNotifier[xbsd.dummyChild, XTk.postWindowCreationLRKey, CheckChildState, widget];
        };

    GetInnerSize: PROC [w: XTk.Widget] RETURNS [sz: Xl.Size Ź [200, 200]] = {
        IF w#NIL THEN {
            sz.width Ź MIN[MAX[w.actual.size.width, 1], 10000];
            sz.height Ź MIN[MAX[w.actual.size.height, 1], 10000];
            };
        };

    GetOuterSize: PROC [w: XTk.Widget] RETURNS [sz: Xl.Size Ź [200, 200]] = {
        IF w#NIL THEN {
            b: INT Ź MIN[MAX[w.actual.borderWidth, 0], 500];
            sz Ź GetInnerSize[w];
            sz.width Ź sz.width + 2*b;
            sz.height Ź sz.height + 2*b;
            };
        };

    Scroll: XTkBiScrollerFrame.ScrollProc = {
        xBiScroller: XBiScroller ~ biScrollerFrame; <<super>>
        doit: BOOL Ź FALSE;
        xbsd: XBSData ~ GetXBiScrollerData[xBiScroller];
        dummyChild: XTk.Widget Ź xbsd.dummyChild;
        realChild: XTk.Widget Ź XTkXScroller.Child[dummyChild];
        docsz: Xl.Size Ź GetOuterSize[realChild];
        winsz: Xl.Size Ź GetInnerSize[dummyChild];
        p: Xl.Point Ź EntryGetState[xbsd];
        SELECT hAction FROM
            thumb => {
                p.x Ź - Real.Round[x*docsz.width];
                doit Ź TRUE;
                };
            forward => {
                p.x Ź p.x - Real.Round[x*winsz.width];
                doit Ź TRUE;
                };
            backward => {
                p.x Ź p.x + Real.Round[x*winsz.width];
                doit Ź TRUE;
                };
            ENDCASE => {};
        SELECT vAction FROM
            thumb => {
                p.y Ź - Real.Round[y*docsz.height];
                doit Ź TRUE;
                };
            forward => {
                p.y Ź p.y - Real.Round[y*winsz.height];
                doit Ź TRUE;
                };
            backward => {
                p.y Ź p.y + Real.Round[y*winsz.height];
                doit Ź TRUE;
                };
            ENDCASE => {};
        IF doit THEN PublicSetState[xBiScroller, p, event];
        };

    FilterPair: TYPE = RECORD [
        filterProc: FilterProc Ź NIL, 
        filterData: REF Ź NIL
        ];

    SetFilterProc: PUBLIC PROC [xBiScroller: XBiScroller, filterProc: FilterProc, filterData: REF Ź NIL] = {
        xbsd: XBSData ~ GetXBiScrollerData[xBiScroller];
        pair: REF FilterPair Ź NIL;
        IF filterProc#NIL THEN pair Ź NEW[FilterPair Ź [filterProc, filterData]];
        xbsd.filterPair Ź pair
        };

    Child: PUBLIC PROC [xBiScroller: XTk.Widget] RETURNS [XTk.Widget Ź NIL] = {
        xbsd: XBSData ~ GetXBiScrollerData[xBiScroller];
        RETURN [XTkXScroller.Child[xbsd.dummyChild]];
        };

    ReplaceChild: PUBLIC PROC [xBiScroller: XBiScroller, child: XTk.Widget, delayed: BOOL Ź FALSE, preventDestructionOfOldChild: BOOL Ź 
    FALSE] = {
        xbsd: XBSData Ź GetXBiScrollerData[xBiScroller];
        <<<<down, the picture>>>>
        XTkXScroller.ReplaceChild[xbsd.dummyChild, child, delayed, preventDestructionOfOldChild];
        };

    SizeSubtract: PROC [szVal: INT, sub: INT] RETURNS [INT] = {
        IF szVal>0 THEN szVal Ź MAX[szVal-sub, 1];
        RETURN [szVal]
        };

    PublicSetState: PUBLIC PROC [xBiScroller: XBiScroller, p: Xl.Point, event: XTk.Event Ź NIL] = {
        xbsd: XBSData ~ GetXBiScrollerData[xBiScroller];
    pair: REF FilterPair Ź xbsd.filterPair;
    IF pair=NIL 
    THEN <<self>>DirectSetState[xBiScroller, p, event]
    ELSE pair.filterProc[xBiScroller, p, pair.filterData, event]
        }; 

    CheckChildState: XTk.WidgetNotifyProc = {
        xBiScroller: XTk.Widget ~ NARROW[registerData];
        xbsd: XBSData ~ GetXBiScrollerData[xBiScroller];
        state: XTkBiScrollerFrame.State2;
        f: REAL;
        docSize: Xl.Size Ź GetOuterSize[XTkXScroller.Child[xbsd.dummyChild]];
        winSize: Xl.Size Ź GetInnerSize[xbsd.dummyChild];
        p: Xl.Point Ź EntryGetState[xbsd];
        state.v.start Ź (f Ź MAX[-p.y, 0])/docSize.height;
        state.h.start Ź (f Ź MAX[-p.x, 0])/docSize.width;
        state.v.next Ź state.v.start + (f Ź winSize.height)/docSize.height;
        state.h.next Ź state.h.start + (f Ź winSize.width)/docSize.width;
        <<super, the scrollbars>>XTkBiScrollerFrame.ParentalSetState[xBiScroller, state, event];
        };

    DirectSetState: PUBLIC PROC [xBiScroller: XBiScroller, p: Xl.Point, event: XTk.Event Ź NIL] = {
        xbsd: XBSData ~ GetXBiScrollerData[xBiScroller];
        rootTQ: Xl.TQ Ź xBiScroller.rootTQ;
        action: PROC [] = {
            EntrySetState[xbsd, p];
            <<down, the picture>>XTkXScroller.SetOffset[xbsd.dummyChild, p];
            XTkFriends.CallNotifiers[xBiScroller, stateChanged, xbsd, event];
            };
        IF rootTQ=NIL OR xBiScroller.state>=screened 
            THEN action[] 
            ELSE Xl.CallWithLock[rootTQ, action];
        }; 

    GetState: PUBLIC PROC [xBiScroller: XBiScroller] RETURNS [p: Xl.Point] = {
        xbsd: XBSData ~ GetXBiScrollerData[xBiScroller];
        RETURN [EntryGetState[xbsd]];
        }; 

    EntrySetState: ENTRY PROC [xbsd: XBSData, p: Xl.Point] = INLINE {
        xbsd.pos Ź p
        }; 

    EntryGetState: ENTRY PROC [xbsd: XBSData] RETURNS [p: Xl.Point] = INLINE {
        RETURN [xbsd.pos]
        }; 

    END.