/*
 * Xailer source code:
 *
 * ImageList.prg
 * Clase TImageList()
 *
 * Copyright 2003, 2007 Jose F. Gimenez
 * Copyright 2003, 2007 Xailer.com
 * All rights reserved
 *
 */

#include "Xailer.ch"
#include "CommCtrl.api"


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

CLASS XImageList FROM TWinObject

PUBLISHED:
   PROPERTY nWidth   INIT 1   WRITE METHOD SetIconSize
   PROPERTY nHeight  INIT 1   WRITE INLINE ::SetIconSize( , Value )

PUBLIC:
   PROPERTY oParent

PROTECTED:
   PROPERTY aBitmaps INIT {}

PUBLIC:
   METHOD New( oParent, nWidth, nHeight ) EXTERN XImageList_Create( oParent, nWidth, nHeight )
   METHOD Create( oParent, nWidth, nHeight ) CONSTRUCTOR
   METHOD Destroy() // --> Nil

   METHOD Add( xImage, lMasked ) // --> nImage
   METHOD Remove( nImage ) // --> lSuccess
   METHOD RemoveAll() // --> lSuccess
   METHOD GetBitmap( nIndex ) // --> hBitmap

   /* NOTA: El handle devuelto por GetIcon() hay que destruirlo cuando no se necesite.
            La responsabilidad de destruirlo es de quien lo llame, no de TImageList - [JFG] */
   METHOD AddIcon( cIcon ) // --> nImages
   METHOD GetIcon( nIcon, nFlags )  INLINE ImageList_GetIcon( ::Handle, nIcon, nFlags ) // --> hIcon
   METHOD ReplaceIcon( nIndex, hIcon ) // --> nIndex
   METHOD GetIconSize() // --> aSize
   METHOD SetIconSize( nWidth, nHeight ) // --> lSuccess

   METHOD GetImageCount() // --> nCount

RESERVED:
   METHOD GetImageInfo( nIndex )
   METHOD GetBkColor()
   METHOD SetBkColor( nColor )
   METHOD Duplicate()

   METHOD Draw( nIndex, hDC, nRow, nCol, nStyle )
   METHOD DrawEx( nIndex, hDC, nRow, nCol, nWidth, nHeight, nClrFore, nClrPane, nStyle )

   METHOD AddMasked( hBitmap, nColor )
   METHOD SetOverlayImage( nImage, nIndex )
   METHOD Copy( nImageSrc, nImageTgt )
   METHOD Swap( nImageSrc, nImageTgt )

   METHOD BeginDrag( nIndex, x, y )
   METHOD EndDrag()
   METHOD DragEnter( hWnd, x, y )
   METHOD DragLeave( hWnd )
   METHOD DragMove( x, y )
   METHOD SetDragCursorImage( nIndex, x, y )
   METHOD DragShowNolock( lShow )
   METHOD GetDragImage()

   METHOD Merge( nImage1, hImageList, nImage2, xOffset, yOffset )

   METHOD Read( cFile )
   METHOD Write( cFile )

   METHOD WriteBitmap( cFile )   INLINE ::Write( cFile, .T. )

ENDCLASS

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

METHOD Create( oParent, nWidth, nHeight ) CLASS XImageList

   UPDATE ::oParent  TO oParent
   UPDATE ::FnWidth  TO nWidth
   UPDATE ::FnHeight TO nHeight

   IF Empty( ::Handle )
      ::Handle := ImageList_Create( ::nWidth, ::nHeight, ILC_MASK + ILC_COLOR32, 0, 4 )
   ENDIF
   ::SetIconSize()

   AEval( ::aBitmaps, {|v| ImageList_Add( ::Handle, v[ 1 ], v[ 2 ] ) } )

   IF ::oParent != Nil
      ::oParent:InsertComponent( Self )
   ENDIF

RETURN Self

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

METHOD Destroy() CLASS XImageList

   IF !Empty( ::Handle )
      ImageList_Destroy( ::Handle )
      ::Handle := 0
   ENDIF

   IF ::oParent != Nil
      ::oParent:RemoveComponent( Self )
   ENDIF

RETURN Nil

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

METHOD Add( xImage, lMasked ) CLASS XImageList

   LOCAL nImage   := -1

   DEFAULT lMasked   TO .F.

   /* NOTA: He comentado la comprobacion de que ya exista el mismo bitmap
            en la lista, porque TToolbar no permite (por ahora) indicar que
            numero de imagen tiene que ir en cada boton, sino que tiene que
            coincidir el numero de boton con el numero de imagen.
            Precisamente, test.prg utiliza el mismo bitmap para todos los
            botones de la toolbar y fallaba.
   */
//   IF Ascan( ::aBitmaps, {|v| Upper( v ) == Upper( cImage ) } ) == 0
//      nImage := ImageList_Add( ::Handle, cImage, lMasked )
//      IF nImage != -1
//         AAdd( ::aBitmaps, cImage )
//      ENDIF
//   ENDIF

   // IOZ (25/06/03): Siempre se aņaden los bitmaps al array para soportar
   // persistencia, y se aņaden al control nativo en el metodo Create()

   AAdd( ::aBitmaps, { xImage, lMasked } )

   IF ! Empty( ::Handle )
      IF ( nImage := ImageList_Add( ::Handle, xImage, lMasked ) ) == 1
         ::FnWidth := ::GetIconSize()[1]
         ::FnHeight := ::GetIconSize()[2]
         IF ::oParent != Nil
            ::oParent:XANotify( XANOTIFY_IMAGELIST_ADDFIRST )
         ENDIF
      ENDIF
   ENDIF

RETURN nImage

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

#pragma BEGINDUMP

#include <windows.h>
#include <commctrl.h>
#include <xailer.h>
#include <constants.ch>

extern BOOL lIsDebug;

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

HB_FUNC_STATIC( IMAGELIST_CREATE )
{
   UINT flags = hb_parnl( 3 );

   if( hb_pcount() < 3 )
   {
      long nColors = ScreenColors();

      switch( nColors )
      {
         case    16: flags = ILC_COLOR4; break;
         case   256: flags = ILC_COLOR8; break;
         case 32768:
         case 65536: flags = ILC_COLOR16; break;
         case    24: flags = ILC_COLOR24; break;
         default   : flags = ILC_COLOR32; break;
      }
   }

   hb_retnl( ( LONG ) ImageList_Create( hb_parnl( 1 ), hb_parnl( 2 ), flags, hb_parnl( 4 ), hb_parnl( 5 ) ) );
}

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

HB_FUNC_STATIC( IMAGELIST_ADD )
{
   HANDLE hIL = (HWND) hb_parnl( 1 );
   LPCSTR cImage = NULL;
   BOOL   lMasked = hb_parl( 3 );
   BOOL   lIcon = FALSE;
   HANDLE hImg;
   HANDLE hMask;
   HANDLE hTemp = NULL;
   int cx, cy;
   ICONINFO ii;

   ImageList_GetIconSize( hIL, &cx, &cy );
   if( ( cx == 1 ) && ( cy == 1 ) )
   {
      cx = 0;
      cy = 0;
   }

   if( HB_ISCHAR( 2 ) )
   {
      cImage = hb_parc( 2 );
      hTemp = XA_LoadIcon( cImage, cx, cy, NULL );
      if( !hTemp )
         hTemp = LoadImage( NULL, cImage, IMAGE_ICON, cx, cy, LR_LOADFROMFILE | LR_LOADMAP3DCOLORS | LR_SHARED );
      if( hTemp )
         lIcon = TRUE;
      else
      {
         hTemp = XA_LoadBitmap32( cImage );
         if( !hTemp )
            hTemp = XA_LoadImage( cImage, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT | LR_LOADMAP3DCOLORS | LR_SHARED );
      }
   }
   else if( HB_ISNUM( 2 ) )
   {
      cImage  = MAKEINTRESOURCE( hb_parnl( 2 ) );
      hTemp = XA_LoadBitmap32( cImage );
      if( !hTemp )
      {
         if( ( hTemp = XA_LoadIcon( cImage, cx, cy, NULL ) ) != NULL )
            lIcon = TRUE;
         else if( GetObject( (HBITMAP) hb_parnl( 2 ), sizeof(BITMAP), NULL ) )
            hTemp = (HBITMAP) hb_parnl( 2 );
      }
   }

   if( hTemp )
   {
      if( lIcon )
      {
         GetIconInfo( hTemp, &ii );
         hMask = ii.hbmMask;
         if( !( lIcon = ( (unsigned) cx != ii.xHotspot * 2 ) || ( (unsigned) cy != ii.yHotspot * 2 ) ) )
            DestroyIcon( hTemp );
         if( lMasked )
            {
            if( XA_GetBmpDisableMode() == dmGRAYED )
               hImg = XA_GetBmpGrayed( ii.hbmColor );
            else
               hImg = XA_GetBmpDisabled( ii.hbmColor );
            DeleteObject( ii.hbmColor );
            if( lIcon )
               {
               DestroyIcon( hTemp );
               ii.hbmColor = hImg;
               hTemp = CreateIconIndirect( &ii );
               }
            }
         else
            hImg = ii.hbmColor;
      }
      else
      {
         if( lMasked )
         {
            if( XA_GetBmpDisableMode() == dmGRAYED )
               hImg = XA_GetBmpGrayed( hTemp );
            else
               hImg = XA_GetBmpDisabled( hTemp );
            DeleteObject( hTemp );
         }
         else
            hImg = hTemp;
         hMask = XA_GetBmpMask( hImg );
      }

      // Si no hay ninguna imagen todavia, y el tamaņo inicial es 1 x 1,
      // calcular las dimensiones del bitmap y reajustar la ImageList
      if( ImageList_GetImageCount( hIL ) == 0 )
      {
         if( ( cx == 0 ) && ( cy == 0 ) )
         {
            BITMAP Bmp;
            memset( &Bmp, 0, sizeof( BITMAP ) );
            GetObject( (HGDIOBJ) hImg, sizeof( BITMAP ), (LPVOID) &Bmp );
            if( ( Bmp.bmWidth != 0 ) && ( Bmp.bmHeight != 0 ) )
               ImageList_SetIconSize( hIL, Bmp.bmWidth, Bmp.bmHeight );
            else
               ImageList_SetIconSize( hIL, 16, 16 );
         }
      }

      if( lIcon )
         {
         hb_retnl( ImageList_AddIcon( hIL, hTemp ) + 1 );
         DestroyIcon( hTemp );
         }
      else
         hb_retnl( ImageList_Add( hIL, hImg, hMask ) + 1 );

      DeleteObject( hImg );
      DeleteObject( hMask );
   }
   else
   {
      if( lIsDebug )
      {
         PHB_DYNS pErrorLoadResource = hb_dynsymFindName( "ERRORLOADRESOURCE" );

         hb_vmPushDynSym( pErrorLoadResource );
         hb_vmPushNil();
         hb_vmPushString( "into imagelist", 14 );
         if( HB_ISCHAR( 2 ) )
            hb_vmPushString( cImage, strlen( cImage ) );
         else if( HB_ISNUM( 2 ) )
         {
            cImage = Dec( hb_parnl( 2 ) );
            hb_vmPushString( cImage, strlen( cImage ) );
         }
         hb_vmDo( 2 );
      }

      hb_retnl( 0 );
   }
}

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

HB_FUNC_STATIC( IMAGELIST_DESTROY )
{
   hb_retl( ImageList_Destroy( (HANDLE) hb_parnl( 1 ) ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_GETIMAGECOUNT )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retni( ImageList_GetImageCount( hIL ) );
}

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

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

HB_FUNC_STATIC( XIMAGELIST_GETBKCOLOR )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retnl( ImageList_GetBkColor( hIL ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_SETBKCOLOR )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retnl( ImageList_SetBkColor( hIL, (COLORREF) hb_parnl( 1 ) ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_REMOVE )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );
   BOOL lOk = ImageList_Remove( hIL, hb_parni( 1 ) - 1 );

   if( lOk )
      {
      if( ImageList_GetImageCount( hIL ) == 0 )
         {
         PHB_ITEM oParent = XA_ObjGetItemCopy( Self, "oParent" );

         if( oParent && !HB_IS_NIL( oParent ) )
            XA_ObjSendNL( oParent, "XANotify", XANOTIFY_IMAGELIST_EMPTY );
         hb_itemRelease( oParent );
         }
      }

   hb_retl( lOk );
}

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

HB_FUNC_STATIC( XIMAGELIST_REMOVEALL )
{
   PHB_ITEM Self   = hb_stackSelfItem();
   HANDLE   hIL    = GetHandleOf( Self );
   BOOL lOk = ImageList_RemoveAll( hIL );

   if( lOk )
      {
      PHB_ITEM oParent = XA_ObjGetItemCopy( Self, "oParent" );
      PHB_ITEM aEmpty = hb_itemArrayNew( 0 );

      XA_ObjSendItem( Self, "_aBitmaps", aEmpty );
      hb_itemRelease( aEmpty );

      if( oParent && !HB_IS_NIL( oParent ) )
         XA_ObjSendNL( oParent, "XANotify", XANOTIFY_IMAGELIST_EMPTY );
      hb_itemRelease( oParent );
      }

   hb_retl( lOk );
}

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

HB_FUNC_STATIC( XIMAGELIST_DUPLICATE )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE hIL     = GetHandleOf( Self );

   hb_retnl( (LONG) ImageList_Duplicate( hIL ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_ADDICON )
{
   PHB_ITEM Self     = hb_stackSelfItem();
   HANDLE   hIL      = GetHandleOf( Self );
   int      nWidth   = XA_ObjGetNL( Self, "nWidth" );
   int      nHeight  = XA_ObjGetNL( Self, "nHeight" );
   HICON    hIcon;
   int      nImages = 0;

   if( nWidth <= 1 ) nWidth = 0;
   if( nHeight <= 1 ) nHeight = 0;
   hIcon = XA_LoadIcon( hb_parc( 1 ), nWidth, nHeight, NULL );
   if( !hIcon )
      hIcon = ExtractIcon( GetInstance( 0 ), hb_parc( 1 ), hb_parnl( 2 ) );

   if( ( hIcon == NULL ) && lIsDebug )
      {
      PHB_DYNS pErrorLoadResource = hb_dynsymFindName( "ERRORLOADRESOURCE" );

      hb_vmPushDynSym( pErrorLoadResource );
      hb_vmPushNil();
      hb_vmPushString( "into imagelist", 14 );
      hb_vmPushString( hb_parc( 1 ), hb_parclen( 1 ) );
      hb_vmDo( 2 );
      }
   else
      {
      nImages = ImageList_AddIcon( hIL, hIcon ) + 1;
      if( nImages == 1 )
         {
         PHB_ITEM oParent = XA_ObjGetItemCopy( Self, "oParent" );

         if( oParent && !HB_IS_NIL( oParent ) )
            XA_ObjSendNL( oParent, "XANotify", XANOTIFY_IMAGELIST_ADDFIRST );
         hb_itemRelease( oParent );
         }
      DestroyIcon( hIcon );
      }

   hb_retnl( nImages );
}

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

HB_FUNC_STATIC( XIMAGELIST_REPLACEICON )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retnl( ImageList_ReplaceIcon( hIL, hb_parnl( 1 ), (HICON) hb_parnl( 2 ) ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_GETICONSIZE )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );
   int cx;
   int cy;

   hb_reta( 2 );

   if( ImageList_GetIconSize( hIL, &cx, &cy ) )
   {
      hb_storvnl( cx, -1, 1 );
      hb_storvnl( cy, -1, 2 );
   }
   else
   {
      hb_storvnl( 0, -1, 1 );
      hb_storvnl( 0, -1, 2 );
   }
}

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

HB_FUNC_STATIC( XIMAGELIST_SETICONSIZE )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );
   int nWidth, nHeight;
   BOOL lOk = TRUE;

   if( HB_ISNIL( 1 ) )
      nWidth = XA_ObjGetNL( Self, "nWidth" );
   else
      {
      nWidth = hb_parnl( 1 );
      XA_ObjSendNL( Self, "_FnWidth", nWidth );
      }

   if( HB_ISNIL( 2 ) )
      nHeight = XA_ObjGetNL( Self, "nHeight" );
   else
      {
      nHeight = hb_parnl( 2 );
      XA_ObjSendNL( Self, "_FnHeight", nHeight );
      }

   if( hIL )
      lOk = ImageList_SetIconSize( hIL, nWidth, nHeight );

   hb_retl( lOk );
}

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

HB_FUNC_STATIC( XIMAGELIST_DRAW )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retl( ImageList_Draw( hIL , hb_parnl( 1 ) - 1,
                              (HDC) hb_parnl( 2 ),
                              hb_parni( 3 ), hb_parni( 4 ),
                              hb_parni( 5 ) ) );

}

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

HB_FUNC_STATIC( XIMAGELIST_DRAWEX )
{
   PHB_ITEM Self  = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retl( ImageList_DrawEx( hIL , hb_parnl( 1 ) - 1,
                              (HDC) hb_parnl( 2 ), hb_parni( 3 ),
                              hb_parni( 4 ),
                              hb_parni( 5 ), hb_parni( 6 ),
                              (COLORREF) hb_parnl( 7 ),
                              HB_ISNUM( 8 ) ? (COLORREF) hb_parnl( 8 ) : CLR_DEFAULT,
                              HB_ISNUM( 9 ) ? hb_parnl( 9 ) : ILD_NORMAL ) );
}

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

HB_FUNC_STATIC( IMAGELIST_GETICON )
{
   hb_retnl( (LONG) ImageList_GetIcon( (HANDLE) hb_parnl( 1 ), hb_parni( 2 ) - 1, HB_ISNUM( 3 ) ? hb_parnl( 3 ) : 0 ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_ADDMASKED )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE   hIL  = GetHandleOf( Self );
   HBITMAP  hImg = NULL;
   int      nImages;

   if( HB_ISCHAR( 1 ) )
      hImg = XA_LoadImage( hb_parc( 1 ), IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS );
   else if( HB_ISNUM( 1 ) )
      hImg = (HBITMAP) hb_parnl( 1 );

   if( ( hImg == NULL ) && lIsDebug )
      {
      PHB_DYNS pErrorLoadResource = hb_dynsymFindName( "ERRORLOADRESOURCE" );

      hb_vmPushDynSym( pErrorLoadResource );
      hb_vmPushNil();
      hb_vmPushString( "into imagelist", 14 );
      if( HB_ISCHAR( 1 ) )
         hb_vmPushString( hb_parc( 1 ), hb_parclen( 1 ) );
      else if( HB_ISNUM( 1 ) )
      {
         char * cImage = Dec( hb_parnl( 2 ) );
         hb_vmPushString( cImage, strlen( cImage ) );
      }
      hb_vmDo( 2 );
      }

   nImages = ImageList_AddMasked( hIL, hImg, (COLORREF) hb_parnl( 2 ) ) + 1;
   if( nImages == 1 )
      {
      PHB_ITEM oParent = XA_ObjGetItemCopy( Self, "oParent" );

      if( oParent && !HB_IS_NIL( oParent ) )
         XA_ObjSendNL( oParent, "XANotify", XANOTIFY_IMAGELIST_ADDFIRST );
      hb_itemRelease( oParent );
      }

   if( HB_ISCHAR( 1 ) )
      DeleteObject( hImg );

   hb_retnl( nImages );
}

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

HB_FUNC_STATIC( XIMAGELIST_SETOVERLAYIMAGE )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retl( ImageList_SetOverlayImage( hIL, hb_parni( 1 ), hb_parni( 2 ) ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_COPY )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retl( ImageList_Copy( hIL, hb_parni( 1 ) - 1, hIL, hb_parni( 2 ) - 1, ILCF_MOVE ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_SWAP )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retl( ImageList_Copy( hIL, hb_parni( 1 ) - 1, hIL, hb_parni( 2 ) - 1, ILCF_SWAP ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_BEGINDRAG )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   ImageList_BeginDrag( hIL, hb_parnl( 1 ), hb_parnl( 2 ), hb_parnl( 3 ) );
}

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

/* NOTA: hay un bug en la declaracion de esta macro en CommCtrl.h y
   en mi version de BCC se queja de que no hay prototipo.
   He puesto aqui el prototipo correcto para que no genere Warning.
   [jlalin]
*/

#ifndef __GNUC__
   #undef ImageList_EndDrag
   WINCOMMCTRLAPI void WINAPI ImageList_EndDrag( void );
#endif

HB_FUNC_STATIC( XIMAGELIST_ENDDRAG )
{
   ImageList_EndDrag();
}

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

HB_FUNC_STATIC( XIMAGELIST_DRAGENTER )
{
   ImageList_DragEnter( (HWND) hb_parnl( 1 ), hb_parnl( 2 ), hb_parnl( 3 ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_DRAGLEAVE )
{
   ImageList_DragLeave( (HWND) hb_parnl( 1 ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_DRAGMOVE )
{
   ImageList_DragMove( hb_parnl( 1 ), hb_parnl( 2 ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_SETDRAGCURSORIMAGE )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   ImageList_SetDragCursorImage( hIL, hb_parnl( 1 ), hb_parnl( 2 ), hb_parnl( 3 ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_DRAGSHOWNOLOCK )
{
   hb_retl( ImageList_DragShowNolock( hb_parl( 1 ) ) );
}

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

HB_FUNC_STATIC( XIMAGELIST_GETDRAGIMAGE )
{
   POINT pt;
   POINT ptHot;
   HIMAGELIST hIL = ImageList_GetDragImage( &pt, &ptHot );

   if( HB_ISLOG( 1 ) )
   {
      hb_reta( 2 );

      if( hb_parl( 1 ) )
      {
         hb_storvnl( pt.x, -1, 1 );
         hb_storvnl( pt.y, -1, 2 );
      }
      else
      {
         hb_storvnl( ptHot.x, -1, 1 );
         hb_storvnl( ptHot.y, -1, 2 );
      }
   }
   else
      hb_retnl( (LONG) hIL );
}

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

HB_FUNC_STATIC( XIMAGELIST_GETIMAGEINFO )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );
   IMAGEINFO img;

   if( ImageList_GetImageInfo( hIL, hb_parni( 2 ), &img ) )
   {
      hb_reta( 2 );
      hb_storvnl( (LONG) img.hbmImage, -1, 1 );
      hb_storvnl( (LONG) img.hbmMask,  -1, 2 );
      //Devolver el RECT en el tercer elemento del array
   }
   else
      hb_reta( 0 );
}

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

HB_FUNC_STATIC( XIMAGELIST_MERGE )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE   hIL   = GetHandleOf( Self );

   hb_retnl( (LONG) ImageList_Merge( hIL, hb_parni( 1 ),
                                     (HIMAGELIST) hb_parnl( 2 ),
                                     hb_parni( 3 ),
                                     hb_parni( 4 ), hb_parni( 5 ) ) );
}

//--------------------------------------------------------------------------
/* NOTA: La funcion que obtenga un bitmap de una imagelist es responsable de
         destruirlo cuando no lo necesite - [JFG] */
HB_FUNC_STATIC( XIMAGELIST_GETBITMAP )
{
   PHB_ITEM Self = hb_stackSelfItem();
   HANDLE hIL = GetHandleOf( Self );
   UINT nIndex = hb_parnl( 1 ) - 1;
   int sizeX, sizeY;
   HBITMAP hBmp, oldBmp;
   HDC hdc = CreateCompatibleDC( NULL );
   HDC hdc2 = GetDC( GetDesktopWindow() );

   ImageList_GetIconSize( hIL, &sizeX, &sizeY );

   hBmp = CreateCompatibleBitmap( hdc2, sizeX, sizeY );
   oldBmp = SelectObject( hdc, hBmp );

   ImageList_Draw( hIL, nIndex, hdc, 0, 0, hb_parnl( 2 ) );

   SelectObject( hdc, oldBmp );
   DeleteDC( hdc );
   ReleaseDC( GetDesktopWindow(), hdc2 );

   hb_retnl( (long) hBmp );
}

#pragma ENDDUMP

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