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

#define INCL_PM

#include "vxrexx.h"
#include "vxfuncs.h"

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

#define PARENT_IS_VIRTUAL

extern PSZ VRProgressPicturePath;


/* Use custom presentation parameters for storing the RibbonColor setting,
 * instead of instance variables.  Disabled by default because it seems to
 * cause weird side effects.
 */
// #define USE_RIBBON_PP


// Useful rectangle macros
#define RECTL_HEIGHT(rcl)       (rcl.yTop - rcl.yBottom)
#define RECTL_WIDTH(rcl)        (rcl.xRight - rcl.xLeft)

// Get separate RGB values from a long
#define RGBVAL_RED(l)           ((l >> 16) & 0xFF)
#define RGBVAL_GREEN(l)         ((l >>  8) & 0xFF)
#define RGBVAL_BLUE(l)          (l & 0xFF)

#ifdef USE_RIBBON_PP
    // Custom presentation parameters for ribbon colour
    #define PP_RIBBONCOLOR          (PP_USER + 101)
    #define PP_RIBBONCOLORINDEX     (PP_USER + 102)
#endif


// Style values
#define PRO_BORDER_DEEP         0x1
#define PRO_BORDER_LINE         0x2
#define PRO_BORDER_ALL          0xF
#define PRO_RIBBON_FLAT         0x10
#define PRO_RIBBON_ALL          0xF0
#define PRO_RIBBON_COLORRGB     0x100
#define PRO_PERCENT_SHOW        0x200
#define PRO_PERCENT_INVERT      0x400


/*
 * Draw3DBorder (internal function)
 * Draw a simple (1 pixel wide) 3D border in 'inset' or 'outset' style.
 */

void Draw3DBorder( HPS hps, RECTL rcl, BOOL bOutset )
{
    POINTL ptl;

    ptl.x = rcl.xLeft;
    ptl.y = rcl.yBottom;
    GpiMove( hps, &ptl );
    if ( bOutset )
        GpiSetColor( hps, SYSCLR_BUTTONLIGHT );
    else
        GpiSetColor( hps, SYSCLR_BUTTONDARK );
    ptl.y = rcl.yTop - 1;
    GpiLine( hps, &ptl );
    GpiMove( hps, &ptl );
    ptl.x = rcl.xRight - 1;
    GpiLine( hps, &ptl );
    if ( bOutset )
        GpiSetColor( hps, SYSCLR_BUTTONDARK );
    else
        GpiSetColor( hps, SYSCLR_BUTTONLIGHT );
    ptl.y = rcl.yTop - 2;
    GpiMove( hps, &ptl );
    ptl.y = rcl.yBottom;
    GpiLine( hps, &ptl );
    GpiMove( hps, &ptl );
    ptl.x = rcl.xLeft + 1;
    GpiLine( hps, &ptl );
}


/*
 * PaintControl (internal function)
 */

BOOL PaintControl( VRProgress *somSelf, HWND hwnd, HPS hps )
{
    HAB    hab;
    RECTL  rcl,
           rclRibbon,
           rclBgnd;
    POINTL ptl;
    LONG   lBgClr,      // Background colour
           lClr,        // Ribbon colour
           lFgClr;      // Text colour
    LONG   lLength;
    float  fFrac;
    ULONG  ulID,
           cb;
    CHAR   achPercent[ 8 ];

    VRProgressData *somThis = VRProgressGetData(somSelf);
    hab = WinQueryAnchorBlock( hwnd );

    if ( !hab || ! WinQueryWindowRect( hwnd, &rcl )) {
        return FALSE;
    }

    // Get the current background colour
    GpiCreateLogColorTable( hps, 0, LCOLF_RGB, 0, 0, NULL );
    cb = WinQueryPresParam( hwnd, PP_BACKGROUNDCOLOR,
                            PP_BACKGROUNDCOLORINDEX, NULL,
                            sizeof( lBgClr ), &lBgClr,
                            QPF_NOINHERIT | QPF_ID2COLORINDEX );
    if ( !cb )
        lBgClr = GpiQueryRGBColor( hps, 0, SYSCLR_SCROLLBAR );

    // Fill in the background
    WinFillRect( hps, &rcl, lBgClr );

    rclRibbon.xLeft   = rcl.xLeft + 1;
    rclRibbon.yBottom = rcl.yBottom + 1;
    rclRibbon.xRight  = rcl.xRight - 1;
    rclRibbon.yTop    = rcl.yTop - 1;
    rclBgnd.xLeft   = rcl.xLeft + 1;
    rclBgnd.yBottom = rcl.yBottom + 1;
    rclBgnd.xRight  = rcl.xRight - 1;
    rclBgnd.yTop    = rcl.yTop - 1;

    // Draw the outer border
    if ( _fsFlags & PRO_BORDER_LINE ) {
        ptl.x = rcl.xLeft;
        ptl.y = rcl.yBottom;
        GpiMove( hps, &ptl );
        GpiSetColor( hps, SYSCLR_BUTTONDARK );
        ptl.x = rcl.xRight - 1;
        ptl.y = rcl.yTop - 1;
        GpiBox( hps, DRO_OUTLINE, &ptl, 0, 0 );
    }
    else {
        Draw3DBorder( hps, rcl, FALSE );
    }
    if ( _fsFlags & PRO_BORDER_DEEP ) {
        // Draw the inner border
        GpiSetColor( hps, CLR_BLACK );
        ptl.x = rcl.xLeft + 1;
        ptl.y = rcl.yBottom + 1;
        GpiMove( hps, &ptl );
        ptl.y = rcl.yTop - 2;
        GpiLine( hps, &ptl );
        GpiMove( hps, &ptl );
        ptl.x = rcl.xRight - 2;
        GpiLine( hps, &ptl );
        ptl.y = rcl.yTop - 3;
        GpiMove( hps, &ptl );
        GpiSetColor( hps, SYSCLR_BUTTONMIDDLE );
        ptl.y = rcl.yBottom + 1;
        GpiLine( hps, &ptl );
        GpiMove( hps, &ptl );
        ptl.x = rcl.xLeft + 2;
        GpiLine( hps, &ptl );
        WinInflateRect( hab, &rclRibbon, -1, -1 );
    }


    if ( _usPercent > 0 ) {
        // Get the current ribbon colour
#ifdef USE_RIBBON_PP
        cb = WinQueryPresParam( hwnd, PP_RIBBONCOLOR,
                                PP_RIBBONCOLORINDEX, &ulID,
                                sizeof( lClr ), &lClr, QPF_NOINHERIT );
        if ( !cb ) {
            lClr = GpiQueryRGBColor( hps, 0, SYSCLR_BUTTONMIDDLE );
            if ( lClr == GPI_ALTERROR ) lClr = 0x00C0C0C0;
        }
        else if ( ulID == PP_RIBBONCOLORINDEX ) {
            GpiCreateLogColorTable( hps, LCOL_RESET, LCOLF_INDRGB, 0, 0, NULL );
        }
#else
        if ( _fsFlags & PRO_RIBBON_COLORRGB ) {
            lClr = _lRibbonClr ? _lRibbonClr:
                                 GpiQueryRGBColor( hps, 0, SYSCLR_BUTTONMIDDLE );
        }
        else {
            GpiCreateLogColorTable( hps, LCOL_RESET, LCOLF_INDRGB, 0, 0, NULL );
            lClr = _lRibbonClr ? _lRibbonClr : SYSCLR_BUTTONMIDDLE;
        }
#endif

        // Draw the progress ribbon
        fFrac = (float) _usPercent / 100;
        lLength = RECTL_WIDTH( rclRibbon ) * fFrac;
        rclRibbon.xRight = rclRibbon.xLeft + lLength;

        if ( !( _fsFlags & PRO_RIBBON_FLAT )) {
            Draw3DBorder( hps, rclRibbon, TRUE );
            WinInflateRect( hab, &rclRibbon, -1, -1 );
            Draw3DBorder( hps, rclRibbon, TRUE );
            WinInflateRect( hab, &rclRibbon, -1, -1 );
        }

        WinFillRect( hps, &rclRibbon, lClr );
        // Now convert the colour to RGB (if necessary) for future calculations
        lClr = GpiQueryRGBColor( hps, 0, lClr );
    }

    if ( _fsFlags & PRO_PERCENT_SHOW ) {
        // Get the current foreground colour
        GpiCreateLogColorTable( hps, 0, LCOLF_RGB, 0, 0, NULL );
        cb = WinQueryPresParam( hwnd, PP_FOREGROUNDCOLOR,
                                PP_FOREGROUNDCOLORINDEX, NULL,
                                sizeof( lFgClr ), &lFgClr,
                                QPF_NOINHERIT | QPF_ID2COLORINDEX );
        if ( !cb )
            lFgClr = GpiQueryRGBColor( hps, 0, SYSCLR_WINDOWTEXT );

        rclBgnd.xLeft = rclRibbon.xRight + 1;

        sprintf( achPercent, "%u%%", _usPercent );
        cb = strlen( achPercent );

        ptl.x = RECTL_WIDTH( rcl ) / 2;
        ptl.y = RECTL_HEIGHT( rcl ) / 2;
        GpiMove( hps, &ptl );
        GpiSetTextAlignment( hps, TA_CENTER, TA_HALF );

        GpiSetColor( hps, lFgClr );
        if ( _fsFlags & PRO_PERCENT_INVERT ) {
            GpiCharStringPos( hps, &rclBgnd, CHS_CLIP, cb, achPercent, NULL );
            if ( _usPercent > 0 ) {
                GpiSetColor( hps, lBgClr );
                GpiCharStringPos( hps, &rclRibbon, CHS_CLIP, cb, achPercent, NULL );
            }
        }
        else GpiCharStringPos( hps, &rcl, NULL, cb, achPercent, NULL );

    }
    return ( TRUE );
}

/*
 *  VRProgressInstance_somInit
 */

SOM_Scope void   SOMLINK VRProgressInstance_somInit(VRProgress *somSelf)
{
    LONG lClr;
    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_somInit");

    _fsFlags   = PRO_PERCENT_SHOW;
    _usPercent = 0;
#ifndef USE_RIBBON_PP
    _lRibbonClr = 0;
#endif

    parent_somInit(somSelf);
}

/*
 *  VRProgressInstance_somUninit
 */

SOM_Scope void   SOMLINK VRProgressInstance_somUninit(VRProgress *somSelf)
{
    /* VRProgressData *somThis = VRProgressGetData(somSelf); */
    VRProgressMethodDebug("VRProgress","VRProgressInstance_somUninit");

    parent_somUninit(somSelf);
}

/*
 *  VRProgressInstance_vrLocalCreateWindow
 */

SOM_Scope HWND   SOMLINK VRProgressInstance_vrLocalCreateWindow(VRProgress *somSelf,
		PBOOL visible)
{
    /* VRProgressData *somThis = VRProgressGetData(somSelf); */
    HWND     hWnd = hNULL;
    SWP      swp;
    LONG     flags;
    SOMAny  *pobj;
    HWND     parent;

    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrLocalCreateWindow");

    pobj = get_parent_object( somSelf );
    if( !pobj ) goto leave;

    parent = _vrGetInnerWindow( pobj );
    if( !parent ) goto leave;

    _vrGetWindowPos( somSelf, &swp, VR_PIXELS, TRUE );

    flags = _vrGetWindowFlags( somSelf );
    *visible = ( ( flags & WS_VISIBLE ) != 0 );
    flags &= ~WS_VISIBLE;

    hWnd = WinCreateWindow( parent,
                            _vrGetWindowClass( SOM_GetClass( somSelf ) ),
                            "",
                            flags,
                            swp.x, swp.y,
                            swp.cx, swp.cy,
                            parent,
                            HWND_TOP,
                            _vrGetNewWindowID( somSelf ),
                            NULL, NULL );

  leave:
    return( hWnd );
}

/*
 *  VRProgressInstance_vrSet_Percent
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrSet_Percent(VRProgress *somSelf,
		LONG val)
{
    RECTL rcl, *prcl;
    HWND hWnd;

    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrSet_Percent");

    if (( val > 100 ) | ( val < 0 ))
        return FALSE;

    _usPercent = (USHORT) val;

    hWnd = _vrGetWindowHandle( somSelf );
    if ( WinQueryWindowRect( hWnd, &rcl )) {
        // Remove the border from the update region
        WinInflateRect( WinQueryAnchorBlock( hWnd ), &rcl, -1, -1 );
        if ( _fsFlags & PRO_BORDER_DEEP )
            WinInflateRect( WinQueryAnchorBlock( hWnd ), &rcl, -1, -1 );
        prcl = &rcl;
    }
    else prcl = NULL;
    WinInvalidateRect( hWnd, prcl, FALSE );
    return TRUE;
}

/*
 *  VRProgressInstance_vrGet_Percent
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrGet_Percent(VRProgress *somSelf,
		PLONG val)
{
    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrGet_Percent");

    *val = _usPercent;
    return TRUE;
}

/*
 *  VRProgressInstance_vrSet_BorderType
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrSet_BorderType(VRProgress *somSelf,
		PSZ str)
{

//FILE *f = fopen("C:\\progress.log", "a");

    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrSet_BorderType");

    _fsFlags &= ~PRO_BORDER_ALL;

    if ( str && tolower( *str ) == 'd') {
        _fsFlags |= PRO_BORDER_DEEP;
    }
    else if ( str && tolower( *str ) == 'l') {
        _fsFlags |= PRO_BORDER_LINE;
    }
    // Leave at 0 for 'shallow' style

//fprintf(f, "[vrSet_BorderType]: _fsFlags = 0x%X\n", _fsFlags);

    WinInvalidateRect( _vrGetWindowHandle( somSelf ), NULL, FALSE );

//fclose(f);

    return TRUE;
}

/*
 *  VRProgressInstance_vrGet_BorderType
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrGet_BorderType(VRProgress *somSelf,
		PSZ *str)
{
    PSZ  type;
    BOOL ok = FALSE;
//SWP swp;
//FILE *f = fopen("C:\\progress.log", "a");

    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrGet_BorderType");

//fprintf(f, "[vrSet_BorderType]: _fsFlags = 0x%X\n", _fsFlags);
//fprintf(f, "[vrSet_BorderType]: WindowFlags = 0x%X\n", _vrGetWindowFlags(somSelf) );

//WinQueryWindowPos( _vrGetWindowHandle( somSelf ), &swp);
//fprintf(f, "[vrSet_BorderType]: WindowPos = {0x%X, %d, %d, %d, %d}\n", swp.fl, swp.x, swp.y, swp.cx, swp.cy );

    if ( _fsFlags & PRO_BORDER_DEEP )
        type = "Deep";
    else if ( _fsFlags & PRO_BORDER_LINE )
        type = "Line";
    else
        type = "Shallow";

    *str = VRMemAlloc( strlen( type ) + 1 );
    if ( *str ) {
        strcpy( *str, type );
        ok = TRUE;
    }

//fclose(f);

    return( ok );
}

/*
 *  VRProgressInstance_vrSet_RibbonType
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrSet_RibbonType(VRProgress *somSelf,
		PSZ str)
{
//FILE *f = fopen("C:\\progress.log", "a");

    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrSet_RibbonType");

    _fsFlags &= ~PRO_RIBBON_ALL;

    if ( str && tolower( *str ) == 'f') {
        _fsFlags |= PRO_RIBBON_FLAT;
    }
    // Leave at 0 for 'Raised' style

//fprintf(f, "[vrSet_RibbonType]: _fsFlags = 0x%X\n", _fsFlags);

    WinInvalidateRect( _vrGetWindowHandle( somSelf ), NULL, FALSE );

//fclose(f);

    return TRUE;
}

/*
 *  VRProgressInstance_vrGet_RibbonType
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrGet_RibbonType(VRProgress *somSelf,
		PSZ *str)
{
    PSZ  type;
    BOOL ok = FALSE;

//FILE *f = fopen("C:\\progress.log", "a");

    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrGet_RibbonType");

//fprintf(f, "[vrGet_RibbonType]: _fsFlags = 0x%X\n", _fsFlags);

    if ( _fsFlags & PRO_RIBBON_FLAT )
        type = "Flat";
    else
        type = "Raised";

    *str = VRMemAlloc( strlen( type ) + 1 );
    if ( *str ) {
        strcpy( *str, type );
        ok = TRUE;
    }

//fclose(f);

    return( ok );
}

/*
 *  VRProgressInstance_vrWM_PAINT
 */

SOM_Scope MRESULT   SOMLINK VRProgressInstance_vrWM_PAINT(VRProgress *somSelf,
		HWND hWnd,
		ULONG msg,
		MPARAM mp1,
		MPARAM mp2)
{
    HPS hps;

    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrWM_PAINT");

    hps = WinBeginPaint( hWnd, NULLHANDLE, NULL );
    PaintControl( somSelf, hWnd, hps );
    WinEndPaint( hps );

    return _vrCallDefProc( somSelf, hWnd, msg, mp1, mp2 );
    //return (MRESULT) 0;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMMeta
/*
 *  VRProgressClass_vrLocalClassInit

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


/*
 *  VRProgressClass_vrLocalWindowClassInit
 */

SOM_Scope bool   SOMLINK VRProgressClass_vrLocalWindowClassInit(M_VRProgress *somSelf)
{
    /* M_VRProgressData *somThis = M_VRProgressGetData(somSelf); */
    M_VRProgressMethodDebug("M_VRProgress","VRProgressClass_vrLocalWindowClassInit");

    return( VRRegisterWindowClass( somSelf, NULL, "VRProgress" ) );
}

/*
 *  VRProgressClass_somInit
 */

SOM_Scope void   SOMLINK VRProgressClass_somInit(M_VRProgress *somSelf)
{
    /* M_VRProgressData *somThis = M_VRProgressGetData(somSelf); */
    M_VRProgressMethodDebug("M_VRProgress","VRProgressClass_somInit");

    parent_somInit(somSelf);

    get_picturepath( somSelf ) = VRProgressPicturePath;

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

/*
 *  VRProgressClass_somUninit
 */

SOM_Scope void   SOMLINK VRProgressClass_somUninit(M_VRProgress *somSelf)
{
    /* M_VRProgressData *somThis = M_VRProgressGetData(somSelf); */
    M_VRProgressMethodDebug("M_VRProgress","VRProgressClass_somUninit");

    parent_somUninit(somSelf);
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRProgressInstance_vrWM_PRESPARAMCHANGED
 */

SOM_Scope MRESULT   SOMLINK VRProgressInstance_vrWM_PRESPARAMCHANGED(VRProgress *somSelf,
		HWND hWnd,
		ULONG msg,
		MPARAM mp1,
		MPARAM mp2)
{
    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrWM_PRESPARAMCHANGED");

    WinInvalidateRect( hWnd, NULL, FALSE );
    return (MRESULT) 0;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRProgressInstance_vrSet_RibbonColor
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrSet_RibbonColor(VRProgress *somSelf,
		PSZ str)
{
    HWND hWnd;
    RGB2 rgb2;
    LONG lIdx;
    bool ok;

    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrSet_RibbonColor");
    if ( !str ) return FALSE;

    hWnd = _vrGetWindowHandle( somSelf );
    if ( str[0] == '(') {
        ok = VRColorToRGB2( str, &rgb2 );
        if ( ok ) {
            lIdx = (rgb2.bRed * 65536) + (rgb2.bGreen * 256) + rgb2.bBlue;
#ifdef USE_RIBBON_PP
            WinSetPresParam( hWnd, PP_RIBBONCOLOR, sizeof(LONG), &lIdx );
            WinRemovePresParam( hWnd, PP_RIBBONCOLORINDEX );
#else
            _lRibbonClr = lIdx;
            _fsFlags |= PRO_RIBBON_COLORRGB;
#endif
        }
    }
    else if ( stricmp( str, "<default>") == 0 ) {
        ok = TRUE;
#ifdef USE_RIBBON_PP
        WinRemovePresParam( hWnd, PP_RIBBONCOLORINDEX );
        WinRemovePresParam( hWnd, PP_RIBBONCOLOR );
#else
        _lRibbonClr = 0;
        _fsFlags &= ~PRO_RIBBON_COLORRGB;
#endif
    }
    else {
        lIdx = VRColorToIndex( str );

        if ( lIdx != CLR_NOINDEX ) {
#ifdef USE_RIBBON_PP
            ok = WinSetPresParam( hWnd, PP_RIBBONCOLORINDEX, sizeof(LONG), &lIdx );
            WinRemovePresParam( hWnd, PP_RIBBONCOLOR );
#else
            ok = TRUE;
            _lRibbonClr = lIdx;
            _fsFlags &= ~PRO_RIBBON_COLORRGB;
#endif
        }
    }
    if ( ok ) WinInvalidateRect( hWnd, NULL, FALSE );

    return( ok );
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRProgressInstance_vrGet_RibbonColor
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrGet_RibbonColor(VRProgress *somSelf,
		PSZ *str)
{
    HWND  hWnd;
    LONG  lClr;
    ULONG cb,
          ulID;
    CHAR  achClr[ 40 ];
    PSZ   pszClr;
    BOOL  ok = FALSE;

    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrGet_RibbonColor");

#ifdef USE_RIBBON_PP
    hWnd = _vrGetWindowHandle( somSelf );
    cb = WinQueryPresParam( hWnd, PP_RIBBONCOLORINDEX, PP_RIBBONCOLOR, &ulID,
                            sizeof(lClr), &lClr, QPF_NOINHERIT );

    if ( cb ) {
        if ( ulID == PP_RIBBONCOLORINDEX ) {
            pszClr = VRIndexToColor( lClr );
            if ( !pszClr ) {
                strcpy( achClr, "<default>");
            }
            else {
                strncpy( achClr, pszClr, sizeof(achClr) - 1 );
            }
        }
        else
            sprintf( achClr, "(%u,%u,%u)",
                     RGBVAL_RED( lClr ), RGBVAL_GREEN( lClr ), RGBVAL_BLUE( lClr ));
    }
    else strcpy( achClr, "<default>");
#else
    if ( ! _lRibbonClr )
        strcpy( achClr, "<default>");
    else if ( _fsFlags & PRO_RIBBON_COLORRGB )
        sprintf( achClr, "(%u,%u,%u)",
                 RGBVAL_RED( _lRibbonClr ), RGBVAL_GREEN( _lRibbonClr ), RGBVAL_BLUE( _lRibbonClr ));
    else {
        pszClr = VRIndexToColor( _lRibbonClr );
        if ( !pszClr )
            strcpy( achClr, "<default>");
        else
            strncpy( achClr, pszClr, sizeof(achClr) - 1 );
    }
#endif

    *str = VRMemAlloc( strlen( achClr ) + 1 );
    if ( *str ) {
        strcpy( *str, achClr );
        ok = TRUE;
    }

    return( ok );
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRProgressInstance_vrSet_ShowPercent
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrSet_ShowPercent(VRProgress *somSelf,
		BOOL on)
{
    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrSet_ShowPercent");

    if ( on )
        _fsFlags |= PRO_PERCENT_SHOW;
    else
        _fsFlags &= ~PRO_PERCENT_SHOW;

    WinInvalidateRect( _vrGetWindowHandle( somSelf ), NULL, FALSE );
    return TRUE;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRProgressInstance_vrGet_ShowPercent
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrGet_ShowPercent(VRProgress *somSelf,
		BOOL *on)
{
    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrGet_ShowPercent");

    *on = ( _fsFlags & PRO_PERCENT_SHOW ) ? TRUE : FALSE;

    WinInvalidateRect( _vrGetWindowHandle( somSelf ), NULL, FALSE );
    return TRUE;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRProgressInstance_vrSet_InvertRibbonText
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrSet_InvertRibbonText(VRProgress *somSelf,
		BOOL on)
{
    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrSet_InvertRibbonText");

    if ( on )
        _fsFlags |= PRO_PERCENT_INVERT;
    else
        _fsFlags &= ~PRO_PERCENT_INVERT;

    WinInvalidateRect( _vrGetWindowHandle( somSelf ), NULL, FALSE );
    return TRUE;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRProgressInstance_vrGet_InvertRibbonText
 */

SOM_Scope bool   SOMLINK VRProgressInstance_vrGet_InvertRibbonText(VRProgress *somSelf,
		BOOL *on)
{
    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrGet_InvertRibbonText");

    *on = ( _fsFlags & PRO_PERCENT_INVERT ) ? TRUE : FALSE;
    WinInvalidateRect( _vrGetWindowHandle( somSelf ), NULL, FALSE );
    return TRUE;
}

#undef SOM_CurrentClass
#define SOM_CurrentClass SOMInstance

/*
 *  VRProgressInstance_vrWM_CONTROLPOINTER
 */

SOM_Scope MRESULT   SOMLINK VRProgressInstance_vrWM_CONTROLPOINTER(VRProgress *somSelf,
		HWND hWnd,
		ULONG msg,
		MPARAM mp1,
		MPARAM mp2)
{
    VRProgressData *somThis = VRProgressGetData(somSelf);
    VRProgressMethodDebug("VRProgress","VRProgressInstance_vrWM_CONTROLPOINTER");

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