Compilando una rutina de menu

User avatar
cnavarro
Posts: 5792
Joined: Wed Feb 15, 2012 8:25 pm
Location: España

Re: Compilando una rutina de menu

Post by cnavarro »

Mezcla de estilos
Ojo, el menu principal tiene estilo 2007, por eso se ven los items iniciales todos con ese estilo

Image

Image

Image

Image

Image
C. Navarro
Hay dos tipos de personas: las que te hacen perder el tiempo y las que te hacen perder la noción del tiempo
Si alguien te dice que algo no se puede hacer, recuerda que esta hablando de sus limitaciones, no de las tuyas.
User avatar
ruben Dario
Posts: 986
Joined: Thu Sep 27, 2007 3:47 pm
Location: Colombia

Re: Compilando una rutina de menu

Post by ruben Dario »

cnavarro wrote:Que utilizas Harbour o XHarbour?
Uso Harbour y xHarbour.
El fuente que quiero compilar es menu.c y uso bcc_6.8
Este es el menu.c que poblicaron y lo quiero compilar, como lo compilo en C. Cual es el parametro para compilar

Code: Select all



    #define OEMRESOURCE



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

/*
    //#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 );

    }

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

     

Muchas gracias. Many thanks.

Saludos,Regards
-------------------------------------------------------------------------------------
Cristobal Navarro
Harbour 3.2.0dev (r1501292255) - FWH 15.04

User avatar
cnavarro    
     
    Posts: 1660
    Joined: Wed Feb 15, 2012 8:25 pm
    Location: España

Top
Re: Compilando una rutina de menu

Postby horacio » Sat Apr 25, 2015 1:03 am
Ahhh, ok. Me habia olvidado de esa rutina. Aqui te mando la otra rutina en C.

Code: Select all  Collapse 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) );
       }

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

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) );
   }

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

 


 
Last edited by ruben Dario on Fri Jan 27, 2017 3:24 pm, edited 2 times in total.
Ruben Dario Gonzalez
Cali-Colombia
rubendariogd@hotmail.com - rubendariogd@gmail.com
User avatar
cnavarro
Posts: 5792
Joined: Wed Feb 15, 2012 8:25 pm
Location: España

Re: Compilando una rutina de menu

Post by cnavarro »

Ruben, qué utilizas Harbour o XHarbour?
Que version de Borland?
C. Navarro
Hay dos tipos de personas: las que te hacen perder el tiempo y las que te hacen perder la noción del tiempo
Si alguien te dice que algo no se puede hacer, recuerda que esta hablando de sus limitaciones, no de las tuyas.
User avatar
ruben Dario
Posts: 986
Joined: Thu Sep 27, 2007 3:47 pm
Location: Colombia

Re: Compilando una rutina de menu

Post by ruben Dario »

cnavarro wrote:Ruben, qué utilizas Harbour o XHarbour?
Que version de Borland?
Gracias.

Uso las dos Versiones Harbour y xHarbour.
La version de BCC de Borland? es la version 6.8
Estoy tratando de compilar el menu.c publicado.
Ruben Dario Gonzalez
Cali-Colombia
rubendariogd@hotmail.com - rubendariogd@gmail.com
Frafive
Posts: 189
Joined: Wed Apr 05, 2006 9:48 pm

Re: Compilando una rutina de menu

Post by Frafive »

Hola amigos
Podéis pasar las fuentes y algún ejemplo.

Un saludo y gracias
User avatar
ruben Dario
Posts: 986
Joined: Thu Sep 27, 2007 3:47 pm
Location: Colombia

Re: Compilando una rutina de menu

Post by ruben Dario »

Me uno a la lista.

Ya que el codigo que se publico no funciona compile el ejemplo que se publico. y el ejemplo falta el archivo .rc

este es el error

Code: Select all


Application
===========
   Path and name: K:\v_xharb_v3\menu_h.exe (32 bits)
   Size:   993,792 bytes
   Compiler version: Harbour 3.2.0dev (r1501292255)
   FiveWin  Version: FWH 14.12
   Windows version: 6.2, Build 9200 

   Time from start: 0 hours 0 mins 0 secs 
   Error occurred at: 05/24/15, 19:58:40
   Error description: Error BASE/1066  Argument error: conditional
   Args:
     [   1] = N   0

Stack Calls
===========
   Called from: .\source\classes\PDMENU.PRG => MENUADDITEM( 47 )
   Called from: .\prg\menu_p.prg => BUILDMENU( 114 )
   Called from: .\prg\menu_p.prg => MAIN( 39 )

System
======
   CPU type: Intel(R) Core(TM) i3-2100 CPU @ 3.10GHz 3100 Mhz
   Hardware memory: 7385 megs

   Free System resources: 90 %
        GDI    resources: 90 %
        User   resources: 90 %

   Windows total applications running: 3
      1 ,                                                                                                     
      2 Conmutación de tareas, K:\v_xharb_v3\menu_h.exe
Gracias
Ruben Dario Gonzalez
Cali-Colombia
rubendariogd@hotmail.com - rubendariogd@gmail.com
User avatar
cnavarro
Posts: 5792
Joined: Wed Feb 15, 2012 8:25 pm
Location: España

Re: Compilando una rutina de menu

Post by cnavarro »

En cuanto a la publicacion de los fuentes

Cita de 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.
Este es el RC que se usa en el ejemplo

Code: Select all

New    BITMAP "c:/fwh/bitmaps/16x16/new.bmp"
Dialog BITMAP "c:/fwh/bitmaps/16x16/form.bmp"
Open   BITMAP "c:/fwh/bitmaps/16x16/open.bmp"
Save   BITMAP "c:/fwh/bitmaps/16x16/floppy.bmp"
Exit   BITMAP "c:/fwh/bitmaps/16x16/exit.bmp"
bitmap BITMAP "c:/fwh/bitmaps/16x16/bitmap.bmp"
icon   BITMAP "c:/fwh/bitmaps/16x16/icon.bmp"
//blanco BITMAP "otro.bmp"

 
Estoy preparando unos ejemplos
C. Navarro
Hay dos tipos de personas: las que te hacen perder el tiempo y las que te hacen perder la noción del tiempo
Si alguien te dice que algo no se puede hacer, recuerda que esta hablando de sus limitaciones, no de las tuyas.
User avatar
ruben Dario
Posts: 986
Joined: Thu Sep 27, 2007 3:47 pm
Location: Colombia

Re: Compilando una rutina de menu

Post by ruben Dario »

Saludos
Tienes un ejemplo de como se usa , el codigo publico en c para menus.

Code: Select all


//#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) );
   }

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

 
Ruben Dario Gonzalez
Cali-Colombia
rubendariogd@hotmail.com - rubendariogd@gmail.com
User avatar
MarioG
Posts: 1356
Joined: Fri Oct 14, 2005 1:28 pm
Location: Resistencia - Chaco - AR

Re: Compilando una rutina de menu

Post by MarioG »

Gente;
alguna posibilidad de obtener esta contribución?
Resistencia - "Ciudad de las Esculturas"
Chaco - Argentina
Post Reply