Compilando una rutina de menu

[cnavarro]

Horacio, y la funcion _DegradColor ?

[horacio]

No veo en el codigo que postee la funcion que nombraste.

Saludos

[cnavarro]

Code: Select all  Expand view

void WindowBoxIn( HDC hDC, RECT * pRect );
void WndDrawBox( HDC hDC, RECT * rct, HPEN hPUpLeft, HPEN hPBotRit );
void WindowInset( HDC hDC, RECT * pRect );
void WindowRaised( HDC hDC, RECT * pRect );
void DrawBitmap( HDC, HBITMAP, WORD, WORD, WORD, WORD, DWORD );
void DrawMasked( HDC, HBITMAP, WORD, WORD );
void DrawGrayed( HDC, HBITMAP, int, int );
void RectDisable( HDC, LPRECT);
void DegardeFill( HDC hDC, RECT * rori, COLORREF cFrom, COLORREF cTo, int nDegType ) ;
void DegradColor( HDC hDC, RECT * rori, COLORREF cFrom, COLORREF cTo, int nDegType, int iRound ) ;    // Aqui

//----------------------------------------------------------------------------//


 

[cnavarro]

Asi compila sin errores, otra cosa es hacerlo funcionar

Code: Select all  Expand view

#define OEMRESOURCE


//#include <WinTen.h>
#include <Windows.h>
//#include <ClipApi.h>
#include <HbApi.h>
//#include <hbapiitm.h>

BOOL bStrAt( BYTE bChar, LPSTR szText );
LPSTR StrToken( LPSTR szText, WORD wOcurrence, BYTE bSeparator, LPWORD pwLen );

void WindowBoxIn( HDC hDC, RECT * pRect );
void WndDrawBox( HDC hDC, RECT * rct, HPEN hPUpLeft, HPEN hPBotRit );
void WindowInset( HDC hDC, RECT * pRect );
void WindowRaised( HDC hDC, RECT * pRect );
void DrawBitmap( HDC, HBITMAP, WORD, WORD, WORD, WORD, DWORD );
void DrawMasked( HDC, HBITMAP, WORD, WORD );
void DrawGrayed( HDC, HBITMAP, int, int );
void RectDisable( HDC, LPRECT);
void DegardeFill( HDC hDC, RECT * rori, COLORREF cFrom, COLORREF cTo, int nDegType ) ;
void DegradColor( HDC hDC, RECT * rori, COLORREF cFrom, COLORREF cTo, int nDegType, int iRound ) ;

//----------------------------------------------------------------------------//

HB_FUNC( CREATEMENU )
{
   hb_retnl( ( LONG ) CreateMenu() );
}

//----------------------------------------------------------------------------//

HB_FUNC( CREATEPOPUPMENU )
{
   hb_retnl( ( LONG ) CreatePopupMenu() );
}

//----------------------------------------------------------------------------//

HB_FUNC( TRACKPOPUP )
{
  hb_retl( TrackPopupMenu( ( HMENU ) hb_parnl( 1 ), hb_parni( 2 ), hb_parni( 4 ),
         hb_parni( 3 ), hb_parni( 5 ), ( HWND ) hb_parni( 6 ), NULL ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( ENABLEMENUITEM )
{
   hb_retl( EnableMenuItem( ( HMENU ) hb_parnl( 1 ), hb_parni( 2 ), hb_parni( 3 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( CHECKMENUITEM )   // ()
{
   hb_retl( CheckMenuItem( ( HMENU ) hb_parnl( 1 ), hb_parni( 2 ), hb_parni( 3 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( GETMITEMCOUNT )   // ()
{
   hb_retni( GetMenuItemCount( ( HMENU ) hb_parnl( 1 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( GETMITEMID )    // hMenu, nPos
{
   hb_retni( GetMenuItemID( ( HMENU ) hb_parnl( 1 ), hb_parni( 2 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( GETSYSTEMMENU )    // ()
{
   hb_retnl( ( LONG ) GetSystemMenu( ( HWND ) hb_parnl( 1 ), hb_parl( 2 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( DESTROYMENU )   //  ()   hMenu
{
   hb_retl( DestroyMenu( ( HMENU ) hb_parnl( 1 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( GETSUBMENU )    // hMenu, nPos
{
   hb_retnl( ( LONG ) GetSubMenu( ( HMENU ) hb_parnl( 1 ), hb_parni( 2 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( GETMENUSTRING )    // ()   hMenu, nId, nPosOrValue
{
   BYTE bBuffer[ 200 ];
   WORD wLen = GetMenuString( ( HMENU ) hb_parnl( 1 ), hb_parni( 2 ), ( char * ) bBuffer,
                              199, hb_parni( 3 ) );

   hb_retclen( ( char * ) bBuffer, wLen );
}

//----------------------------------------------------------------------------//

HB_FUNC( GETMENUSTATE )    // ()   hMenu, nId, nFlags
{
   hb_retni( GetMenuState( ( HMENU ) hb_parnl( 1 ), hb_parni( 2 ), hb_parni( 3 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( DRAWMENUBAR )    // ()    hWnd
{
   DrawMenuBar( ( HWND ) hb_parnl( 1 ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( HILITEMENUITEM )  // ()  hWnd, hMenu, idItem, nHiliteFlags
{
   hb_retl( HiliteMenuItem( ( HWND ) hb_parnl( 1 ), ( HMENU ) hb_parnl( 2 ),
                          hb_parni( 3 ), hb_parni( 4 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( LOADMENU )
{
   if ( HB_ISCHAR( 2 ) )
      hb_retnl( ( LONG ) LoadMenu( ( HINSTANCE ) hb_parnl( 1 ),
                     ( LPSTR ) hb_parc( 2 ) ) );
   else
      hb_retnl( ( LONG ) LoadMenu( ( HINSTANCE ) hb_parnl( 1 ),
                     ( LPSTR ) MAKEINTRESOURCE( hb_parni( 2 ) ) ) ) ;
}

//----------------------------------------------------------------------------//

HB_FUNC( APPENDMENU )
{
   if ( HB_ISCHAR( 4 ) )
      hb_retl( AppendMenu( ( HMENU ) hb_parnl( 1 ), ( UINT ) hb_parnl( 2 ), hb_parnl( 3 ),
                       hb_parc( 4 ) ) );
   else  
      hb_retl( AppendMenu( ( HMENU ) hb_parnl( 1 ), ( UINT ) hb_parnl( 2 ), hb_parnl( 3 ),
                       ( LPSTR ) hb_parnl( 4 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( SETMENU )
{
   hb_retl( SetMenu( ( HWND ) hb_parnl( 1 ), ( HMENU ) hb_parnl( 2 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( MODIFYMENU )
{
   if ( HB_ISCHAR( 5 ) )
      hb_retl( ModifyMenu( ( HMENU ) hb_parnl( 1 ), ( UINT ) hb_parni( 2 ),
          hb_parni( 3 ), ( UINT ) hb_parni( 4 ), hb_parc( 5 ) ) );
   else
      hb_retl( ModifyMenu( ( HMENU ) hb_parvnl( 1 ), ( UINT ) hb_parvni( 2 ),
          hb_parni( 3 ), ( UINT ) hb_parni( 4 ), ( LPSTR ) hb_parnl( 5 ) ) ) ;
}

//----------------------------------------------------------------------------//

HB_FUNC( INSERTMENU ) // ( hMenu, nIdItem, nFlags, nNewItem, cPrompt ) --> lSuccess
{
   hb_retl( InsertMenu( ( HMENU ) hb_parnl( 1 ), hb_parni( 2 ), hb_parni( 3 ),
                      hb_parni( 4 ), hb_parc( 5 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( REMOVEMENU ) // ( hMenu, nItem, nFlags ) --> lSuccess
{
   hb_retl( RemoveMenu( ( HMENU ) hb_parnl( 1 ),
                      ( UINT ) hb_parni( 2 ),
                      ( UINT ) hb_parni( 3 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( ATMENUDRAWITEM ) // ( pDrawItemStruct, cPrompt, lTop, hBitmap,lSeparator,acolor,lbar )
{
   LPDRAWITEMSTRUCT lpdis = ( LPDRAWITEMSTRUCT ) hb_parnl( 1 );
   LPSTR szPrompt = ( char * ) hb_parc( 2 );
   BOOL bTab = bStrAt( 9, szPrompt );
   WORD wLen;
   BOOL lSeparator = hb_parl( 5 );
   BOOL lBar       = hb_parl( 7 );
   HPEN hNormal, hOldPen;
   HBRUSH hBrush;
   LOGBRUSH lb;
   RECT rct;
   RECT rctdg;
   RECT rctsep;
   RECT rctshd;
   COLORREF nClrMenu     =  hb_parvnl(6,1);
   COLORREF nClrMenuTxt  =  hb_parvnl(6,2);
   COLORREF nClrBack     =  hb_parvnl(6,3);
   COLORREF nClrTo       =  hb_parvnl(6,4);
   COLORREF nClrHighBai  =  hb_parvnl(6,5);
   COLORREF nClrHighBaf  =  hb_parvnl(6,6);
   COLORREF nClrHighTxt  =  hb_parvnl(6,7);
   COLORREF nClrHighBar  =  hb_parvnl(6,8);

   HBITMAP hBmp = ( HBITMAP ) hb_parnl( 4 );
   
   HGDIOBJ hOldFont;
   switch( lpdis->itemAction )
   {
      case ODA_DRAWENTIRE:
      case ODA_SELECT:
           lb.lbStyle = BS_SOLID;
           lb.lbColor = nClrMenu;
           hBrush = CreateBrushIndirect( &lb );
           FillRect( lpdis->hDC, &lpdis->rcItem, hBrush );
           DeleteObject( hBrush );

           SetBkColor( lpdis->hDC, nClrMenu );
           SetBkMode( lpdis->hDC, TRANSPARENT );
           SetTextColor( lpdis->hDC, nClrMenuTxt);


           if( lpdis->itemState & ODS_SELECTED &&
               ! ( lpdis->itemState & ODS_GRAYED ) && !lSeparator )
           {
              lb.lbColor = nClrHighBai;
              SetBkColor( lpdis->hDC, nClrHighBai );
              SetTextColor( lpdis->hDC, nClrHighTxt );
              if( !lBar )
                lpdis->rcItem.left += 22;
           }
           else
              lb.lbColor = nClrMenu;


           hBrush = CreateBrushIndirect( &lb );
           FillRect( lpdis->hDC, &lpdis->rcItem, hBrush );
           DeleteObject( hBrush );
           if( lpdis->itemState & ODS_SELECTED &&
              ! ( lpdis->itemState & ODS_GRAYED ) )
           {
             if( !lBar )
                 lpdis->rcItem.left -= 22;
           }

           if(!lBar)
           {
             rct.top    = lpdis->rcItem.top+1;
             rct.left   = lpdis->rcItem.left+1;
             rct.right  = lpdis->rcItem.right-1; //22;
             rct.bottom = lpdis->rcItem.bottom - 2;
           }
           else
           {
             rct.top    = lpdis->rcItem.top+1;
             rct.left   = lpdis->rcItem.left+1;
             rct.right  = lpdis->rcItem.right-4;
             rct.bottom = lpdis->rcItem.bottom - 1;

             rctshd.top    = lpdis->rcItem.top+3;
             rctshd.left   = lpdis->rcItem.right-3;
             rctshd.right  = lpdis->rcItem.right;
             rctshd.bottom = lpdis->rcItem.bottom;

           }

           rctdg.top    = lpdis->rcItem.top-1; //-4
           rctdg.left   = lpdis->rcItem.left;
           rctdg.right  = 22;
           rctdg.bottom = lpdis->rcItem.bottom+1; // - 1;

           if( !lBar )
              DegradColor( lpdis->hDC, &rctdg, nClrBack, nClrTo, 2, 1 ) ;

           if( lpdis->itemState & ODS_SELECTED )
              if( ! ( lpdis->itemState & ODS_GRAYED ) ) //&&
                {
                     hNormal = CreatePen(PS_SOLID,0,nClrHighBar);
                     hOldPen = SelectObject(lpdis->hDC,hNormal);
                     Rectangle(lpdis->hDC,rct.left-1,rct.top-1,rct.right+1,rct.bottom+1);
                     SelectObject(lpdis->hDC,hOldPen);
                     DeleteObject( hNormal );
                     DegradColor( lpdis->hDC, &rct, nClrHighBai, nClrHighBaf, 1, 1 ) ;
                     if(lBar)
                     {
                       lb.lbColor = GetSysColor(16);
                       hBrush = CreateBrushIndirect( &lb );
                       FillRect( lpdis->hDC, &rctshd, hBrush );
                       DeleteObject( hBrush );
                       rctshd.top    = lpdis->rcItem.top;
                       rctshd.left   = lpdis->rcItem.right-3;
                       rctshd.right  = lpdis->rcItem.right;
                       rctshd.bottom = lpdis->rcItem.top+3;
                       lb.lbColor = nClrMenu;
                       hBrush = CreateBrushIndirect( &lb );
                       FillRect( lpdis->hDC, &rctshd, hBrush );
                       DeleteObject( hBrush );

                     }
                }
if(!lBar)
{

           if( lpdis->itemState & ODS_CHECKED )
           {
              HBITMAP hBmp = LoadBitmap( 0, MAKEINTRESOURCE( OBM_CHECK ) );

              if( ! ( lpdis->itemState & ODS_SELECTED ) )
                 DrawMasked( lpdis->hDC, hBmp, lpdis->rcItem.top + 3,
                             lpdis->rcItem.left + 4 );
              else
                 DrawMasked( lpdis->hDC, hBmp, lpdis->rcItem.top + 3,
                             lpdis->rcItem.left + 4 );
              DeleteObject( hBmp );
           }


           if( hBmp  && !( (int) hBmp == 1 )  )
           {
              if( ! ( lpdis->itemState & ODS_CHECKED ) )
                 DrawMasked( lpdis->hDC, hBmp, lpdis->rcItem.top + 3, //ojo
                            lpdis->rcItem.left + 2 );
              else
                 if( ! ( lpdis->itemState & ODS_SELECTED ) )
                    DrawGrayed( lpdis->hDC, hBmp, lpdis->rcItem.top + 3,
                                lpdis->rcItem.left + 2 );
                 else
                    DrawMasked( lpdis->hDC, hBmp, lpdis->rcItem.top + 3,
                                lpdis->rcItem.left + 2 );
           }
}
           if(!lBar)
           {
             lpdis->rcItem.top  += 4;
             lpdis->rcItem.left += 26;
           }
           else
           {
             lpdis->rcItem.top  += 2;
             lpdis->rcItem.left += 3;
           }            
           if( !bTab )
           {
              if( lSeparator )
              {
                 rctsep.top    = lpdis->rcItem.top-1;
                 rctsep.left   = lpdis->rcItem.left;
                 rctsep.right  = lpdis->rcItem.right+5;
                 rctsep.bottom = lpdis->rcItem.bottom - 4;
                 lb.lbStyle = BS_SOLID;
                 lb.lbColor = nClrHighBar ;
                 hBrush = CreateBrushIndirect( &lb );
                 FillRect( lpdis->hDC, &rctsep, hBrush );
                 DeleteObject( hBrush );
              }
              else
              {
              if(!lBar)
                {
                   DrawText( lpdis->hDC, szPrompt, -1, &lpdis->rcItem, DT_LEFT );
                }
                else
                {
                   lpdis->rcItem.left -= 5;
                   DrawText( lpdis->hDC, szPrompt, -1, &lpdis->rcItem, DT_CENTER );
                   lpdis->rcItem.left += 5;
                }
              }
           }
           else
           {
              lpdis->rcItem.right -= 26;
              StrToken( szPrompt, 1, 9, &wLen ); // 32 bits does not fill wLen before
              DrawText( lpdis->hDC, StrToken(szPrompt, 1, 9, &wLen), wLen, &lpdis->rcItem, DT_LEFT );
              StrToken( szPrompt, 2, 9, &wLen ); // 32 bits does not fill wLen before
              DrawText( lpdis->hDC, StrToken(szPrompt, 2, 9, &wLen), wLen, &lpdis->rcItem, DT_RIGHT );
              lpdis->rcItem.right += 26;
           }
           if(!lBar)
           {
             /*
              if( !lSeparator )
                {
                if( lpdis->itemState & ODS_GRAYED )
                   RectDisable( lpdis->hDC, &lpdis->rcItem );
                }
             */
             lpdis->rcItem.top  -= 4;
             lpdis->rcItem.left -= 26;
           }
           else
           {
             lpdis->rcItem.top  -= 2;
             lpdis->rcItem.left -= 4;
           }



           hb_retl( TRUE );
           break;

      case ODA_FOCUS:
           hb_retl( FALSE );
           break;
   }
}

//----------------------------------------------------------------------------//
/*
#ifdef __HARBOUR__
   CLIPPER MENUMEASUREITEM( PARAMS ) // ( pMeasureItemStruct, nLen )
#else
   CLIPPER MENUMEASUR( PARAMS ) // EITEM( pMeasureItemStruct, nLen )
#endif
{
   LPMEASUREITEMSTRUCT lp = ( LPMEASUREITEMSTRUCT ) _parnl( 1 );
   lp->itemWidth  = hb_parni( 2 );
   lp->itemHeight = GetSystemMetrics( SM_CYMENU ); //18
}
*/
//----------------------------------------------------------------------------//

HB_FUNC( GETMEAITEM ) // ( pMeasureItemStruct ) --> nMenuItemID
{
   LPMEASUREITEMSTRUCT lp = ( LPMEASUREITEMSTRUCT ) hb_parnl( 1 );

   hb_retnl( lp->itemID );
}

//----------------------------------------------------------------------------//

HB_FUNC( GETDRAWITEM ) // ( pDrawItemStruct ) --> nMenuItemID
{
   LPDRAWITEMSTRUCT lpdis = ( LPDRAWITEMSTRUCT ) hb_parnl( 1 );

   hb_retnl( lpdis->itemID );
}

//----------------------------------------------------------------------------//

HB_FUNC( GETDRAWMENU ) // ( pDrawItemStruct ) --> hMenu
{
   LPDRAWITEMSTRUCT lpdis = ( LPDRAWITEMSTRUCT ) hb_parnl( 1 );

   hb_retnl( ( LONG ) lpdis->hwndItem );
}

//----------------------------------------------------------------------------//

HB_FUNC( ISMENU )
{
   hb_retl( IsMenu( ( HMENU ) hb_parnl( 1 ) ) );
}

//----------------------------------------------------------------------------//

HB_FUNC( _GETMENUID )
{
    hb_retnl((LONG)GetMenu((HWND) hb_parnl(1)));
}

//----------------------------------------------------------------------------//

HB_FUNC ( _COLORMENU )
{
   HMENU      iMenu;
   MENUINFO   iMenuInfo ;
   COLORREF lColor = hb_parnl(2);
   BOOL  lSubMenu = hb_parl(3);
   HWND  himage ;

   himage = (HWND)LoadImage(0,hb_parc(4),IMAGE_BITMAP ,0,0,LR_LOADFROMFILE | LR_LOADMAP3DCOLORS | LR_LOADTRANSPARENT );

   if (himage==NULL)
     {
       himage = (HWND)LoadImage(GetModuleHandle(NULL),hb_parc(4),IMAGE_BITMAP ,0,0, LR_LOADMAP3DCOLORS    | LR_LOADTRANSPARENT );
     }
   iMenu              = GetMenu((HWND) hb_parnl(1));
   GetMenuInfo(iMenu, &iMenuInfo);
   iMenuInfo.cbSize   = sizeof(MENUINFO);
   iMenuInfo.dwStyle  = GetWindowLongPtr( (HWND) hb_parnl(1), GWL_STYLE );

   if (lSubMenu)
    {
      iMenuInfo.fMask    = MIM_BACKGROUND | MIM_APPLYTOSUBMENUS ;
    }
   else
    {
      iMenuInfo.fMask    = MIM_BACKGROUND;
    }

   if (himage==NULL)
    {
       iMenuInfo.hbrBack = CreateSolidBrush(lColor);
    }
   else
    {
       iMenuInfo.hbrBack = CreatePatternBrush( (HBITMAP) himage);
    }

   SetMenuInfo(iMenu, &iMenuInfo);
   DrawMenuBar((HWND) hb_parnl(1));

}

//----------------------------------------------------------------------------//

HB_FUNC ( _COLORSUBMENU )
{
   HMENU      iMenu;
   MENUINFO   iMenuInfo ;
   COLORREF lColor = hb_parnl(2);
   iMenu              = GetMenu((HWND) hb_parnl(1));
   GetMenuInfo(iMenu, &iMenuInfo);
   iMenuInfo.cbSize   = sizeof(MENUINFO);
   iMenuInfo.fMask    = MIM_BACKGROUND | MIM_APPLYTOSUBMENUS;
   iMenuInfo.hbrBack  = CreateSolidBrush(lColor);
   SetMenuInfo(iMenu, &iMenuInfo);
//   DrawMenuBar((HWND) _parnl(1));
}

//----------------------------------------------------------------------------//
HB_FUNC( CHGMENUMEA ) // pMeasureItemStruct, nWidth, nHeight
{
   LPMEASUREITEMSTRUCT lp = ( LPMEASUREITEMSTRUCT ) hb_parnl( 1 );
   lp->itemWidth  = hb_parni( 2 ) ;
   lp->itemHeight = hb_parni( 3 ) ;
}

HB_FUNC( GETDRAWISR ) // ( pDrawitemstruct )
{
   LPDRAWITEMSTRUCT lp = ( LPDRAWITEMSTRUCT ) hb_parnl( 1 );

   hb_reta( 12 );

   hb_storvni( lp->CtlType      ,    -1, 1  );
   hb_storvni( lp->CtlID        ,    -1, 2  );
   hb_storvni( lp->itemID       ,    -1, 3  );
   hb_storvni( lp->itemAction   ,    -1, 4  );
   hb_storvni( lp->itemState    ,    -1, 5  );
   hb_storvni( ( LONG ) lp->hwndItem     ,    -1, 6  );
   hb_storvni( ( LONG ) lp->hDC          ,    -1, 7  );
   hb_storvni( lp->rcItem.top   ,    -1, 8  );
   hb_storvni( lp->rcItem.left  ,    -1, 9  );
   hb_storvni( lp->rcItem.bottom,    -1, 10 );
   hb_storvni( lp->rcItem.right ,    -1, 11 );
   hb_storvnd( lp->itemData     ,    -1, 12 );

}

HB_FUNC( GETMEAUSUR ) // ( pMeasureItemStruct )
{
   LPMEASUREITEMSTRUCT lp = ( LPMEASUREITEMSTRUCT ) hb_parnl( 1 );

   hb_reta( 6 );

   hb_storvni( lp->CtlType      ,    -1, 1  );
   hb_storvni( lp->CtlID        ,    -1, 2  );
   hb_storvni( lp->itemID       ,    -1, 3  );
   hb_storvni( lp->itemWidth    ,    -1, 4  );
   hb_storvni( lp->itemHeight   ,    -1, 5  );
   hb_storvnd( lp->itemData     ,    -1, 12 );

}

//----------------------------------------------------------------------------//

 

[horacio]

Ahhh, ok. Me habia olvidado de esa rutina. Aqui te mando la otra rutina en C.

Code: Select all  Expand view

#include <WinTen.h>  
#include <Windows.h>
#include <hbApi.h>  
#include <commctrl.h>
#include <StdLib.h>

void DegradColor( HDC hDC, RECT * rori, COLORREF cFrom, COLORREF cTo, int iType, int iRound )
{
   int clr1r, clr1g, clr1b, clr2r, clr2g, clr2b ;
   signed int iEle, iRed, iGreen, iBlue, iTot, iHalf ;
   BOOL bHorz = ( iType == 2 || iType == 4 ) ;
   BOOL bDir ;
   RECT rct ;
   HPEN hOldPen, hPen ;
   LOGBRUSH lb ;
   HBRUSH hOldBrush, hBrush, hNull ;

   rct.top = rori->top ;
   rct.left = rori->left ;
   rct.bottom = rori->bottom ;
   rct.right = rori->right ;

    iTot   = ( ! bHorz ? ( rct.bottom  - rct.top + 1 ) : ( rct.right - rct.left + 1 ) ) ;

   iHalf  = iTot / 2 ;
    lb.lbStyle = BS_NULL ;
    hNull  = CreateBrushIndirect(&lb) ;

   clr1r = GetRValue( cFrom ) ;
   clr1g = GetGValue( cFrom ) ;
   clr1b = GetBValue( cFrom ) ;

   clr2r = GetRValue( cTo ) ;
   clr2g = GetGValue( cTo ) ;
   clr2b = GetBValue( cTo ) ;

   iRed   =  abs( clr2r - clr1r ) ;
   iGreen =  abs( clr2g - clr1g ) ;
   iBlue  =  abs( clr2b - clr1b ) ;

   iRed   = ( iRed <= 0 ? 0 : ( iRed / iTot ) );
   iGreen = ( iGreen <= 0 ? 0 : ( iGreen / iTot ) ) ;
   iBlue  = ( iBlue <= 0 ? 0 : ( iBlue / iTot ) ) ;

   if( iType == 3 || iType == 4 )
   {
    iRed   *= 2 ;
      iGreen *= 2 ;
      iBlue  *= 2 ;
   }

   if( iType == 5 )
   {
      rct.top  += ( ( rct.bottom - rct.top ) / 2 ) ;
      rct.left += ( ( rct.right - rct.left ) / 2 ) ;
      rct.top  -= ( ( rct.bottom - rct.top ) / 3 ) ;
      rct.bottom = rct.top + 2 ;
      rct.right  = rct.left + 2 ;
   }
   else
   {
    if( ! bHorz )
        rct.bottom = rct.top + 1 ;
       else
        rct.right = rct.left + 1 ;
   }


   if( iType == 5 )
   {
       hPen      = CreatePen( PS_SOLID, 1, RGB( clr2r, clr2g, clr2b ) ) ;
    hOldPen   = SelectObject( hDC, hPen ) ;
        hBrush    = CreateSolidBrush( RGB( clr2r, clr2g, clr2b ) ) ;
    hOldBrush = SelectObject( hDC, hBrush ) ;
      if( iRound == 1 )
            Ellipse( hDC, rori->left, rori->top, rori->right, rori->bottom ) ;
      else
            RoundRect( hDC, rori->left, rori->top, rori->right, rori->bottom, 16, 16 ) ;

    SelectObject( hDC, hOldBrush ) ;
       DeleteObject( hBrush ) ;
    SelectObject( hDC, hOldPen ) ;
       DeleteObject( hPen ) ;
       hPen    = CreatePen( PS_SOLID, 2, RGB( clr1r, clr1g, clr1b ) ) ;
    hOldPen = SelectObject( hDC, hPen ) ;
    SelectObject( hDC, hNull ) ;
      if( iRound == 1 )
            Ellipse( hDC, rct.left, rct.top, rct.right, rct.bottom ) ;
      else
            RoundRect( hDC, rct.left, rct.top, rct.right, rct.bottom, 16, 16 ) ;

   }
   else
   {
       hPen      = CreatePen( PS_SOLID, 1, RGB( clr1r, clr1g, clr1b ) ) ;
    hOldPen   = SelectObject( hDC, hPen ) ;
        hBrush    = CreateSolidBrush( RGB( clr1r, clr1g, clr1b ) ) ;
    hOldBrush = SelectObject( hDC, hBrush ) ;
   }

   for( iEle = 1; iEle < iTot; iEle++ )
   {

        if( iType > 2 && iType < 5 && iEle > iHalf )
      {
        clr2r = GetRValue( cFrom ) ;
        clr2g = GetGValue( cFrom ) ;
        clr2b = GetBValue( cFrom ) ;
      }

      bDir = ( clr2r > clr1r ? TRUE : FALSE ) ;
      if( bDir )
        clr1r += iRed ;
      else
        clr1r -= iRed ;

      clr1r = ( clr1r < 0 ? 0 : clr1r > 255 ? 255 : clr1r ) ;

      bDir = ( clr2g > clr1g ? TRUE : FALSE  ) ;
      if( bDir )
        clr1g += iGreen ;
      else
        clr1g -= iGreen ;

      clr1g = ( clr1g < 0 ? 0 : clr1g > 255 ? 255 : clr1g ) ;

      bDir = ( clr2b > clr1b ? TRUE : FALSE  ) ;

      if( bDir )
        clr1b += iBlue ;
      else
        clr1b -= iBlue ;

      clr1b = ( clr1b < 0 ? 0 : clr1b > 255 ? 255 : clr1b ) ;

      if( iType == 5 )
      {
              SelectObject( hDC, hOldBrush ) ;
           DeleteObject( hNull ) ;
                hNull  = CreateBrushIndirect(&lb) ;
              SelectObject( hDC, hNull ) ;
          SelectObject( hDC, hOldPen ) ;
            DeleteObject( hPen ) ;
            hPen = CreatePen( PS_SOLID, 2, RGB( clr1r, clr1g, clr1b ) ) ;
            SelectObject( hDC, hPen ) ;
       if( iRound == 1 )
            Ellipse( hDC, rct.left, rct.top, rct.right + 1, rct.bottom + 1 ) ;
          else
            RoundRect( hDC, rct.left, rct.top, rct.right + 1, rct.bottom + 1, 16, 16 ) ;

          if( iRound == 1 )
            Ellipse( hDC, rct.left, rct.top, rct.right + 1, rct.bottom + 1 ) ;
        else
            RoundRect( hDC, rct.left, rct.top, rct.right + 1, rct.bottom + 1, 16, 16 ) ;

            rct.top    -= ( rct.top <= rori->top ? 0 : 1 ) ;
            rct.left   -= ( rct.left <= rori->left ? 0 : 1 );
            rct.bottom +=  ( rct.bottom >= rori->bottom ? 0 : 1 ) ;
            rct.right  +=  ( rct.right >= rori->right ? 0 : 1 ) ;
       }
      else
      {
          SelectObject( hDC, hOldBrush ) ;
       DeleteObject( hBrush ) ;
        hBrush = CreateSolidBrush( RGB( clr1r, clr1g, clr1b ) ) ;
          SelectObject( hDC, hBrush ) ;

        FillRect( hDC, &rct, hBrush ) ;

        if( ! bHorz )
        {
                rct.top++ ;
        rct.bottom++ ;
        }
        else
        {
            rct.left++ ;
            rct.right++ ;
        }
      }
   }
    SelectObject( hDC, hOldBrush ) ;
    SelectObject( hDC, hOldPen ) ;
   DeleteObject( hBrush ) ;
   DeleteObject( hPen ) ;
   DeleteObject( hNull ) ;
}

//---------------------------------------------------------------------------//

void DegardeFill( HDC hDC, RECT* rct, COLORREF crStart, COLORREF crEnd, int bVertical )
    {
       int nSegments = 100;
       COLORREF cr;
       int nR      = GetRValue(crStart);
       int nG      = GetGValue(crStart);
       int nB      = GetBValue(crStart);
       int neB     = GetBValue(crEnd);
       int neG     = GetGValue(crEnd);
       int neR     = GetRValue(crEnd);
       int nDiffR  = (neR - nR);
       int nDiffG  = (neG - nG);
       int nDiffB  = (neB - nB);
       int ndR ;
       int ndG ;
       int ndB ;
       int nCX ;
       int nCY ;
       int nTop    = rct->top;
       int nBottom ; //= rct->bottom;
       int nLeft   = rct->left;
       int nRight ; // = rct->right;
       HBRUSH hBrush;
       RECT rc;

       int i;

       if( !bVertical )
       {
          if( nSegments > ( rct->right - rct->left ) )
          {
            nSegments = ( rct->right - rct->left );
          }
       }
       else
       {
          if( nSegments > ( rct->bottom - rct->top ) )
          {
            nSegments = ( rct->bottom - rct->top );
          }
       }

       ndR = 256 * (nDiffR) / (max(nSegments,1));
       ndG = 256 * (nDiffG) / (max(nSegments,1));
       ndB = 256 * (nDiffB) / (max(nSegments,1));
       nCX = (rct->right-rct->left) / max(nSegments,1);
       nCY = (rct->bottom-rct->top) / max(nSegments,1);

       nR *= 256;
       nG *= 256;
       nB *= 256;

       for (i = 0; i < nSegments; i++, nR += ndR, nG += ndG, nB += ndB)
       {

               if(i == (nSegments - 1))
               {
                  nRight  = rct->right;
                  nBottom = rct->bottom;
               }
               else
               {
                  nBottom = nTop + nCY;
                  nRight = nLeft + nCX;
               }

               cr = RGB(nR / 256, nG / 256, nB / 256);

               {
                  hBrush = CreateSolidBrush( cr );
                  if( bVertical )
                  {
                     rc.top    = nTop;
                     rc.left   = rct->left;
                     rc.bottom = nBottom + 1;
                     rc.right  = rct->right;
                  }
                  else
                  {
                     rc.top    = rct->top;
                     rc.left   = nLeft;
                     rc.bottom = rct->bottom;
                     rc.right  = nRight+1;
                  }
                  FillRect(hDC, &rc, hBrush );
                  DeleteObject( hBrush );
               }

               nLeft = nRight;
               nTop = nBottom;
       }
    }

COLORREF MixedColor(COLORREF colorA,COLORREF colorB)
{
  // ( 86a + 14b ) / 100
  int red   = MulDiv(86,GetRValue(colorA),100) + MulDiv(14,GetRValue(colorB),100);
  int green = MulDiv(86,GetGValue(colorA),100) + MulDiv(14,GetGValue(colorB),100);
  int blue  = MulDiv(86,GetBValue(colorA),100) + MulDiv(14,GetBValue(colorB),100);

  return RGB( min(red,0xff),min(green,0xff), min(blue,0xff));
}

COLORREF MidColor(COLORREF colorA,COLORREF colorB)
{
  // (7a + 3b)/10
  int red   = MulDiv(7,GetRValue(colorA),10) + MulDiv(3,GetRValue(colorB),10);
  int green = MulDiv(7,GetGValue(colorA),10) + MulDiv(3,GetGValue(colorB),10);
  int blue  = MulDiv(7,GetBValue(colorA),10) + MulDiv(3,GetBValue(colorB),10);

  return RGB( min(red,0xff),min(green,0xff), min(blue,0xff));
}

COLORREF GrayColor(COLORREF crColor)
{
  int Gray  = (((int)GetRValue(crColor)) + GetGValue(crColor) + GetBValue(crColor))/3;

  return RGB( Gray,Gray,Gray);
}

BOOL IsLightColor(COLORREF crColor)
{
  return (((int)GetRValue(crColor)) + GetGValue(crColor) + GetBValue(crColor))>(3*128);
}

COLORREF BleachColor(int Add, COLORREF color)
{
  return RGB( min (GetRValue(color)+Add, 255),
              min (GetGValue(color)+Add, 255),
              min (GetBValue(color)+Add, 255));
}
//------------------------------------------------------//
HARBOUR HB_FUN_DARKENCOLORXP() //COLORREF lcolor)
{
  COLORREF lcolor = hb_parnl(1);
  hb_retnl( RGB( MulDiv(GetRValue(lcolor),7,10),
                 MulDiv(GetGValue(lcolor),7,10),
                 MulDiv(GetBValue(lcolor)+55,7,10)) );
}
//------------------------------------------------------//
HARBOUR HB_FUN_DARKENCOLOR() // long lScale, COLORREF lColor)
{
  COLORREF lColor = hb_parnl(2);
  LONG lScale = hb_parni(1);

  long red   = MulDiv(GetRValue(lColor),(255-lScale),255);
  long green = MulDiv(GetGValue(lColor),(255-lScale),255);
  long blue  = MulDiv(GetBValue(lColor),(255-lScale),255);

  hb_retnl( RGB(red, green, blue));
}

COLORREF DarkenColor(long lScale, COLORREF lColor)
{

  long red   = MulDiv(GetRValue(lColor),(255-lScale),255);
  long green = MulDiv(GetGValue(lColor),(255-lScale),255);
  long blue  = MulDiv(GetBValue(lColor),(255-lScale),255);

  return( RGB(red, green, blue));
}

//-------------------------------------------------------//
HARBOUR HB_FUN_LIGHTCOLOR( ) //long lScale, COLORREF lColor)
{
  COLORREF lColor = hb_parnl(2);
  LONG lScale = hb_parni(1);

  long R = MulDiv(255-GetRValue(lColor),lScale,255)+GetRValue(lColor);
  long G = MulDiv(255-GetGValue(lColor),lScale,255)+GetGValue(lColor);
  long B = MulDiv(255-GetBValue(lColor),lScale,255)+GetBValue(lColor);

  hb_retnl( RGB(R, G, B) );
}

COLORREF LightenColor( long lScale, COLORREF lColor)
{
  long R = MulDiv(255-GetRValue(lColor),lScale,255)+GetRValue(lColor);
  long G = MulDiv(255-GetGValue(lColor),lScale,255)+GetGValue(lColor);
  long B = MulDiv(255-GetBValue(lColor),lScale,255)+GetBValue(lColor);

  return( RGB(R, G, B) );
}

//-------------------------------------//

HARBOUR HB_FUN_DEGRADADO()
   {
           RECT rct;

           rct.top      = hb_parni( 2, 1 );
           rct.left     = hb_parni( 2, 2 );
           rct.bottom   = hb_parni( 2, 3 );
           rct.right    = hb_parni( 2, 4 );

           DegardeFill( ( HDC ) hb_parnl( 1 ) , &rct, hb_parnl( 3 ), hb_parnl( 4 ), hb_parl(5) );
   }



 

Saludos

[cnavarro]

Aqui tienes la ultima

Code: Select all  Expand view

//#include <WinTen.h>
#include <Windows.h>
//#include <ClipApi.h>
#include <HbApi.h>
#include <commctrl.h>
#include <StdLib.h>

//----------------------------------------------------------------------------//

void DegradColor( HDC hDC, RECT * rori, COLORREF cFrom, COLORREF cTo, int iType, int iRound )
{
   int clr1r, clr1g, clr1b, clr2r, clr2g, clr2b ;
   signed int iEle, iRed, iGreen, iBlue, iTot, iHalf ;
   BOOL bHorz = ( iType == 2 || iType == 4 ) ;
   BOOL bDir ;
   RECT rct ;
   HPEN hOldPen, hPen ;
   LOGBRUSH lb ;
   HBRUSH hOldBrush, hBrush, hNull ;

   rct.top = rori->top ;
   rct.left = rori->left ;
   rct.bottom = rori->bottom ;
   rct.right = rori->right ;

    iTot   = ( ! bHorz ? ( rct.bottom  - rct.top + 1 ) : ( rct.right - rct.left + 1 ) ) ;

   iHalf  = iTot / 2 ;
    lb.lbStyle = BS_NULL ;
    hNull  = CreateBrushIndirect(&lb) ;

   clr1r = GetRValue( cFrom ) ;
   clr1g = GetGValue( cFrom ) ;
   clr1b = GetBValue( cFrom ) ;

   clr2r = GetRValue( cTo ) ;
   clr2g = GetGValue( cTo ) ;
   clr2b = GetBValue( cTo ) ;

   iRed   =  abs( clr2r - clr1r ) ;
   iGreen =  abs( clr2g - clr1g ) ;
   iBlue  =  abs( clr2b - clr1b ) ;

   iRed   = ( iRed <= 0 ? 0 : ( iRed / iTot ) );
   iGreen = ( iGreen <= 0 ? 0 : ( iGreen / iTot ) ) ;
   iBlue  = ( iBlue <= 0 ? 0 : ( iBlue / iTot ) ) ;

   if( iType == 3 || iType == 4 )
   {
    iRed   *= 2 ;
      iGreen *= 2 ;
      iBlue  *= 2 ;
   }

   if( iType == 5 )
   {
      rct.top  += ( ( rct.bottom - rct.top ) / 2 ) ;
      rct.left += ( ( rct.right - rct.left ) / 2 ) ;
      rct.top  -= ( ( rct.bottom - rct.top ) / 3 ) ;
      rct.bottom = rct.top + 2 ;
      rct.right  = rct.left + 2 ;
   }
   else
   {
    if( ! bHorz )
        rct.bottom = rct.top + 1 ;
       else
        rct.right = rct.left + 1 ;
   }


   if( iType == 5 )
   {
       hPen      = CreatePen( PS_SOLID, 1, RGB( clr2r, clr2g, clr2b ) ) ;
    hOldPen   = SelectObject( hDC, hPen ) ;
        hBrush    = CreateSolidBrush( RGB( clr2r, clr2g, clr2b ) ) ;
    hOldBrush = SelectObject( hDC, hBrush ) ;
      if( iRound == 1 )
            Ellipse( hDC, rori->left, rori->top, rori->right, rori->bottom ) ;
      else
            RoundRect( hDC, rori->left, rori->top, rori->right, rori->bottom, 16, 16 ) ;

    SelectObject( hDC, hOldBrush ) ;
       DeleteObject( hBrush ) ;
    SelectObject( hDC, hOldPen ) ;
       DeleteObject( hPen ) ;
       hPen    = CreatePen( PS_SOLID, 2, RGB( clr1r, clr1g, clr1b ) ) ;
    hOldPen = SelectObject( hDC, hPen ) ;
    SelectObject( hDC, hNull ) ;
      if( iRound == 1 )
            Ellipse( hDC, rct.left, rct.top, rct.right, rct.bottom ) ;
      else
            RoundRect( hDC, rct.left, rct.top, rct.right, rct.bottom, 16, 16 ) ;

   }
   else
   {
       hPen      = CreatePen( PS_SOLID, 1, RGB( clr1r, clr1g, clr1b ) ) ;
    hOldPen   = SelectObject( hDC, hPen ) ;
        hBrush    = CreateSolidBrush( RGB( clr1r, clr1g, clr1b ) ) ;
    hOldBrush = SelectObject( hDC, hBrush ) ;
   }

   for( iEle = 1; iEle < iTot; iEle++ )
   {

        if( iType > 2 && iType < 5 && iEle > iHalf )
      {
        clr2r = GetRValue( cFrom ) ;
        clr2g = GetGValue( cFrom ) ;
        clr2b = GetBValue( cFrom ) ;
      }

      bDir = ( clr2r > clr1r ? TRUE : FALSE ) ;
      if( bDir )
        clr1r += iRed ;
      else
        clr1r -= iRed ;

      clr1r = ( clr1r < 0 ? 0 : clr1r > 255 ? 255 : clr1r ) ;

      bDir = ( clr2g > clr1g ? TRUE : FALSE  ) ;
      if( bDir )
        clr1g += iGreen ;
      else
        clr1g -= iGreen ;

      clr1g = ( clr1g < 0 ? 0 : clr1g > 255 ? 255 : clr1g ) ;

      bDir = ( clr2b > clr1b ? TRUE : FALSE  ) ;

      if( bDir )
        clr1b += iBlue ;
      else
        clr1b -= iBlue ;

      clr1b = ( clr1b < 0 ? 0 : clr1b > 255 ? 255 : clr1b ) ;

      if( iType == 5 )
      {
              SelectObject( hDC, hOldBrush ) ;
           DeleteObject( hNull ) ;
                hNull  = CreateBrushIndirect(&lb) ;
              SelectObject( hDC, hNull ) ;
          SelectObject( hDC, hOldPen ) ;
            DeleteObject( hPen ) ;
            hPen = CreatePen( PS_SOLID, 2, RGB( clr1r, clr1g, clr1b ) ) ;
            SelectObject( hDC, hPen ) ;
       if( iRound == 1 )
            Ellipse( hDC, rct.left, rct.top, rct.right + 1, rct.bottom + 1 ) ;
          else
            RoundRect( hDC, rct.left, rct.top, rct.right + 1, rct.bottom + 1, 16, 16 ) ;

          if( iRound == 1 )
            Ellipse( hDC, rct.left, rct.top, rct.right + 1, rct.bottom + 1 ) ;
        else
            RoundRect( hDC, rct.left, rct.top, rct.right + 1, rct.bottom + 1, 16, 16 ) ;

            rct.top    -= ( rct.top <= rori->top ? 0 : 1 ) ;
            rct.left   -= ( rct.left <= rori->left ? 0 : 1 );
            rct.bottom +=  ( rct.bottom >= rori->bottom ? 0 : 1 ) ;
            rct.right  +=  ( rct.right >= rori->right ? 0 : 1 ) ;
       }
      else
      {
          SelectObject( hDC, hOldBrush ) ;
       DeleteObject( hBrush ) ;
        hBrush = CreateSolidBrush( RGB( clr1r, clr1g, clr1b ) ) ;
          SelectObject( hDC, hBrush ) ;

        FillRect( hDC, &rct, hBrush ) ;

        if( ! bHorz )
        {
                rct.top++ ;
        rct.bottom++ ;
        }
        else
        {
            rct.left++ ;
            rct.right++ ;
        }
      }
   }
    SelectObject( hDC, hOldBrush ) ;
    SelectObject( hDC, hOldPen ) ;
   DeleteObject( hBrush ) ;
   DeleteObject( hPen ) ;
   DeleteObject( hNull ) ;
}

//---------------------------------------------------------------------------//

void DegardeFill( HDC hDC, RECT* rct, COLORREF crStart, COLORREF crEnd, int bVertical )
    {
       int nSegments = 100;
       COLORREF cr;
       int nR      = GetRValue(crStart);
       int nG      = GetGValue(crStart);
       int nB      = GetBValue(crStart);
       int neB     = GetBValue(crEnd);
       int neG     = GetGValue(crEnd);
       int neR     = GetRValue(crEnd);
       int nDiffR  = (neR - nR);
       int nDiffG  = (neG - nG);
       int nDiffB  = (neB - nB);
       int ndR ;
       int ndG ;
       int ndB ;
       int nCX ;
       int nCY ;
       int nTop    = rct->top;
       int nBottom ; //= rct->bottom;
       int nLeft   = rct->left;
       int nRight ; // = rct->right;
       HBRUSH hBrush;
       RECT rc;

       int i;

       if( !bVertical )
       {
          if( nSegments > ( rct->right - rct->left ) )
          {
            nSegments = ( rct->right - rct->left );
          }
       }
       else
       {
          if( nSegments > ( rct->bottom - rct->top ) )
          {
            nSegments = ( rct->bottom - rct->top );
          }
       }

       ndR = 256 * (nDiffR) / (max(nSegments,1));
       ndG = 256 * (nDiffG) / (max(nSegments,1));
       ndB = 256 * (nDiffB) / (max(nSegments,1));
       nCX = (rct->right-rct->left) / max(nSegments,1);
       nCY = (rct->bottom-rct->top) / max(nSegments,1);

       nR *= 256;
       nG *= 256;
       nB *= 256;

       for (i = 0; i < nSegments; i++, nR += ndR, nG += ndG, nB += ndB)
       {

               if(i == (nSegments - 1))
               {
                  nRight  = rct->right;
                  nBottom = rct->bottom;
               }
               else
               {
                  nBottom = nTop + nCY;
                  nRight = nLeft + nCX;
               }

               cr = RGB(nR / 256, nG / 256, nB / 256);

               {
                  hBrush = CreateSolidBrush( cr );
                  if( bVertical )
                  {
                     rc.top    = nTop;
                     rc.left   = rct->left;
                     rc.bottom = nBottom + 1;
                     rc.right  = rct->right;
                  }
                  else
                  {
                     rc.top    = rct->top;
                     rc.left   = nLeft;
                     rc.bottom = rct->bottom;
                     rc.right  = nRight+1;
                  }
                  FillRect(hDC, &rc, hBrush );
                  DeleteObject( hBrush );
               }

               nLeft = nRight;
               nTop = nBottom;
       }
    }

//----------------------------------------------------------------------------//

COLORREF MixedColor(COLORREF colorA,COLORREF colorB)
{
  // ( 86a + 14b ) / 100
  int red   = MulDiv(86,GetRValue(colorA),100) + MulDiv(14,GetRValue(colorB),100);
  int green = MulDiv(86,GetGValue(colorA),100) + MulDiv(14,GetGValue(colorB),100);
  int blue  = MulDiv(86,GetBValue(colorA),100) + MulDiv(14,GetBValue(colorB),100);

  return RGB( min(red,0xff),min(green,0xff), min(blue,0xff));
}

//----------------------------------------------------------------------------//

COLORREF MidColor(COLORREF colorA,COLORREF colorB)
{
  // (7a + 3b)/10
  int red   = MulDiv(7,GetRValue(colorA),10) + MulDiv(3,GetRValue(colorB),10);
  int green = MulDiv(7,GetGValue(colorA),10) + MulDiv(3,GetGValue(colorB),10);
  int blue  = MulDiv(7,GetBValue(colorA),10) + MulDiv(3,GetBValue(colorB),10);

  return RGB( min(red,0xff),min(green,0xff), min(blue,0xff));
}

//----------------------------------------------------------------------------//

COLORREF GrayColor(COLORREF crColor)
{
  int Gray  = (((int)GetRValue(crColor)) + GetGValue(crColor) + GetBValue(crColor))/3;

  return RGB( Gray,Gray,Gray);
}

//----------------------------------------------------------------------------//

BOOL IsLightColor(COLORREF crColor)
{
  return (((int)GetRValue(crColor)) + GetGValue(crColor) + GetBValue(crColor))>(3*128);
}

//----------------------------------------------------------------------------//

COLORREF BleachColor(int Add, COLORREF color)
{
  return RGB( min (GetRValue(color)+Add, 255),
              min (GetGValue(color)+Add, 255),
              min (GetBValue(color)+Add, 255));
}

//------------------------------------------------------//

HB_FUNC( DARKENCOLORXP ) //COLORREF lcolor)
{
  COLORREF lcolor = hb_parnl(1);
  hb_retnl( RGB( MulDiv(GetRValue(lcolor),7,10),
                 MulDiv(GetGValue(lcolor),7,10),
                 MulDiv(GetBValue(lcolor)+55,7,10)) );
}
//------------------------------------------------------//

HB_FUNC( DARKENCOLOR ) // long lScale, COLORREF lColor)
{
  COLORREF lColor = hb_parnl(2);
  LONG lScale = hb_parni(1);

  long red   = MulDiv(GetRValue(lColor),(255-lScale),255);
  long green = MulDiv(GetGValue(lColor),(255-lScale),255);
  long blue  = MulDiv(GetBValue(lColor),(255-lScale),255);

  hb_retnl( RGB(red, green, blue));
}

//----------------------------------------------------------------------------//

COLORREF DarkenColor(long lScale, COLORREF lColor)
{

  long red   = MulDiv(GetRValue(lColor),(255-lScale),255);
  long green = MulDiv(GetGValue(lColor),(255-lScale),255);
  long blue  = MulDiv(GetBValue(lColor),(255-lScale),255);

  return( RGB(red, green, blue));
}

//-------------------------------------------------------//

HB_FUNC( LIGHTCOLOR ) //long lScale, COLORREF lColor)
{
  COLORREF lColor = hb_parnl(2);
  LONG lScale = hb_parni(1);

  long R = MulDiv(255-GetRValue(lColor),lScale,255)+GetRValue(lColor);
  long G = MulDiv(255-GetGValue(lColor),lScale,255)+GetGValue(lColor);
  long B = MulDiv(255-GetBValue(lColor),lScale,255)+GetBValue(lColor);

  hb_retnl( RGB(R, G, B) );
}

//----------------------------------------------------------------------------//

COLORREF LightenColor( long lScale, COLORREF lColor)
{
  long R = MulDiv(255-GetRValue(lColor),lScale,255)+GetRValue(lColor);
  long G = MulDiv(255-GetGValue(lColor),lScale,255)+GetGValue(lColor);
  long B = MulDiv(255-GetBValue(lColor),lScale,255)+GetBValue(lColor);

  return( RGB(R, G, B) );
}

//-------------------------------------//

HB_FUNC( DEGRADADO )
   {
           RECT rct;

           rct.top      = hb_parvni( 2, 1 );
           rct.left     = hb_parvni( 2, 2 );
           rct.bottom   = hb_parvni( 2, 3 );
           rct.right    = hb_parvni( 2, 4 );

           DegardeFill( ( HDC ) hb_parnl( 1 ) , &rct, hb_parnl( 3 ), hb_parnl( 4 ), hb_parl(5) );
   }

 //----------------------------------------------------------------------------//

 

[cnavarro]

Pero implementar los submenus es mas complicado para usar con las clases de Fivewin

[cnavarro]

Aclaro que esto no es un desarrollo mio, como dije lo baje de algun lado que no recuerdo y no encuentro por ningun lado los creditos. Me gustaria poder echarlo a andar.

Saludos

Horacio, he encontrado el tema en el foro
Creo que la clase original es de Arturo Tamayo Daza
Si alguien tiene los fuentes, podria facilitarlos ya que los links que hay ya no funcionan

http://fivetechsupport.com/forums/viewt ... 567#p24583

[horacio]

Cristobal, yo tengo los fuentes pero algunos son modificaciones de clases y funciones de FW. Deberia postear solo las modificaciones pero algunos están tan alterados que eso me parece dificil. Si Antonio no tiene inconvenientes los cuelgo de este hilo.

Saludos

[cnavarro]

Cristobal, yo tengo los fuentes pero algunos son modificaciones de clases y funciones de FW. Deberia postear solo las modificaciones pero algunos están tan alterados que eso me parece dificil. Si Antonio no tiene inconvenientes los cuelgo de este hilo.

Saludos

Horacio, no hace falta
He buscado entre "el baul de los recuerdos" y ya tenia los fuentes originales de Arturo Tamayo y ya tengo funcionando su clase, con un minimo cambio, con Fwh 15.03 y el ultimo Harbour
Cuando tenga una rato, miraré a ver como lo compatibilizo con las nuevas versiones

[horacio]

Cristobal, buenisimo !!!

Saludos

[horacio]

Cristobal, a ver si me echas una manito, al compilar tengo estE error.

Code: Select all  Expand view

Unresolved external _HB_FUN___CLS_PARAM  referenced from OBJ\MENU.OBJ
 

Gracias y Saludos

[cnavarro]

Has eliminado la palabra PARAMS en la llamada a las funciones?

[horacio]

Ok, ya no sale. Compila perfectamente pero muestra una ventana un segundo y se cierra. Alguna idea. Compilo con FWH14.12 y Harbour. Muchas gracias

Saludos

[cnavarro]

Añade a la clase de Arturo las Datas l2007 y l2010 e inicializalas a .F.
Añade el metodo SetSkin que hay en la clase TMenu de Fw
y prueba