/*
 * tooltip.c
 *
 * This class definition file has been generated from the file
 * ..\SOM\SC\tooltip.c in preparation for compiling.  New
 * methods will be appended at the end only.
 */

#define INCL_PM
#define INCL_DOSPROCESS
#define INCL_DOSERRORS
#define INCL_RXSHV
#define INCL_RXFUNC

#include "vxrexx.h"
#include "vxfuncs.h"
#include "utility.h"
#include "tipwin.h"

#define ID_TIMER        10

#define VRToolTip_Class_Source
#ifdef __WATCOMC__
#pragma disable_message(111)
#endif
#include "tooltip.ih"
#ifdef __WATCOMC__
#pragma enable_message(111)
#endif
#include "tooltip.ph"
#include "vxcdata.h"

extern PSZ VRToolTipPicturePath;


/*
 * OnRegisteredControl  (internal function)
 *
 * Determines whether the specified point falls inside a registered window
 * control.  If so, returns that control's data.  Returns NULL otherwise.
 */
SOM_Scope PTTREGCTL OnRegisteredControl( VRToolTip *somSelf, POINTL pos )
{
    PTTREGCTL pCtl;
    HWND      hwnd;
    HWND      hwndParent;
    SOMAny   *somCtl;
    RXSTRING  property,
              propval;
    BOOL      isVisible = FALSE,
              isEnabled = FALSE;
#if 0
    HPS       hps;
    ULONG     ulrc;
    LONG      lPtIn;
    HRGN      hrgn;
#else
    SWP       swp;
    POINTL    relpos;
    BOOL      rc;
#endif

    VRToolTipData *somThis = VRToolTipGetData(somSelf);

    if ( ! _usCtls ) return NULL;
    pCtl = _pCtls;

    hwnd = _vrGetWindowHandle( somSelf );
    if ( ! WinIsThreadActive( WinQueryAnchorBlock( hwnd )))
        return NULL;

#if 0
    hps = WinGetPS( hwnd );
    while ( pCtl && pCtl->hwnd )
    {
        hwndParent = WinQueryWindow( pCtl->hwnd, QW_PARENT );
        if ( !hwndParent ) continue;

        ulrc = WinQueryVisibleRegion( pCtl->hwnd, hrgn );

        if (( ulrc != RGN_ERROR ) && ( ulrc != RGN_NULL )) {
            lPtIn = GpiPtInRegion( hps, hrgn, &pos );

            if ( lPtIn == PRGN_INSIDE ) {
                isVisible = FALSE,
                isEnabled = FALSE;

                /* We found a registered control under the mouse. Now we make sure
                 * it's both enabled and visible.
                 */
                somCtl = VRMapWindowToObject( pCtl->hwnd );
                MAKERXSTRING( property, "Visible", 7 );
                propval.strptr = NULL;
                propval.strlength = 0;
                if (( VRGetProperty( somCtl, &property, &propval ) == VR_GETPROP_OK ) &&
                    propval.strptr != NULL )
                {
                    if ( strcmp( propval.strptr, "1") == 0 )
                        isVisible = TRUE;
                    DosFreeMem( propval.strptr );
                    propval.strptr = NULL;
                    propval.strlength = 0;
                }
                MAKERXSTRING( property, "Enabled", 7 );
                if (( VRGetProperty( somCtl, &property, &propval ) == VR_GETPROP_OK ) &&
                    propval.strptr != NULL )
                {
                    if ( strcmp( propval.strptr, "1") == 0 )
                        isEnabled = TRUE;
                    DosFreeMem( propval.strptr );
                    propval.strptr = NULL;
                    propval.strlength = 0;
                }

                WinReleasePS( hps );
                if ( isVisible && isEnabled )
                    return pCtl;
                else
                    return NULL;
            }
        }
        pCtl = pCtl->pNext;
    }
    WinReleasePS( hps );

#else

    while ( pCtl && pCtl->hwnd )
    {
        rc = WinQueryWindowPos( pCtl->hwnd, &swp );
        if ( !rc ) continue;
        hwndParent = WinQueryWindow( pCtl->hwnd, QW_PARENT );
        if ( !hwndParent ) continue;
        relpos.x = pos.x; relpos.y = pos.y;
        WinMapWindowPoints( HWND_DESKTOP, hwndParent, &relpos, 1 );

        if ((( relpos.x >= swp.x ) && ( relpos.x <= ( swp.x + swp.cx ))) &&
            (( relpos.y >= swp.y ) && ( relpos.y <= ( swp.y + swp.cy ))))
        {
            isVisible = FALSE,
            isEnabled = FALSE;

            /* We found a registered control under the mouse. Now we make sure
             * it's both enabled and visible.
             */
            somCtl = VRMapWindowToObject( pCtl->hwnd );
            MAKERXSTRING( property, "Visible", 7 );
            propval.strptr = NULL;
            propval.strlength = 0;
            if (( VRGetProperty( somCtl, &property, &propval ) == VR_GETPROP_OK ) &&
                propval.strptr != NULL )
            {
                if ( strcmp( propval.strptr, "1") == 0 )
                    isVisible = TRUE;
                DosFreeMem( propval.strptr );
                propval.strptr = NULL;
                propval.strlength = 0;
            }
            MAKERXSTRING( property, "Enabled", 7 );
            if (( VRGetProperty( somCtl, &property, &propval ) == VR_GETPROP_OK ) &&
                propval.strptr != NULL )
            {
                if ( strcmp( propval.strptr, "1") == 0 )
                    isEnabled = TRUE;
                DosFreeMem( propval.strptr );
                propval.strptr = NULL;
                propval.strlength = 0;
            }

            if ( isVisible && isEnabled )
                return pCtl;
            else
                return NULL;
        }

        pCtl = pCtl->pNext;
    }

#endif

    return NULL;
}


/*
 *  ShowTip  (internal function)
 */
SOM_Scope void ShowTip( VRToolTip *somSelf, PTTREGCTL pCtl, POINTL pos )
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);

    if ( !_hwndTip || !pCtl->pszTip ) return;
    _hwndShowing = pCtl->hwnd;

    WinSetWindowText( _hwndTip, pCtl->pszTip );
    WinSetWindowPos( _hwndTip, 0L, pos.x+2, pos.y+2, 0, 0, SWP_MOVE | SWP_SHOW );
    WinShowWindow( _hwndTip, TRUE );
}


/*
 *  HideTip  (internal function)
 */
SOM_Scope void HideTip( VRToolTip *somSelf )
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);

    _hwndShowing = NULL;
    if ( _hwndTip ) WinShowWindow( _hwndTip, FALSE );
}


/*
 *  VRToolTipInstance_somInit
 */

SOM_Scope void   SOMLINK VRToolTipInstance_somInit(VRToolTip *somSelf)
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_somInit");

    _usCtls      = 0;
    _pCtls       = NULL;
    _timer       = 0;
    _ulTimeOut   = 0;
    _hwndShowing = NULLHANDLE;
    _hwndTip     = NULLHANDLE;

    parent_somInit(somSelf);
#if 0
    if ( VRQueryRunMode() == VR_DESIGN_MODE ) {
        _vrSet_Enabled( somSelf, FALSE );   // disable by default
    }
#endif
}

/*
 *  VRToolTipInstance_somUninit
 */

SOM_Scope void   SOMLINK VRToolTipInstance_somUninit(VRToolTip *somSelf)
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_somUninit");

    // free the linked list of registered controls
    if ( _usCtls ) {
        PTTREGCTL pCtl;
        while ( _pCtls ) {
            pCtl = _pCtls;
            _pCtls = pCtl->pNext;
            if ( pCtl->pszTip ) VRMemFree( pCtl->pszTip );
            VRMemFree( pCtl );
        }
    }

    // stop the check timer
    if ( _timer ) {
        HWND hwnd =_vrGetWindowHandle( somSelf );
        HAB  hab  = WinQueryAnchorBlock( hwnd );
        WinStopTimer( hab, hwnd, _timer );
    }

    // destroy the tooltip popup if it exists
    if ( _hwndTip ) WinDestroyWindow( _hwndTip );

    parent_somUninit(somSelf);
}

/*
 *  VRToolTipInstance_vrLocalCreateWindow
 */

SOM_Scope HWND   SOMLINK VRToolTipInstance_vrLocalCreateWindow(VRToolTip *somSelf,
		PBOOL visible)
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrLocalCreateWindow");

    return (parent_vrLocalCreateWindow(somSelf,visible));
}

/*
 *  VRToolTipInstance_vrSet_Enabled
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrSet_Enabled(VRToolTip *somSelf,
		BOOL on)
{
    HAB         hab;
    HWND        hwnd;
    ULONG       ulTrigger,
                idFG, idBG,
                cbPP;
    LONG        lFG, lBG;
    PPRESPARAMS ppres;
    CHAR        szValue[ 40 ];
    RXSTRING    rsprop, rsvalue;


    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrSet_Enabled");

    hwnd = _vrGetWindowHandle( somSelf );
    hab = WinQueryAnchorBlock( hwnd );

    if ( !hwnd || VRQueryRunMode() == VR_DESIGN_MODE );     // do nothing

    else if ( on ) {
        ulTrigger = 100;
        _timer = WinStartTimer( hab, hwnd, ID_TIMER, ulTrigger );
        if ( _timer == 0 ) on = FALSE;
        else {
            // create the tooltip flyover window
            rsvalue.strptr = szValue;
            rsvalue.strlength = sizeof( szValue );
            if ( ! WinQueryPresParam( hwnd, PP_BACKGROUNDCOLORINDEX,
                                      PP_BACKGROUNDCOLOR, &idBG,
                                      sizeof( lBG ), &lBG, 0 ))
                lBG = SYSCLR_WINDOW;

            if ( ! WinQueryPresParam( hwnd, PP_FOREGROUNDCOLORINDEX,
                                      PP_FOREGROUNDCOLOR, &idFG,
                                      sizeof( lFG ), &lFG, 0 ))
                lFG = SYSCLR_WINDOWTEXT;
            MAKERXSTRING( rsprop, "Font", 4 );
            if ( VRGetProperty( somSelf, &rsprop, &rsvalue ) != VR_GETPROP_OK )
                MAKERXSTRING( rsvalue, "<default>", 10 );
            // don't set PP_FONTNAMESIZE if the Font property is "<default>"
            if ( strcmp( rsvalue.strptr, "<default>") == 0 )
                cbPP = sizeof( ULONG ) * 6;
            else
                cbPP = ( sizeof( ULONG ) * 8 ) + rsvalue.strlength + 1;

            ppres = (PPRESPARAMS) VRMemAlloc( cbPP + sizeof( ULONG ));
            ppres->cb = cbPP;
            ppres->aparam[0].id = idBG;
            ppres->aparam[0].cb = sizeof( LONG );
            memcpy(&ppres->aparam[0].ab, &lBG, sizeof(lBG));
            ppres->aparam[1].id = idFG;
            ppres->aparam[1].cb = sizeof( LONG );
            memcpy(&ppres->aparam[1].ab, &lFG, sizeof(lFG));
            if ( strcmp( rsvalue.strptr, "<default>")) {
                ppres->aparam[2].id = PP_FONTNAMESIZE;
                ppres->aparam[2].cb = rsvalue.strlength + 1;
                memcpy(&ppres->aparam[2].ab, rsvalue.strptr, rsvalue.strlength + 1 );
            }

            WinRegisterClass( hab, "VRX_TTPopup", TTPopupProc, CS_SIZEREDRAW, sizeof( PVOID ));
            _hwndTip = WinCreateWindow( HWND_DESKTOP, "VRX_TTPopup", "",
                                        CS_SIZEREDRAW, 0, 0, 0, 0, hwnd, HWND_TOP,
                                        100, NULL, ppres );

            VRMemFree( ppres );
        }
    }
    else {
        if ( _timer ) WinStopTimer( hab, hwnd, _timer );
        if ( _hwndTip ) WinDestroyWindow( _hwndTip );
    }

    _ulTimeOut = 0;
    return (parent_vrSet_Enabled(somSelf,on));
}

/*
 *  VRToolTipInstance_vrGet_Enabled
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrGet_Enabled(VRToolTip *somSelf,
		BOOL *on)
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrGet_Enabled");

    return (parent_vrGet_Enabled(somSelf,on));
}

/*
 *  VRToolTipInstance_vrRXMethod_Register
 *
 *  Defines a new control/tooltip relationship and adds it to our list.
 *
 *  ok = VRMethod( tooltip, "Register", window, tiptext )
 *
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrRXMethod_Register(VRToolTip *somSelf,
		LONG argc,
		PRXSTRING argv,
		PLONG argsused,
		PRXSTRING retstr,
		PVRMETHEXTRA rxdata)
{
    PTTREGCTL pRegister;        // Pointer to new registered-tooltip struct
    SOMAny *object = NULL;      // SOM object of specified window
    HWND    hwndCtl;            // handle of specified window
    TID     tid;
    BOOL    ok = FALSE;

    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrRXMethod_Register");

    if (( argc != 2 ) || ( !RXVALIDSTRING( argv[0] )) || ( !RXVALIDSTRING( argv[1] )))
        return FALSE;

    // Get the handle of the window being registered
    if ( ! _vrGetRexxIds( somSelf, &tid, NULL )) return FALSE;
    if ( VRRXStringToSOMObject( &(argv[0]), &object, tid ) && object ) {
        hwndCtl = VRMapObjectToWindow( object );
        if ( !hwndCtl ) return FALSE;
    }
    else return FALSE;

    // Create a new registered-control record
    pRegister = VRMemAlloc( sizeof( TTREGCTL ));
    if ( !pRegister ) goto finish;
    pRegister->hwnd = hwndCtl;
    pRegister->pszTip = VRMemAlloc( RXSTRLEN( argv[1] ) + 1 );
    if ( ! pRegister->pszTip ) {
        VRMemFree( pRegister );
        goto finish;
    }
    strcpy( pRegister->pszTip, argv[1].strptr );
    pRegister->pNext = NULL;

    // Add the new record to the end of our linked list
    if ( !_usCtls ) _pCtls = pRegister;
    else {
        PTTREGCTL pLast = _pCtls;
        while ( pLast->pNext != NULL ) pLast = pLast->pNext;
        pLast->pNext = pRegister;
    }
    _usCtls++;
    ok = TRUE;

    // Finish up
finish:
    VRBooleanToRXString( retstr, ok );
    return TRUE;
}

/*
 *  VRToolTipInstance_vrRXMethod_Deregister
 *
 *  Removes the specified window (and its tip) from our list of registered
 *  controls.
 *
 *  ok = VRMethod( tooltip, "Deregister", window )
 *
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrRXMethod_Deregister(VRToolTip *somSelf,
		LONG argc,
		PRXSTRING argv,
		PLONG argsused,
		PRXSTRING retstr,
		PVRMETHEXTRA rxdata)
{
    PTTREGCTL pCtl, pPrev;      // Pointers to registered-tooltip struct
    SOMAny *object = NULL;      // SOM object of specified window
    HWND    hwndCtl;            // handle of specified window
    TID     tid;
    BOOL    ok = FALSE;

    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrRXMethod_Deregister");

    if (( argc != 1 ) || ( !RXVALIDSTRING( argv[0] )))
        return FALSE;
    if ( !_usCtls || !_pCtls ) return FALSE;

    if ( ! _vrGetRexxIds( somSelf, &tid, NULL )) return FALSE;

    // Get the handle of the window being deregistered
    if ( VRRXStringToSOMObject( &(argv[0]), &object, tid ) && object ) {
        hwndCtl = VRMapObjectToWindow( object );
        if ( !hwndCtl ) return FALSE;
    }
    else return FALSE;

    pCtl = _pCtls;
    while ( pCtl && ( pCtl->hwnd != hwndCtl )) pCtl = pCtl->pNext;
    if ( !pCtl ) goto finish;

    // OK, we found the control
    // If this control's tip is currently showing, hide it
    if ( _hwndShowing == hwndCtl ) HideTip( somSelf );

    // Now remove it from the list
    pPrev = _pCtls;
    while ( pPrev->pNext && ( pPrev->pNext->hwnd != hwndCtl )) pPrev = pPrev->pNext;
    if ( !pPrev ) goto finish;
    pPrev->pNext = pCtl->pNext;
    _usCtls--;
    if ( pCtl->pszTip ) VRMemFree( pCtl->pszTip );
    VRMemFree( pCtl );
    ok = TRUE;

    // Finish up
finish:
    VRBooleanToRXString( retstr, ok );
    return TRUE;
}

/*
 *  VRToolTipInstance_vrRXMethod_QueryRegistered
 *
 *  Return a list of windows that are currently registered.  The given
 *  stem will contain the VX-REXX object handles ("?VRwhatever") in standard
 *  REXX-array notation.
 *
 *  ok = VRMethod( tooltip, "QueryRegistered", stem )
 *
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrRXMethod_QueryRegistered(VRToolTip *somSelf,
		LONG argc,
		PRXSTRING argv,
		PLONG argsused,
		PRXSTRING retstr,
		PVRMETHEXTRA rxdata)
{
    CHAR       szValue[ 20 ];       // string buffer for VX-REXX object name
    CBSTEMDATA cbdata;
    PTTREGCTL  pCtl;
    SOMAny     *somCtl;
    PSZ        pszStem;
    RXSTRING   rsCtl;
    USHORT     i;
    TID        tid;
    BOOL       ok;


    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrRXMethod_QueryRegistered");

    if (( argc != 1 ) || ( !RXVALIDSTRING( argv[0] )))
        return FALSE;
    if ( argv[0].strptr[ argv[0].strlength-1 ] == '.') argv[0].strlength--;
    argv[0].strptr[ RXSTRLEN( argv[0] ) ] = '\0';
    pszStem = argv[0].strptr;

    if ( ! _vrGetRexxIds( somSelf, &tid, NULL ))
        return FALSE;

    cbdata.pszName = pszStem;

    rsCtl.strptr    = szValue;
    rsCtl.strlength = sizeof( szValue );
    pCtl = _pCtls;
    i = 0;
    while ( pCtl ) {
        somCtl = VRMapWindowToObject( pCtl->hwnd );
        if ( somCtl && VRSOMObjectToRXString( somCtl, &rsCtl )) {
            szValue[ RXSTRLEN( rsCtl ) ] = '\0';

            cbdata.ulIndex = ++i;
            cbdata.pszValue = rsCtl.strptr;
            cbdata.rc = 0;
            if ( ! VRCallFunctionClient( tid, (PFN) CB_WriteStemElement, &cbdata )) {
                i--;
                break;
            }
        }
        pCtl = pCtl->pNext;
    }

    sprintf( szValue, "%u", i );
    cbdata.ulIndex = 0;
    cbdata.rc = 0;
    cbdata.pszValue = szValue;
    ok = VRCallFunctionClient( tid, (PFN) CB_WriteStemElement, &cbdata );

    VRBooleanToRXString( retstr, ok );
    return TRUE;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrRXMethod_SetTipText
 *
 *  Changes the tooltip text associated with the given control.  The control
 *  in question must have been previously registered with "Register" (if an
 *  unregistered control is specified, a REX0040 error will result).
 *
 *  ok = VRMethod( tooltip, "SetTipText", window, text )
 *
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrRXMethod_SetTipText(VRToolTip *somSelf,
		LONG argc,
		PRXSTRING argv,
		PLONG argsused,
		PRXSTRING retstr,
		PVRMETHEXTRA rxdata)
{
    PTTREGCTL pCtl;             // pointer to registered-tooltip struct
    SOMAny *object = NULL;      // SOM object of specified window
    HWND    hwndCtl;            // handle of specified window
    TID     tid;                // current thread ID


    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrRXMethod_SetTipText");

    // Verify we have two valid RXSTRING arguments
    if (( argc != 2 ) ||
        ( !RXVALIDSTRING( argv[0] )) ||
        ( !RXVALIDSTRING( argv[1] )))
        return FALSE;
    if ( !_usCtls || !_pCtls ) return FALSE;

    if ( ! _vrGetRexxIds( somSelf, &tid, NULL )) return FALSE;

    // Get the handle of the specified window
    if ( VRRXStringToSOMObject( &(argv[0]), &object, tid ) && object ) {
        hwndCtl = VRMapObjectToWindow( object );
        if ( !hwndCtl ) return FALSE;
    }
    else return FALSE;

    pCtl = _pCtls;
    while ( pCtl && ( pCtl->hwnd != hwndCtl )) pCtl = pCtl->pNext;
    if ( !pCtl ) return FALSE;

    // We found the control, now update its tip text
    if ( pCtl->pszTip ) VRMemFree( pCtl->pszTip );
    pCtl->pszTip = VRMemAlloc( RXSTRLEN( argv[1] ) + 1 );
    strcpy( pCtl->pszTip, argv[1].strptr );

    VRBooleanToRXString( retstr, TRUE );
    return TRUE;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrRXMethod_GetTipText
 *
 *  Returns the current tooltip text associated with the given control, which
 *  must have been previously registered with "Register" (if an unregistered
 *  control is specified, a REX0040 error will result).
 *
 *  text = VRMethod( tooltip, "GetTipText", window )
 *
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrRXMethod_GetTipText(VRToolTip *somSelf,
		LONG argc,
		PRXSTRING argv,
		PLONG argsused,
		PRXSTRING retstr,
		PVRMETHEXTRA rxdata)
{
    PTTREGCTL pCtl;             // pointer to registered-tooltip struct
    SOMAny *object = NULL;      // SOM object of specified window
    HWND    hwndCtl;            // handle of specified window
    TID     tid;                // current thread ID


    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrRXMethod_GetTipText");

    // Verify we have one valid RXSTRING argument (a window name)
    if (( argc != 1 ) || ( !RXVALIDSTRING( argv[0] ))) return FALSE;
    if ( !_usCtls || !_pCtls ) return FALSE;

    if ( ! _vrGetRexxIds( somSelf, &tid, NULL )) return FALSE;

    // Get the handle of the specified window
    if ( VRRXStringToSOMObject( &(argv[0]), &object, tid ) && object ) {
        hwndCtl = VRMapObjectToWindow( object );
        if ( !hwndCtl ) return FALSE;
    }
    else return FALSE;

    pCtl = _pCtls;
    while ( pCtl && ( pCtl->hwnd != hwndCtl )) pCtl = pCtl->pNext;
    if ( !pCtl ) return FALSE;

    // We found the control, now return its tip text
    if ( pCtl->pszTip )
        VRCopyResult( pCtl->pszTip, strlen( pCtl->pszTip ), retstr );
    else
        VRCopyResult("", 0, retstr );

    return TRUE;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMMeta
/*
 *  VRToolTipClass_vrLocalClassInit

 * Note: The vrLocalClassInit function is defined
 * in the .ph file for this class....
 */


/*
 *  VRToolTipClass_vrLocalWindowClassInit
 */

SOM_Scope bool   SOMLINK VRToolTipClass_vrLocalWindowClassInit(M_VRToolTip *somSelf)
{
    /* M_VRToolTipData *somThis = M_VRToolTipGetData(somSelf); */
    M_VRToolTipMethodDebug("M_VRToolTip","VRToolTipClass_vrLocalWindowClassInit");

    return (parent_vrLocalWindowClassInit(somSelf));
}

/*
 *  VRToolTipClass_somInit
 */

SOM_Scope void   SOMLINK VRToolTipClass_somInit(M_VRToolTip *somSelf)
{
    /* M_VRToolTipData *somThis = M_VRToolTipGetData(somSelf); */
    M_VRToolTipMethodDebug("M_VRToolTip","VRToolTipClass_somInit");

    parent_somInit(somSelf);

    get_picturepath( somSelf ) = VRToolTipPicturePath;

    if( VRQueryRunMode() == VR_DESIGN_MODE ){
        VRInstallHelp( somSelf );
    }
}

/*
 *  VRToolTipClass_somUninit
 */

SOM_Scope void   SOMLINK VRToolTipClass_somUninit(M_VRToolTip *somSelf)
{
    /* M_VRToolTipData *somThis = M_VRToolTipGetData(somSelf); */
    M_VRToolTipMethodDebug("M_VRToolTip","VRToolTipClass_somUninit");

    parent_somUninit(somSelf);
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrSet_BackColor
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrSet_BackColor(VRToolTip *somSelf,
		PSZ str)
{
    LONG  lClr;
    HWND  hwnd;
    ULONG ulID;
    bool  ok;

    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrSet_BackColor");

    // The parent class will convert the string into a presentation parameter
    ok = parent_vrSet_BackColor( somSelf, str );
    hwnd = _vrGetWindowHandle( somSelf );
    if ( _hwndTip && str ) {
        if ( WinQueryPresParam( hwnd, PP_BACKGROUNDCOLORINDEX, PP_BACKGROUNDCOLOR,
                                &ulID, sizeof( lClr ), &lClr, 0 ))
        {
            WinSetPresParam( _hwndTip, ulID, sizeof( lClr ), &lClr );
            if ( _hwndShowing ) HideTip( somSelf );
        }
    }

    return ( ok );
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrGet_BackColor
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrGet_BackColor(VRToolTip *somSelf,
		PSZ *str)
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrGet_BackColor");

    return (parent_vrGet_BackColor(somSelf,str));
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrSet_ForeColor
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrSet_ForeColor(VRToolTip *somSelf,
		PSZ str)
{
    LONG  lClr;
    HWND  hwnd;
    ULONG ulID;
    bool  ok;

    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrSet_ForeColor");

    // The parent class will convert the string into a presentation parameter
    ok = parent_vrSet_ForeColor( somSelf, str );
    hwnd = _vrGetWindowHandle( somSelf );
    if ( _hwndTip && str ) {
        if ( WinQueryPresParam( hwnd, PP_FOREGROUNDCOLORINDEX, PP_FOREGROUNDCOLOR,
                                &ulID, sizeof( lClr ), &lClr, 0 ))
        {
            WinSetPresParam( _hwndTip, ulID, sizeof( lClr ), &lClr );
            if ( _hwndShowing ) HideTip( somSelf );
        }
    }

    return ( ok );
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrGet_ForeColor
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrGet_ForeColor(VRToolTip *somSelf,
		PSZ *str)
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrGet_ForeColor");

    return (parent_vrGet_ForeColor(somSelf,str));
}


#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrSet_Font
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrSet_Font(VRToolTip *somSelf,
		PSZ str)
{
    CHAR szFont[ FACESIZE ];
    HWND hwnd;
    bool ok;

    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrSet_Font");

    // The parent class will convert the string into a presentation parameter
    ok = parent_vrSet_Font( somSelf, str );
    hwnd = _vrGetWindowHandle( somSelf );
    if ( _hwndTip && str ) {
        strncpy( szFont, str, FACESIZE-1 );
        if ( WinQueryPresParam( hwnd, PP_FONTNAMESIZE, 0, NULL, FACESIZE, szFont, 0 ))
        {
            WinSetPresParam( _hwndTip, PP_FONTNAMESIZE, FACESIZE, szFont );
            if ( _hwndShowing ) HideTip( somSelf );
        }
    }

    return ( ok );
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrGet_Font
 */

SOM_Scope bool   SOMLINK VRToolTipInstance_vrGet_Font(VRToolTip *somSelf,
		PSZ *str)
{
    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrGet_Font");

    return (parent_vrGet_Font(somSelf,str));
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrWM_TIMER
 */

SOM_Scope MRESULT   SOMLINK VRToolTipInstance_vrWM_TIMER(VRToolTip *somSelf,
		HWND hWnd,
		ULONG msg,
		MPARAM mp1,
		MPARAM mp2)
{
    POINTL    pos;
    PTTREGCTL pOnCtl;

    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrWM_TIMER");

    if ( WinQueryPointerPos( HWND_DESKTOP, &pos )) {
        pOnCtl = OnRegisteredControl( somSelf, pos );
        if ( pOnCtl ) {
            if ( pOnCtl->hwnd != _hwndShowing ) {
                if ( _ulTimeOut < 10 ) _ulTimeOut++;
                if ( _ulTimeOut == 10 ) {
                    if ( _hwndShowing ) HideTip( somSelf );
                    ShowTip( somSelf, pOnCtl, pos );
                }
            }
        }
        else {
            _ulTimeOut = 0;
            HideTip( somSelf );
        }
    }

    return (MRESULT) 0;
}


#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRToolTipInstance_vrHandleNotify
 */

SOM_Scope MRESULT   SOMLINK VRToolTipInstance_vrHandleNotify(VRToolTip *somSelf,
		HWND hWnd,
		ULONG msg,
		MPARAM mp1,
		MPARAM mp2)
{
    BOOL enabled;

    VRToolTipData *somThis = VRToolTipGetData(somSelf);
    VRToolTipMethodDebug("VRToolTip","VRToolTipInstance_vrHandleNotify");

    /* Because Enabled is a create-time property, it gets set before the
     * actual window is created.  That means the SetEnabled method won't
     * be able to do any of the necessary setup when Enabled is set via
     * the designer.  So we intercept this message to forcibly re-set the
     * Enabled property after the window is created.  This allows the
     * timer and popup window to be initialized if appropriate.
     */
    _vrGet_Enabled( somSelf, &enabled );
    if ( enabled ) _vrSet_Enabled( somSelf, enabled );

    return (parent_vrHandleNotify(somSelf,hWnd,msg,mp1,mp2));
}