System for writing main memory address of object to secondary storage when storing object and reading main memory address of object when retrieving object from secondary storage

Abstract

A method and system for interconnecting software components. In a preferred embodiment, the present invention instantiates an event object. The event object includes message information describing the message and a dispatching member function for invoking a member function of a target object passing the message information. A message is passed by invoking the dispatching member function of the event object passing an identifier to a target object and an identifier of a member function of the target object. The dispatching member function invokes the identified member function of the identified target object passing the event information as an actual parameter. The event object is preferably of a derived class that inherits a base class. The base class provides common event behavior, while the derived class provides behavior specific to a type of message.

Claims

I claim:

1. A method in a computer system of persistently storing objects implementing the behavior of a visual program in secondary storage, the computer system having a central processing unit and a main memory, the main memory having memory locations, each memory location having a memory address, each object being an instance of a class and having a memory address that uniquely identifies the object, the method including the steps of:

when storing the visual program in secondary storage,

storing in secondary storage the memory address of each object; and

for each object, storing in secondary storage an internal state of the object and the memory address of each target object to which the object is connected; and

when retrieving the visual program from secondary storage,

retrieving from secondary storage the memory address of each object;

for each object,

instantiating an object of the retrieved class within the main memory, the instantiated object having a new memory address; and

mapping the retrieved memory address to the new memory address for the instantiated object; and

for each instantiated object,

retrieving from secondary storage the internal state and the memory address of the target objects to which the object is connected;

determining from the mapping the new memory address corresponding to the retrieved memory address of each target object; and

storing the determined new memory addresses in the instantiated object.

2. The method of claim 1 wherein the internal state includes a pointer to a member function of each target object to which a source object is connected.

3. A method in a computer system for persistently storing a plurality of connected objects in secondary storage, the computer system having a central processing unit and a main memory, the main memory being directly accessible by the central processing unit, the main memory having memory locations, each memory location having a memory address, each object having an object class and being instantiated in main memory of the computer system, each object having a memory address that uniquely identifies the instantiated object within main memory, each object containing the memory address of each target object to which it is connected, the method comprising:

when storing the objects in secondary storage,

for each object,

writing to secondary storage the memory address of the object and the memory address of each target object to which the object is connected; and

when retrieving the objects from secondary storage,

for each object,

reading from secondary storage the memory address of the object;

instantiating the object in the main memory of the computer system, the instantiated object having a new memory address;

reading from secondary storages the memory address of each target object to which the object is connected; and

mapping the read memory address of each target object to which the object is connected to the new memory address for that target object so that the instantiated object is connected to the instantiated target object.

4. The method of claim 3 wherein each target object has a plurality of member functions and when writing to secondary storage, writing an indication of one of the plurality of member functions for each target object and when reading from secondary storage, reading an indication of the member function for each target object.

5. A computer-readable medium containing instructions for causing a computer system to persistently store a plurality of connected objects in secondary storage, the computer system having a central processing unit and a main memory, the main memory having memory locations, each memory location having a memory address, each object having an object class and being instantiated in main memory of the computer system, each object having a memory address that uniquely identifies the instantiated object within main memory, each object containing the memory address of each target object to which it is connected, by a method comprising:

when storing the objects in secondary storage,

for each object,

writing to secondary storage the memory address of the object and the memory addresses of each target object to which the object is connected; and

when retrieving the objects from secondary storage,

for each object,

reading from secondary storage the memory address of the object;

instantiating the object in the main memory of the computer system, the instantiated object having a new memory address;

reading from secondary storage the memory address of each target object to which the object is connected; and

mapping the read memory address of each target object to which the object is connected to the new memory address for that target object so that the instantiated object is connected to the instantiated target object.

6. The computer-readable medium of claim 5 wherein each target object has a plurality of member functions and when writing to secondary storage, writing an indication of one of the plurality of member functions for each target object and when reading from secondary storage, reading an indication of the member function for each target object.

7. A computer-readable medium containing instructions for causing a computer system to persistently store objects implementing the behavior of a visual program in secondary storage, the computer system having a central processing unit and a main memory, the main memory having memory locations, each memory location having a memory address, each object being an instance of a class and having a memory address that uniquely identifies the object, by a method comprising:

when storing the visual program in secondary storage,

storing in secondary storage the memory address of each object; and

for each object, storing in secondary storage an internal state of the object and the memory address of each target object to which the object is connected; and

when retrieving the visual program from secondary storage,

retrieving from secondary storage the memory address of each object;

for each object,

instantiating an object of the retrieved class within the main memory, the instantiated object having a new memory address; and

mapping the retrieved memory address to the new memory address for the instantiated object; and

for each instantiated object,

retrieving from secondary storage the internal state and the memory address of the target objects to which the object is connected;

determining from the mapping the new memory address corresponding to the retrieved memory address of each target object; and

storing the determined new memory addresses in the instantiated object.

Description

TECHNICAL FIELD

The present invention relates generally to a computer system for visual programming, and more specifically, to a method and system for interconnecting visual components and passing messages between connected components.

BACKGROUND OF THE INVENTION

Visual programming is a computer programming technique that allows for rapid development of visually oriented programs (visual programs). FIG. 1 is a diagram illustrating a sample operation of a visual program. The visual program is a temperature converter, which converts Fahrenheit to Centigrade, and vice versa. The Fahrenheit scroll bar 101 is used to set the Fahrenheit value to between 0 and 100 degrees as indicated by the position of the Fahrenheit slider 103. The Fahrenheit display 102 displays the numeric Fahrenheit value represented by the position of the Fahrenheit slider. The Centigrade scroll bar 111 is used to set the Centigrade value between 0 and 100 degrees as indicated by the Centigrade slider 113. The Centigrade display 112 displays the numeric Centigrade value represented by the position of the Centigrade slider. In operation, when the Fahrenheit slider is moved by a user, the Centigrade slider is automatically moved to the corresponding Centigrade position and the Fahrenheit and Centigrade displays are updated. Conversely, when the Centigrade slider is moved by a user, the Fahrenheit slider is automatically moved to the corresponding Fahrenheit position and the Centigrade and Fahrenheit displays are updated.

Visual programming allows various components (e.g., a scroll bar) to be interconnected visually to effect the program behavior. A visual programming environment typically includes a list of predefined components that can be interconnected to create a visual program. Each component may include input and output ports and a visual interface. When creating a visual program, a programmer specifies the visual components and their location on the display. The programmer also specifies the interconnection between various ports. The components pass values through these connections. FIG. 2 is a block diagram illustrating a scroll bar component. The scroll bar component 201 receives messages from the operating system (e.g., mouse down) and controls the display of a scroll bar. The scroll bar also provides an input port 203 and an output port 202. The input port is used to receive a value indicating a new position of the slider and the output port is used to send a value indicating a new slider position. The scroll bar can be connected to other components through its ports.

FIG. 3 is a diagram illustrating a scroll bar connected to a display component. A display component 301 has one input port 303 for receiving a value. The display component controls the displaying of the value that it receives. The output port 202 of the scroll bar component 201 is connected to the input port 303 of the display component. In operation, whenever the scroll bar slider is moved, a value indicating the new position of the slider is sent from the scroll bar component to the display component. The display component receives this value and updates its display accordingly.

Although prior references have described general visual programming environments, visual programming is not widespread because of the inefficiencies of visual programs. For example, visual programs often execute in an interpretive mode that results in unacceptably slow performance.

SUMMARY OF THE INVENTION

It is an object of the present invention to provide a method and system that allows for creation of efficient visual programs.

It is another object of the present invention to provide a method and system that shields component developer from the details of the connecting of components and the passing of values between components.

These and other objects, which will become apparent as the invention is more fully described below, are obtained by an improved method and system for sending messages between components. In a preferred embodiment, the present invention instantiates an event object. The event object includes message information describing the message and a dispatching member function for invoking a member function of a target object passing the message information. A message is passed by invoking the dispatching member function of the event object passing an identifier to a target object and an identifier of a member function of the target object. The dispatching member function invokes the identified member function of the identified target object passing the event information as an actual parameter. The event object is preferably of a derived class that inherits a base class. The base class provides common event behavior, while the derived class provides behavior specific to a type of message.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram illustrating a sample operation of a visual program.

FIG. 2 is a block diagram illustrating a scroll bar component.

FIG. 3 is a diagram illustrating a scroll bar connected to a display component.

FIG. 4 is a diagram illustrating visual programming of the present invention.

FIG. 5 is a diagram illustrating the instantiated objects for the temperature converter.

FIG. 6 is a table containing a listing of the connections for the for the temperature converter program.

FIG. 7 is a flow diagram illustrating the flow of control of sending a message from a source object to a target object.

FIG. 8 is a block diagram of data structures of a CEditor object.

FIG. 9 is a block diagram of a computer system.

DETAILED DESCRIPTION OF THE INVENTION

The present invention provides a method and system for connecting components and passing of messages (events) between components. In a preferred embodiment, each component may provide multiple input ports and output ports. Each output port sends a message corresponding to a particular type of event; each input port receives a message corresponding to a particular type of event. A component that sends a message is referred to as a source, and a component that receives the message is referred to as the target. In a preferred embodiment, each component has an associated run-time class and editor class. The editor class provides component-specific behavior to assist in creating a visual program. The run-time class provides the component behavior when the visual program executes. A visual programming system controls the development of visual programs by instantiating objects of the editor classes and controls the run-time execution by instantiating objects of the run-time class. As described below, the present invention provides a mechanism in which messages are efficiently passed between components. In the following, a preferred embodiment of the present invention is described using well-known object-oriented terminology and terminology of the C++ programming language.

FIG. 4 is a diagram illustrating visual programming of the present invention. To generate a visual program to implement a temperature converter, a programmer would position a Fahrenheit scroll bar 401, a Fahrenheit display 430, a Centigrade scroll bar 420, and a Centigrade display 440. The programmer would also position an FtoC calculator 460, which converts a Fahrenheit value to a Centigrade value, and a CtoF calculator 450, which converts a Centigrade value to a Fahrenheit value. In one embodiment, the components are selected from an extendible list of available components. The programmer then connects the components through their ports. The connections 412->461 and 412->431 indicate that when the Fahrenheit scroll bar is changed (e.g., slider moved), the new value is sent to the FtoC calculator and the Fahrenheit display. The connection 462->421 indicates that when the FtoC calculator calculates a new Centigrade value, the new value is sent to the Centigrade scroll bar. The connections 422->441 and 422->451 indicate that when the Centigrade scroll bar is changed, the new value is sent to the CtoF calculator and the Centigrade display. The connection 452->411 indicates that when the CtoF calculator calculates a new Fahrenheit value, the new value is sent to the Fahrenheit scroll bar. In one embodiment, the components are connected by entering a connect mode and selecting the source and target of each connection.

The visual programming system instantiates an object of the run-time class for each component selected by the programmer. FIG. 5 is a diagram illustrating the instantiated objects for the temperature converter. The FScrollbar object 501 corresponds to the Fahrenheit scroll bar component, the CScrollbar object 502 corresponds to the Centigrade scroll bar component, the FDisplay object 503 corresponds to the Fahrenheit display component, the CDisplay object 504 corresponds to the Centigrade display component, the FtoC object 505 corresponds to the FtoC calculator component, and the CtoF object 506 corresponds to the CtoF calculator component. Each of these objects implements the display and control of the corresponding component. The directed arcs indicate the direction of the connections, that is, from an output port to an input port.

Each component may send messages to other components corresponding to different types of events. For example, a scroll bar may send a message to indicate a changed value event has occurred and another message to indicate a scroll down has occurred. Each type of event has its own output port. Also, input ports are designated to receive only certain types of events. For example, an output port that sends messages relating to a scroll up event can only be connected to an input port that expects a message in the same format as a scroll up message.

A source object (corresponding to a source component) sends a message (communicates the occurrence of an event) by invoking a member function of a target object (corresponding to a target component). Each input and output port is preferably associated with a function member of the run-time object. For example, a scroll bar object may have a function member named ValueIn corresponding to an input port for receiving a new value and a function member named ValueOut corresponding to an output port for sending a new value. In operation, the member function ValueOut is invoked whenever a change in the value for the scroll bar occurs, e.g., when the slider is moved. The member function ValueOut invokes the target member function corresponding to each input port to which it is connected. The invoked target member function then processes the value information which is passed as a parameter.

In a preferred embodiment, message information (e.g., new value) is encapsulated in an object of an event class. The source member function corresponding to an output port creates an event object and stores the event information in the event object. The source member function effects the invocation of a notify member function of a target object passing the event object and a pointer to the target member function. The notify member function invokes a dispatching member function of the event object passing a pointer to the target object and a pointer to the target member function. The dispatching member function invokes the target member function passing the stored information as a parameter. In a preferred embodiment, different implementations of event objects are used to represent different function prototypes (parameter list) of target member functions. Each class of event object contains information that is passed to a target member function according to the function prototype. Thus, each source member function invokes target member functions with the same prototype.

In a preferred embodiment, each run-time class inherits the class CObject. The class CObject tracks the connections and controls the sending of messages. The class CObject is referred to as a connection manager. In this way, run-time classes that implement component behavior can be developed without detailed knowledge of the implementation of the class CObject. Moreover, run-time objects implemented by different developers can cooperatively interact. FIG. 6 is a table containing a listing of the connections for the for the temperature converter program. The class CObject includes an array (connectionArray) that contains the connections for each output port of the run-time object. Each entry of the connection array contains an identifier of the output port of the source object, an identifier of the target object, and an identifier of the input port of the target object. For example, the connection array for the FScrollbar object contains two entries:

(Out1, FDisplay, In1) and (Out1, FtoC, In1)

"Out1" identifies the output port, "FDisplay" and "FtoC" identify the target objects, and "In1" identifies the input port of the target objects. When an event occurs for a particular output port, the source object instantiates an event object and invokes an inform targets member function of the class CObject (connection manager) identifying the output port. The output port is preferably identified by a pointer to a member function (source member function) of the source object. The inform targets member function sends an appropriate message to each target object as indicated by the connection array for the source object. The input port is preferably identified by a pointer to a member function (target member function) of the target object. The connection manager sends the message to the target object by invoking a notify member function of the target object passing a pointer to the target member function and an event object. The event object contains actual parameters for the target member function. The notify member function invokes a dispatch member function of the event object passing a pointer to the target member function and a pointer to the target object. The dispatch member function formats the actual parameters and invokes the target member function of the target object passing the actual parameters.

Code Table 1 contains pseudocode for the class CObject.

                  CODE TABLE 1
    ______________________________________
    class CONNECTION
    {   CObject *ptarget;
    ULONG pmftarget;
    ULONG pmfsource;
    class CObject
    {
    boolean         isRecursing;
    CONNECTION      connectionArray›10!;
    int             connectionCount;
    virtual     boolean NotifyEvent (CEvent *pevent, CObject
                *psource, ULONG pmftarget);
                boolean InformTargets(CEvent *pevent, ULONG
                pmfsource);
                void     AddTarget(CObject *ptarget,
                         ULONG pmftarget, ULONG
                         pmfsource);
    virtual     void     Serialize(CArchive &ar);
    virtual     VOID     WriteConnectionArray(CArchive
                         &ar);
    virtual     VOID     ReadConnectionArray(CArchive
                         &ar);
    virtual     VOID     SerializeObjectData(CArchive &ar);
    };
    BOOL CObject::NotifyEvent (CEvent *pevent, CObject *psource,
    ULONG pmftarget)
    {
    BOOL ret;
    if (isRecursing) return FALSE;
    isRecursing = TRUE;
    if (pevent -> IsKindOf(CValueEvent))
    ret ((CValueEvent*)pevent)->Dispatch(psource, this, pmftarget);
    else if
    .
    .
    .
    else return FALSE;
    isRecursing = FALSE;
    return ret;
    }
    BOOL CObject::InformTargets(CEvent *pevent, ULONG pmfsource)
    {
    for (i = 0; i < connectionCount; i++)
    {
    if (connectionArray›i!.pmfsource == pmfsource)
    connectionArray›i!.pmftarget->NotifyEvent(pevent, this,
    connectionArray›i!.pmftarget);
    }
    }
    void CObject::AddTarget(CObject *ptarget, ULONG pmftarget, ULONG
    pmfsource)
    {
    i = connectionCount++;
    connectionArray›i!.ptarget = ptarget;
    connectionArray›i!.pmftarget = pmftarget;
    connectionArray›i!.pmfsource = pmfsource;
    }
    ______________________________________

    ______________________________________
    class CEvent
    public:
    CEvent();
    virtual BOOL Dispatch (CObject *psource, CObject *ptarget,
    ULONG pmftarget)=0;
    }
    class CActionEvent : public CEvent
    {
    public:
    virtual BOOL Dispatch (CObject *psource, CObject *ptarget,
    ULONG pmftarget)
    {(ptarget->*(LongToMember(pmf)))()};
    }
    class CIntEvent : public CEvent
    {
    public:
    INT       numValue;
    virtual BOOL Dispatch (CObject*psource, CObject *ptarget,
    ULONG pmftarget)
    {(target->*(LongToMember(pmftarget)))(numValue)};
    }
    class CStringEvent : public CEvent
    {
    public:
    STRING    stringValue;
    virtual BOOL Dispatch (CObject *psource, CObject *ptarget, ULONG
    pmftarget);
    {(ptarget->*(LongToMember(pmftarget)))(stringValue)};
    }
    ______________________________________

                  CODE TABLE 3
    ______________________________________
    class CScrollbar : CObject, CWindow
    INT       m.sub.-- largeChange;
    INT       m.sub.-- smallChange;
    INT       m.sub.-- value;
    INT       m.sub.-- minimum;
    INT       m.sub.-- maximum;
    BOOL      m.sub.-- isVert;
            CScrollBar();
            CScrollBar(const VRect &pos, CWindow *parent,
            boolean isVert);
    virtual INT largeChange();
    virtual VOID
                largeChange(INT);
    virtual INT smallChang();
    virtual VOID
                smallChange(INT);
    virtual INT value();
    virtual VOID
                value(INT);
    virtual INT minimum();
    virtual VOID
                minimum(INT);
    virtual INT maximum();
    virtual VOID
                maximum(INT);
    virtual VOID
                lineUP();
    virtual VOID
                lineDown();
    virtual VOID
                pageUP();
    virtual VOID
                pageDown();
    virtual LONG
                HandleParentMsg(HWND hwnd, unsigned wm,
                WORD wParam, LONG
    IParam);
    }
    CScrollBar::CScrollBar(const VRect &pos, CWindow *parent,
    BOOL isVert)
    DWORD style;
    if (isVert)
    style = WS.sub.-- CHILD .vertline. SBS.sub.-- VERT;
    else
    style = WS.sub.-- CHILD .vertline. SBS.sub.-- HORZ;
    m.sub.-- isVert = isVert;
    CWinWindow::Init(
                parent,
              NULL,
              0L,
              "SCROLLBAR",
              "",
              style,
              pos.left,
              pos.top,
              pos.right - pos.left,
              pos.bottom - pos.top,
              NULL,
              NULL);
    smallChange(1);
    largeChange(10);
    minimum(0);
    maximum(100);
    value(0);
    }
    VOID    CScrollBar::lineUp()
    {
    CActionEvent evt;
    VOID (ScrollBar::*mfp)() = &CScrollBar::lineUp;
    InformTarget(&evt, MemberToLong(mfp));
    value(m.sub.-- value-m.sub.-- smallChange);
    }
    VOID    CScrollBar::value(INT theValue)
    {
    if (theValue < m.sub.-- minimum)
           theValue = m.sub.-- minimum;
    if (theValue > m.sub.-- maximum)
           theValue = m.sub.-- maximum;
    if (m.sub.-- value |= theValue)
    {
           m value = theValue;
           if (m.sub.-- hwnd |= NULL)
            SetScrollPos(GetHwnd(), SB.sub.-- CTL, m.sub.-- value,
            TRUE);
           CIntValue numEvent;
           INT (CScrollBar::*mfp)() = &CScrollBar::value;
           numEvent.numValue = m.sub.-- value;
           InformTargets(&numEvent,
           (ULONG)MemberToLong(mfp));
    }
    }
    VOID    CScrollBar::minimum(INT theMinimum)
    {
    m.sub.-- minimum = theMinimum;
    if (m.sub.-- hwnd |= NULL)
    SetScrollRange(GetHwnd(), SB.sub.-- CTL, m.sub.-- minimum, m.sub.--
    maximum,
    TRUE);
    if (m.sub.-- value < the Minimum)
    value(theMinimum);
    }
    LONG ScrollBar::HandleParentMsg(   HWND hwnd,
    unsigned   wm,
    WORD wParam,
    LONG   IParam)
    {
    switch(wm)
    {
    case WM.sub.-- HSCROLL:
    case WM.sub.-- VSCROLL:
    switch(wParam)
    {
    case SB.sub.-- LINEUP:
                        lineUp(); break;
    case SB.sub.-- LINEDOWN:
                        lineDown(); break;
    case SB.sub.-- PAGEUP:
                        pageUp(); break;
    case SB.sub.-- PAGEDOWN:
                        pageDown(); break;
    case SB.sub.-- TOP: value(minimum()); break;
    case SB.sub.-- BOTTOM
                        value(maximum()); break;
    case SB.sub.-- THUMBTRACK:
    case SB.sub.-- THUMBPOSITION:
                        value(LOWORD(IParam));
                        break;
    case SB.sub.-- ENDSCROLL:
                        break;
    }
    default: break;
    }
    return CWinWindow::HandleParentMSG(hwnd, wm, wParam, IParam);
    }
    ______________________________________

                  CODE TABLE 4
    ______________________________________
    class CEditor:
              public CObject
    public:
            CEditor(CEditor* pEditor, CObject* pSubject);
    virtual VOID ObjectDeleted(CObject* object);
    virtual VOID PortChanged(CEditPort* port);
    VString mName;
    private:
    CEditPortListPtr mPortList;
    CEditorUIPtr mEditorUI;
    CObjectPtr mSubject;
    CEditorListPtr mChildEditors;
    CEditorPtr mParent;
    };
    VOID    CEditor::ObjectDeleted(CObject* object)
    {
    for each CEditPort port1 in mPortList
           if (port1 is connected)
            for each CEditPort port2 in mConnectedPorts of port1
             if (port2.mSubject == object)
              port1->Disconnect(port2)
    RemoveTarget(object);
    mSubject->RemoveTarget(object);
    for each CEditorUI eui in mEditorUIList
           eui->RemoveTarget(object);
    };
    ______________________________________

                  CODE TABLE 5
    ______________________________________
    class CEditorUI: public CObject, CWindow
    public:
    virtual void Draw(const VRect& rectUpdate);
    virtual BOOL OnMouseStart(CUserEvp *, VPoint, INT,
                 INT);
    virtual BOOL OnMouseDrag(CUserEvp *, VPoint, BOOL);
    virtual BOOL OnMouseEnd(CUserEvp *, VPoint, BOOL);
    virtual void PositionChange();
    BOOL showTracker;
    VPoint startSize;
    VPoint startPoint;
    WORD dragMode;
    virtual BOOL MakeStdUI(CEditor*, CWindow*);
    virtual BOOL NotifyEvent(CEvent* ev,
                CObject* sender,
                ULONG action);
    CPopMenuPtr  m.sub.-- popup;
    CPropertyDialogPtr
                 m.sub.-- dialog;
    private:
    CEditorPtr   mEditor;
    BOOL         mIsActive;
    };
    ______________________________________

    ______________________________________
    Name     Type        Input Member
                                    Output Member
    ______________________________________
    Position CIntEvent   6          7
    Pageup   CActionEvent
                         11         12
    ______________________________________

                  CODE TABLE 6
    ______________________________________
    class CEditPort:  public CObject
    public:
    virtual       Connect(CEditPort*
    BOOL          OtherPort);
    virtual       Disconnect(CEditPort*
    BOOL          OtherPort);
    private:
    VString       mName;
    CEditorPtr    mOwnerEditor;
    CObjectPtr    mSubject;
    CEditPortListPtr mConnectedPorts;
    BOOL          mIsConnected : 1;
    BOOL          mIsOutput : 1;
    BOOL          mIsInput : 1;
    BOOL          mCanRead : 1;
    BOOL          mCanWrite : 1;
    CObjectPtr    mValueIn;
    CObjectPtr    mValueOut;
    };
    BOOL    CEditPort::Connect(CEditPort*
    OtherPort)
    {
    mSubject->AddTarget(
             Otherport->mSubject,
             OtherPort->MValueIn,
             this->MValueOut);
    mIsConnected = TRUE;
    mConnectedPorts->Add(OtherPort);
    return TRUE;
    }
    ______________________________________

                  CODE TABLE 7
    ______________________________________
    class CEScrollBar : CEditor
    {   CEScrollBar(CEditor* pParentEditor,
    CWindow* pParentWindow,
    CObject* pSubject);
    };
    CEScrollBar::CEScrollBar(CEditor* pParentEditor,
    CWindow* pParentWindow,
    CObject* pSubject)
    : CEditor(pParentEditor, pSubject)
    CEditPort* pp;
    void (CScrollBar::*mfp3)();
    name(**);
    {
    INT (CScrollBar::*mfp1)()   = &CScrollBar::value;
    void (CScrollBar::*mfp2)(INT)   = &CScrollBar::value;
    pp = new CNumEditPort(this, "Value");
    pp->isOutput(TRUE);
    pp->valueOut( (CObject*)MemberToLong( mfp1 ) );
    pp->isInput(TRUE);
    pp->valueIn( (CObject*)MemberToLong( mfp2 ) );
    pp->canRead(TRUE);
    pp->canWrite(TRUE);
    portList()->Add(pp);
    }
    pp = new CEditPort(this, "Line Up");
    pp->isInput(TRUE);
    pp->valueIn( (CObject*)MemberToLong( mfp3 =
    &CScrollBar::lineUp ) );
    portList()->Add(pp);
    CEScrollBarUI* ui = new CEScrollBarUI(this,
    pParentWindow);
    editorUIList( new CEditorUIList );
    editorUIList()->Add( ui );
    }
    ______________________________________


              CODE TABLE 8
    ______________________________________
    class CEScrollBarUI:CEditorUI
    {CEScrollBarUI(CEditor*, CWindow*)}
    CEScrollBarUI::CBScrollBarUI(
                     CEditor* pEditor,
                   CWindow* pParentWindow)
    editor(pEditor);
    parent(pParentWindow);
    CObject* po = editor()->subject();
    position( ((CWindow*)po)->position() );
    MakeStdUI(pEditor, pParentWindow);
    }
    ______________________________________

• Inventors
  Burgess, Henry W.;
• Assignee
  Microsoft Corporation (Redmond, WA)
• Published
  Sep-8-1998
• Current US Classes:
  717/166
• Application #
  756540
• International Classes
  G06F 012/08; G06F 015/82
• Field of Search
  395/701 395/705 395/600 395/710 395/650 395/800
• Examiner
  Lee; Thomas C.
• Agent
  Seed and Berry LLP
• US Patent References:
  4014005
  4754395
  4872167
  4885717
  5003460
  5005119
  5021976
  5051898
  5095522
  5136716
  5142622
  5163130
  5179550
  5283898
  5287537
  5295256
  5303379
  5305461
  5339430
  5341478
  5386568
  5404534
  5421019
  5426747
  5448736
  5455952
  5551035