#include "ctlspriv.h" #include "image.h" #include "../CommonImageList.h" #define __IOleControl_INTERFACE_DEFINED__ // There is a conflict with the IOleControl's def of CONTROLINFO #include "CommonControls.h" // Define this structure such that it will read and write the same // format for both 16 and 32 bit applications... #pragma pack(2) typedef struct _ILFILEHEADER { WORD magic; WORD version; SHORT cImage; SHORT cAlloc; SHORT cGrow; SHORT cx; SHORT cy; COLORREF clrBk; SHORT flags; SHORT aOverlayIndexes[NUM_OVERLAY_IMAGES]; // array of special images } ILFILEHEADER; // This is the old size which has only 4 overlay slots #define ILFILEHEADER_SIZE0 (SIZEOF(ILFILEHEADER) - SIZEOF(SHORT) * (NUM_OVERLAY_IMAGES - NUM_OVERLAY_IMAGES_0)) #pragma pack() void ImageList_DeleteDragBitmaps(); HRESULT Stream_WriteBitmap(LPSTREAM pstm, HBITMAP hbm, int cBitsPerPixel); HRESULT Stream_ReadBitmap(LPSTREAM pstm, BOOL f, HBITMAP* hbmp); BOOL ImageList_SetDragImage(HIMAGELIST piml, int i, int dxHotspot, int dyHotspot); class CImageList : public CImageListBase, public IImageList, public IImageListPriv, public IPersistStream { long _cRef; ~CImageList(); void _Destroy(); public: CImageList(); HRESULT Initialize(int cx, int cy, UINT flags, int cInitial, int cGrow); void _RemoveItemBitmap(int i); BOOL _IsSameObject(IUnknown* punk); HRESULT _SetIconSize(int cxImage, int cyImage); HBITMAP _CreateMirroredBitmap(HBITMAP hbmOrig); HRESULT _ReAllocBitmaps(int cAlloc); HRESULT _Add(HBITMAP hbmImage, HBITMAP hbmMask, int cImage, int xStart, int yStart, int* pi); HRESULT _AddMasked(HBITMAP hbmImage, COLORREF crMask, int* pi); HRESULT _AddValidated(HBITMAP hbmImage, HBITMAP hbmMask, int* pi); HRESULT _ReplaceValidated(int i, HBITMAP hbmImage, HBITMAP hbmMask); HRESULT _Replace(int i, int cImage, HBITMAP hbmImage, HBITMAP hbmMask, int xStart, int yStart); HRESULT _Remove(int i); HRESULT _SetOverlayImage(int iImage, int iOverlay); HRESULT _ReplaceIcon(int i, HICON hIcon, int* pi); HBITMAP _CopyBitmap(HBITMAP hbm, HDC hdc); void _Merge(IImageList* pux, int i, int dx, int dy); HRESULT _Merge(int i1, IUnknown* punk, int i2, int dx, int dy, CImageList** ppiml); HRESULT _Read(ILFILEHEADER *pilfh, HBITMAP hbmImage, HBITMAP hbmMask); BOOL _MoreOverlaysUsed(); BOOL GetSpareImageRect(RECT * prcImage); void _CopyOneImage(int iDst, int x, int y, CImageList* piml, int iSrc); BOOL CreateDragBitmaps(); COLORREF _SetBkColor(COLORREF clrBk); HBITMAP _CreateBitmap(int cx, int cy); void _ResetBkColor(int iFirst, int iLast, COLORREF clr); static BOOL GlobalInit(void); static void GlobalUninit(void); static void SelectDstBitmap(HBITMAP hbmDst); static void SelectSrcBitmap(HBITMAP hbmSrc); static CImageList* Create(int cx, int cy, UINT flags, int cInitial, int cGrow); static void _DeleteBitmap(HBITMAP hbmp); BOOL _fInitialized; BOOL _fSolidBk; // is the bkcolor a solid color (in hbmImage) BOOL _fColorsSet; // The DIB colors have been set with SetColorTable() int _cImage; // count of images in image list int _cAlloc; // # of images we have space for int _cGrow; // # of images to grow bitmaps by int _cx; // width of each image int _cy; // height int _cStrip; // # images in horizontal strip UINT _flags; // ILC_* flags COLORREF _clrBlend; // last blend color COLORREF _clrBk; // bk color or CLR_NONE for transparent. HBRUSH _hbrBk; // bk brush or black HBITMAP _hbmImage; // all images are in here HBITMAP _hbmMask; // all image masks are in here. HDC _hdcImage; HDC _hdcMask; int _aOverlayIndexes[NUM_OVERLAY_IMAGES]; // array of special images int _aOverlayX[NUM_OVERLAY_IMAGES]; // x offset of image int _aOverlayY[NUM_OVERLAY_IMAGES]; // y offset of image int _aOverlayDX[NUM_OVERLAY_IMAGES]; // cx offset of image int _aOverlayDY[NUM_OVERLAY_IMAGES]; // cy offset of image int _aOverlayF[NUM_OVERLAY_IMAGES]; // ILD_ flags for image CImageList* _pimlMirror; // Set only when another mirrored imagelist is needed (ILC_MIRROR) // // used for "blending" effects on a HiColor display. // assumes layout of a DIBSECTION. // struct { BITMAP bm; BITMAPINFOHEADER bi; DWORD ct[256]; } dib; // *** IUnknown *** STDMETHODIMP QueryInterface(REFIID riid, void **ppv); STDMETHODIMP_(ULONG)AddRef(); STDMETHODIMP_(ULONG)Release(); // *** IImageList *** STDMETHODIMP Add(HBITMAP hbmImage, HBITMAP hbmMask, int* pi); STDMETHODIMP ReplaceIcon(int i, HICON hIcon, int* pi); STDMETHODIMP SetOverlayImage(int iImage, int iOverlay); STDMETHODIMP Replace(int i, HBITMAP hbmImage, HBITMAP hbmMask); STDMETHODIMP AddMasked(HBITMAP hbmImage, COLORREF crMask, int* pi); STDMETHODIMP Draw(IMAGELISTDRAWPARAMS* pimldp); STDMETHODIMP Remove(int i); STDMETHODIMP GetIcon(int i, UINT flags, HICON* phicon); STDMETHODIMP GetImageInfo(int i, IMAGEINFO * pImageInfo); STDMETHODIMP Copy(int iDst, IUnknown* punkSrc, int iSrc, UINT uFlags); STDMETHODIMP Merge(int i1, IUnknown* punk, int i2, int dx, int dy, REFIID riid, void** ppv); STDMETHODIMP Clone(REFIID riid, void** ppv); STDMETHODIMP GetImageRect(int i, RECT * prcImage); STDMETHODIMP SetIconSize(int cxImage, int cyImage); STDMETHODIMP GetIconSize(int* pcx, int* pcy); STDMETHODIMP SetImageCount(UINT uAlloc); STDMETHODIMP GetImageCount(int* pi); STDMETHODIMP SetBkColor(COLORREF clrBk, COLORREF* pclr); STDMETHODIMP GetBkColor(COLORREF* pclr); STDMETHODIMP BeginDrag(int iTrack, int dxHotspot, int dyHotspot); STDMETHODIMP DragEnter(HWND hwndLock, int x, int y); STDMETHODIMP DragMove(int x, int y); STDMETHODIMP DragLeave(HWND hwndLock); STDMETHODIMP EndDrag(); STDMETHODIMP SetDragCursorImage(IUnknown* punk, int i, int dxHotspot, int dyHotspot); STDMETHODIMP DragShowNolock(BOOL fShow); STDMETHODIMP GetDragImage(POINT * ppt, POINT * pptHotspot, REFIID riid, void** ppv); STDMETHODIMP GetItemFlags(int i, DWORD *dwFlags); STDMETHODIMP GetOverlayImage(int iOverlay, int* piImage); // *** IImageListPriv *** STDMETHODIMP SetFlags(UINT uFlags); STDMETHODIMP GetFlags(UINT* puFlags); STDMETHODIMP SetColorTable(int start, int len, RGBQUAD *prgb, int* pi); STDMETHODIMP GetPrivateGoo(HBITMAP* hbmp, HDC* hdc, HBITMAP* hbmpMask, HDC* hdcMask); STDMETHODIMP GetMirror(REFIID riid, void** ppv); STDMETHODIMP CopyDitherImage(WORD iDst, int xDst, int yDst, IUnknown* punkSrc, int iSrc, UINT fStyle); // *** IPersist *** STDMETHODIMP GetClassID(CLSID *pClassID) { *pClassID = CLSID_ImageList; return S_OK; } STDMETHODIMP IsDirty() { return E_NOTIMPL; } // *** IPersistStream *** STDMETHODIMP Load(IStream *pStm); STDMETHODIMP Save(IStream *pStm, int fClearDirty); STDMETHODIMP GetSizeMax(ULARGE_INTEGER * pcbSize) { return E_NOTIMPL; } }; HDC g_hdcSrc = NULL; HBITMAP g_hbmSrc = NULL; HBITMAP g_hbmDcDeselect = NULL; HDC g_hdcDst = NULL; HBITMAP g_hbmDst = NULL; int g_iILRefCount = 0; HRESULT HIMAGELIST_QueryInterface(HIMAGELIST himl, REFIID riid, void** ppv) { *ppv = NULL; if (himl) { // First Convert the HIMAGELIST to an IUnknown. IUnknown* punk = reinterpret_cast(himl); // Now, we need to validate the object. CImageListBase contains the goo needed to figure out if this // is a valid imagelist. CImageListBase* pval = FindImageListBase(punk); // Now we call some private member. if (pval->IsValid()) { // If it's valid then we can QI safely. return punk->QueryInterface(riid, ppv); } } return E_POINTER; } HRESULT WimpyDrawEx(IImageList* pux, int i, HDC hdcDst, int x, int y, int cx, int cy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle) { IMAGELISTDRAWPARAMS imldp = {0}; imldp.cbSize = sizeof(imldp); imldp.himl = reinterpret_cast(pux); imldp.i = i; imldp.hdcDst = hdcDst; imldp.x = x; imldp.y = y; imldp.cx = cx; imldp.cy = cy; imldp.rgbBk = rgbBk; imldp.rgbFg = rgbFg; imldp.fStyle = fStyle; imldp.dwRop = SRCCOPY; return pux->Draw(&imldp); } HRESULT WimpyDraw(IImageList* pux, int i, HDC hdcDst, int x, int y, UINT fStyle) { IMAGELISTDRAWPARAMS imldp = {0}; imldp.cbSize = sizeof(imldp); imldp.himl = reinterpret_cast(pux); imldp.i = i; imldp.hdcDst = hdcDst; imldp.x = x; imldp.y = y; imldp.rgbBk = CLR_DEFAULT; imldp.rgbFg = CLR_DEFAULT; imldp.fStyle = fStyle; imldp.dwRop = SRCCOPY; return pux->Draw(&imldp); } CImageList::CImageList() : _cRef(1) { } CImageList::~CImageList() { if (_pimlMirror) { _pimlMirror->Release(); } _Destroy(); } HRESULT CImageList::Initialize(int cxI, int cyI, UINT flagsI, int cInitialI, int cGrowI) { HRESULT hr = E_OUTOFMEMORY; if (cGrowI < 4) { cGrowI = 4; } else { // round up by 4's cGrowI = (cGrowI + 3) & ~3; } _cStrip = 4; _cGrow = cGrowI; _cx = cxI; _cy = cyI; _clrBlend = CLR_NONE; _clrBk = CLR_NONE; _hbrBk = (HBRUSH)GetStockObject(BLACK_BRUSH); _fSolidBk = TRUE; _flags = flagsI; _pimlMirror = NULL; // // Initialize the overlay indexes to -1 since 0 is a valid index. // for (int i = 0; i < NUM_OVERLAY_IMAGES; i++) { _aOverlayIndexes[i] = -1; } _hdcImage = CreateCompatibleDC(NULL); if (_hdcImage) { hr = S_OK; if (_flags & ILC_MASK) { _hdcMask = CreateCompatibleDC(NULL); if (!_hdcMask) hr = E_OUTOFMEMORY; } if (SUCCEEDED(hr)) { hr = _ReAllocBitmaps(cInitialI + 1); if (FAILED(hr)) { hr = _ReAllocBitmaps(1); } } } // Don't do this if we are already initialized, we just want to pass new information.... if (SUCCEEDED(hr) && !_fInitialized) g_iILRefCount++; _fInitialized = TRUE; return hr; } HRESULT CImageList::QueryInterface(REFIID riid, void **ppv) { HRESULT hr = E_NOINTERFACE; if (riid == IID_IUnknown || riid == IID_IImageList) { *ppv = (IImageList*)this; hr = S_OK; } else if (riid == IID_IImageListPriv) { *ppv = (IImageListPriv*)this; hr = S_OK; } else if (riid == IID_IPersist) { *ppv = (IPersist*)this; hr = S_OK; } else if (riid == IID_IPersistStream) { *ppv = (IPersistStream*)this; hr = S_OK; } if (SUCCEEDED(hr)) AddRef(); return hr; } ULONG CImageList::AddRef() { return InterlockedIncrement(&_cRef); } ULONG CImageList::Release() { if (InterlockedDecrement(&_cRef)) return _cRef; delete this; return 0; } HRESULT CImageList::GetPrivateGoo(HBITMAP* phbmp, HDC* phdc, HBITMAP* phbmpMask, HDC* phdcMask) { if (phbmp) *phbmp = _hbmImage; if (phdc) *phdc = _hdcImage; if (phbmpMask) *phbmpMask = _hbmMask; if (phdcMask) *phdcMask = _hdcMask; return S_OK; } HRESULT CImageList::GetMirror(REFIID riid, void** ppv) { if (_pimlMirror) return _pimlMirror->QueryInterface(riid, ppv); return E_NOINTERFACE; } // // global work buffer, this buffer is always a DDB never a DIBSection // HBITMAP g_hbmWork = NULL; // work buffer. BITMAP g_bmWork = {0}; // work buffer size HBRUSH g_hbrMonoDither = NULL; // gray dither brush for dragging HBRUSH g_hbrStripe = NULL; #define NOTSRCAND 0x00220326L #define ROP_PSo 0x00FC008A #define ROP_DPo 0x00FA0089 #define ROP_DPna 0x000A0329 #define ROP_DPSona 0x00020c89 #define ROP_SDPSanax 0x00E61ce8 #define ROP_DSna 0x00220326 #define ROP_PSDPxax 0x00b8074a #define ROP_PatNotMask 0x00b8074a // D <- S==0 ? P : D #define ROP_PatMask 0x00E20746 // D <- S==1 ? P : D #define ROP_MaskPat 0x00AC0744 // D <- P==1 ? D : S #define ROP_DSo 0x00EE0086L #define ROP_DSno 0x00BB0226L #define ROP_DSa 0x008800C6L static int g_iDither = 0; void InitDitherBrush() { HBITMAP hbmTemp; static const WORD graybits[] = {0xAAAA, 0x5555, 0xAAAA, 0x5555, 0xAAAA, 0x5555, 0xAAAA, 0x5555}; if (g_iDither) { g_iDither++; } else { // build the dither brush. this is a fixed 8x8 bitmap hbmTemp = CreateBitmap(8, 8, 1, 1, graybits); if (hbmTemp) { // now use the bitmap for what it was really intended... g_hbrMonoDither = CreatePatternBrush(hbmTemp); DeleteObject(hbmTemp); g_iDither++; } } } void TerminateDitherBrush() { g_iDither--; if (g_iDither == 0) { DeleteObject(g_hbrMonoDither); g_hbrMonoDither = NULL; } } /* ** GetScreenDepth() */ int GetScreenDepth() { int i; HDC hdc = GetDC(NULL); i = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES); ReleaseDC(NULL, hdc); return i; } // // should we use a DIB section on the current device? // // the main goal of using DS is to save memory, but they draw slow // on some devices. // // 4bpp Device (ie 16 color VGA) dont use DS // 8bpp Device (ie 256 color SVGA) use DS if DIBENG based. // >8bpp Device (ie 16bpp 24bpp) always use DS, saves memory // #define CAPS1 94 /* other caps */ #define C1_DIBENGINE 0x0010 /* DIB Engine compliant driver */ // // create a bitmap compatible with the given ImageList // HBITMAP CImageList::_CreateBitmap(int cx, int cy) { HDC hdc; HBITMAP hbm; void* lpBits; struct { BITMAPINFOHEADER bi; DWORD ct[256]; } dib; // // create a compatible bitmap if the imagelist has a bitmap already. // if (_hbmImage && _hdcImage) { return CreateCompatibleBitmap(_hdcImage, cx, cy); } hdc = GetDC(NULL); // no color depth was specifed // // if we are on a DIBENG based DISPLAY, we use 4bit DIBSections to save // memory. // if ((_flags & ILC_COLORMASK) == 0) { _flags |= ILC_COLOR4; } if ((_flags & ILC_COLORMASK) != ILC_COLORDDB) { dib.bi.biSize = sizeof(BITMAPINFOHEADER); dib.bi.biWidth = cx; dib.bi.biHeight = cy; dib.bi.biPlanes = 1; dib.bi.biBitCount = (_flags & ILC_COLORMASK); dib.bi.biCompression = BI_RGB; dib.bi.biSizeImage = 0; dib.bi.biXPelsPerMeter = 0; dib.bi.biYPelsPerMeter = 0; dib.bi.biClrUsed = 16; dib.bi.biClrImportant = 0; dib.ct[0] = 0x00000000; // 0000 black dib.ct[1] = 0x00800000; // 0001 dark red dib.ct[2] = 0x00008000; // 0010 dark green dib.ct[3] = 0x00808000; // 0011 mustard dib.ct[4] = 0x00000080; // 0100 dark blue dib.ct[5] = 0x00800080; // 0101 purple dib.ct[6] = 0x00008080; // 0110 dark turquoise dib.ct[7] = 0x00C0C0C0; // 1000 gray dib.ct[8] = 0x00808080; // 0111 dark gray dib.ct[9] = 0x00FF0000; // 1001 red dib.ct[10] = 0x0000FF00; // 1010 green dib.ct[11] = 0x00FFFF00; // 1011 yellow dib.ct[12] = 0x000000FF; // 1100 blue dib.ct[13] = 0x00FF00FF; // 1101 pink (magenta) dib.ct[14] = 0x0000FFFF; // 1110 cyan dib.ct[15] = 0x00FFFFFF; // 1111 white if (dib.bi.biBitCount == 8) { HPALETTE hpal; int i; if (hpal = CreateHalftonePalette(NULL)) { i = GetPaletteEntries(hpal, 0, 256, (LPPALETTEENTRY)&dib.ct[0]); DeleteObject(hpal); if (i > 64) { dib.bi.biClrUsed = i; for (i=0; i<(int)dib.bi.biClrUsed; i++) dib.ct[i] = RGB(GetBValue(dib.ct[i]),GetGValue(dib.ct[i]),GetRValue(dib.ct[i])); } } else { dib.bi.biBitCount = (_flags & ILC_COLORMASK); dib.bi.biClrUsed = 256; } if (dib.bi.biClrUsed <= 16) dib.bi.biBitCount = 4; } hbm = CreateDIBSection(hdc, (LPBITMAPINFO)&dib, DIB_RGB_COLORS, &lpBits, NULL, 0); } else { hbm = CreateCompatibleBitmap(hdc, cx, cy); } ReleaseDC(NULL, hdc); return hbm; } EXTERN_C HBITMAP CreateColorBitmap(int cx, int cy) { HBITMAP hbm; HDC hdc; hdc = GetDC(NULL); // // on a multimonitor system with mixed bitdepths // always use a 32bit bitmap for our work buffer // this will prevent us from losing colors when // blting to and from the screen. this is mainly // important for the drag & drop offscreen buffers. // if (!(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) && GetSystemMetrics(SM_CMONITORS) > 1 && GetSystemMetrics(SM_SAMEDISPLAYFORMAT) == 0) { void* p; BITMAPINFO bi = {sizeof(BITMAPINFOHEADER), cx, cy, 1, 32}; hbm = CreateDIBSection(hdc, &bi, DIB_RGB_COLORS, &p, NULL, 0); } else { hbm = CreateCompatibleBitmap(hdc, cx, cy); } ReleaseDC(NULL, hdc); return hbm; } EXTERN_C HBITMAP CreateMonoBitmap(int cx, int cy) { return CreateBitmap(cx, cy, 1, 1, NULL); } //============================================================================ BOOL CImageList::GlobalInit(void) { HDC hdcScreen; static const WORD stripebits[] = {0x7777, 0xdddd, 0x7777, 0xdddd, 0x7777, 0xdddd, 0x7777, 0xdddd}; HBITMAP hbmTemp; // if already initialized, there is nothing to do if (g_hdcDst) return TRUE; hdcScreen = GetDC(HWND_DESKTOP); g_hdcSrc = CreateCompatibleDC(hdcScreen); g_hdcDst = CreateCompatibleDC(hdcScreen); InitDitherBrush(); hbmTemp = CreateBitmap(8, 8, 1, 1, stripebits); if (hbmTemp) { // initialize the deselect 1x1 bitmap g_hbmDcDeselect = SelectBitmap(g_hdcDst, hbmTemp); SelectBitmap(g_hdcDst, g_hbmDcDeselect); g_hbrStripe = CreatePatternBrush(hbmTemp); DeleteObject(hbmTemp); } ReleaseDC(HWND_DESKTOP, hdcScreen); if (!g_hdcSrc || !g_hdcDst || !g_hbrMonoDither) { CImageList::GlobalUninit(); TraceMsg(TF_ERROR, "ImageList: Unable to initialize"); return FALSE; } return TRUE; } void CImageList::GlobalUninit() { TerminateDitherBrush(); if (g_hbrStripe) { DeleteObject(g_hbrStripe); g_hbrStripe = NULL; } ImageList_DeleteDragBitmaps(); if (g_hdcDst) { CImageList::SelectDstBitmap(NULL); DeleteDC(g_hdcDst); g_hdcDst = NULL; } if (g_hdcSrc) { CImageList::SelectSrcBitmap(NULL); DeleteDC(g_hdcSrc); g_hdcSrc = NULL; } if (g_hbmWork) { DeleteBitmap(g_hbmWork); g_hbmWork = NULL; } } void CImageList::SelectDstBitmap(HBITMAP hbmDst) { ASSERTCRITICAL; if (hbmDst != g_hbmDst) { // If it's selected in the source DC, then deselect it first // if (hbmDst && hbmDst == g_hbmSrc) CImageList::SelectSrcBitmap(NULL); SelectBitmap(g_hdcDst, hbmDst ? hbmDst : g_hbmDcDeselect); g_hbmDst = hbmDst; } } void CImageList::SelectSrcBitmap(HBITMAP hbmSrc) { ASSERTCRITICAL; if (hbmSrc != g_hbmSrc) { // If it's selected in the dest DC, then deselect it first // if (hbmSrc && hbmSrc == g_hbmDst) CImageList::SelectDstBitmap(NULL); SelectBitmap(g_hdcSrc, hbmSrc ? hbmSrc : g_hbmDcDeselect); g_hbmSrc = hbmSrc; } } HDC ImageList_GetWorkDC(HDC hdc, int dx, int dy) { ASSERTCRITICAL; if (g_hbmWork == NULL || GetDeviceCaps(hdc, BITSPIXEL) != g_bmWork.bmBitsPixel || g_bmWork.bmWidth < dx || g_bmWork.bmHeight < dy) { CImageList::_DeleteBitmap(g_hbmWork); g_hbmWork = NULL; if (dx == 0 || dy == 0) return NULL; if (g_hbmWork = CreateCompatibleBitmap(hdc, dx, dy)) { GetObject(g_hbmWork, sizeof(g_bmWork), &g_bmWork); } } CImageList::SelectSrcBitmap(g_hbmWork); if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) { HPALETTE hpal = (HPALETTE)SelectPalette(hdc, (HPALETTE)GetStockObject(DEFAULT_PALETTE), TRUE); SelectPalette(g_hdcSrc, hpal, TRUE); } return g_hdcSrc; } void ImageList_ReleaseWorkDC(HDC hdc) { ASSERTCRITICAL; ASSERT(hdc == g_hdcSrc); if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) { SelectPalette(hdc, (HPALETTE)GetStockObject(DEFAULT_PALETTE), TRUE); } } void CImageList::_DeleteBitmap(HBITMAP hbm) { ASSERTCRITICAL; if (hbm) { if (g_hbmDst == hbm) CImageList::SelectDstBitmap(NULL); if (g_hbmSrc == hbm) CImageList::SelectSrcBitmap(NULL); DeleteBitmap(hbm); } } #define ILC_WIN95 (ILC_MASK | ILC_COLORMASK | ILC_SHARED | ILC_PALETTE) //============================================================================ HRESULT ImageList_InitGlobals() { HRESULT hr = S_OK; ENTERCRITICAL; if (!g_iILRefCount) { if (!CImageList::GlobalInit()) { hr = E_OUTOFMEMORY; } } LEAVECRITICAL; return S_OK; } CImageList* CImageList::Create(int cx, int cy, UINT flags, int cInitial, int cGrow) { CImageList* piml = NULL; HRESULT hr = S_OK; if (cx < 0 || cy < 0) return NULL; // Validate the flags if (flags & ~ILC_VALID) return NULL; hr = ImageList_InitGlobals(); ENTERCRITICAL; if (SUCCEEDED(hr)) { piml = new CImageList(); // allocate the bitmap PLUS one re-usable entry if (piml) { hr = piml->Initialize(cx, cy, flags, cInitial, cGrow); if (FAILED(hr)) { piml->Release(); piml = NULL; } } } LEAVECRITICAL; return piml; } void CImageList::_Destroy() { ENTERCRITICAL; // nuke dc's if (_hdcImage) { SelectObject(_hdcImage, g_hbmDcDeselect); DeleteDC(_hdcImage); } if (_hdcMask) { SelectObject(_hdcMask, g_hbmDcDeselect); DeleteDC(_hdcMask); } // nuke bitmaps if (_hbmImage) _DeleteBitmap(_hbmImage); if (_hbmMask) _DeleteBitmap(_hbmMask); if (_hbrBk) DeleteObject(_hbrBk); // one less use of imagelists. if it's the last, terminate the imagelist g_iILRefCount--; if (!g_iILRefCount) CImageList::GlobalUninit(); LEAVECRITICAL; } HRESULT CImageList::GetImageCount(int* pi) { *pi = _cImage; return S_OK; } HRESULT CImageList::SetImageCount(UINT uAlloc) { ENTERCRITICAL; HRESULT hr = _ReAllocBitmaps(-((int)uAlloc + 1)); if (SUCCEEDED(hr)) { _cImage = (int)uAlloc; } LEAVECRITICAL; return hr; } HRESULT CImageList::GetIconSize(int* pcx, int* pcy) { if (!pcx || !pcy) return E_INVALIDARG; *pcx = _cx; *pcy = _cy; return S_OK; } // // change the size of a existing image list // also removes all items // HRESULT CImageList::_SetIconSize(int cxImage, int cyImage) { if (_cx == cxImage && _cy == cyImage) return S_FALSE; // no change if (_cx < 0 || _cy < 0) return E_INVALIDARG; // invalid dimensions _cx = cxImage; _cy = cyImage; return Remove(-1); } HRESULT CImageList::SetIconSize(int cxImage, int cyImage) { if (_pimlMirror) { _pimlMirror->_SetIconSize(cxImage, cyImage); } return _SetIconSize(cxImage, cyImage); } // // ImageList_SetFlags // // change the image list flags, then rebuilds the bitmaps. // // the only reason to call this function is to change the // color depth of the image list, the shell needs to do this // when the screen depth changes and it wants to use HiColor icons. // HRESULT CImageList::SetFlags(UINT uFlags) { HBITMAP hOldImage; // check for valid input flags if (_flags & ~ILC_VALID) return E_INVALIDARG; // you cant change these flags. if ((uFlags ^ _flags) & ILC_SHARED) return E_INVALIDARG; // now change the flags and rebuild the bitmaps. _flags = uFlags; // set the old bitmap to NULL, so when Imagelist_remove calls // ImageList_createBitmap, it will not call CreatecomptibleBitmap, // it will create the spec for the bitmap from scratch.. hOldImage = _hbmImage; _hbmImage = NULL; Remove(-1); // imagelist::remove will have ensured that the old image is no longer selected // thus we can now delete it... if ( hOldImage ) DeleteObject( hOldImage ); return S_OK; } HRESULT CImageList::GetFlags(UINT* puFlags) { *puFlags = (_flags & ILC_VALID) | (_pimlMirror ? ILC_MIRROR : 0); return S_OK; } // reset the background color of images iFirst through iLast void CImageList::_ResetBkColor(int iFirst, int iLast, COLORREF clr) { HBRUSH hbrT=NULL; DWORD rop; if (_hdcMask == NULL) return; if (clr == CLR_BLACK || clr == CLR_NONE) { rop = ROP_DSna; } else if (clr == CLR_WHITE) { rop = ROP_DSo; } else { ASSERT(_hbrBk); ASSERT(_clrBk == clr); rop = ROP_PatMask; hbrT = SelectBrush(_hdcImage, _hbrBk); } for ( ;iFirst <= iLast; iFirst++) { RECT rc; GetImageRect(iFirst, &rc); BitBlt(_hdcImage, rc.left, rc.top, _cx, _cy, _hdcMask, rc.left, rc.top, rop); } if (hbrT) SelectBrush(_hdcImage, hbrT); } // // GetNearestColor is problematic. If you have a 32-bit HDC with a 16-bit bitmap // selected into it, and you call GetNearestColor, GDI ignores the // color-depth of the bitmap and thinks you have a 32-bit bitmap inside, // so of course it returns the same color unchanged. // // So instead, we have to emulate GetNearestColor with SetPixel. // COLORREF GetNearestColor32(HDC hdc, COLORREF rgb) { COLORREF rgbT; rgbT = GetPixel(hdc, 0, 0); rgb = SetPixel(hdc, 0, 0, rgb); SetPixelV(hdc, 0, 0, rgbT); return rgb; } COLORREF CImageList::_SetBkColor(COLORREF clrBkI) { COLORREF clrBkOld; // Quick out if there is no change in color if (_clrBk == clrBkI) { return _clrBk; } // The following code deletes the brush, resets the background color etc., // so, protect it with a critical section. ENTERCRITICAL; if (_hbrBk) { DeleteBrush(_hbrBk); } clrBkOld = _clrBk; _clrBk = clrBkI; if (_clrBk == CLR_NONE) { _hbrBk = (HBRUSH)GetStockObject(BLACK_BRUSH); _fSolidBk = TRUE; } else { _hbrBk = CreateSolidBrush(_clrBk); _fSolidBk = GetNearestColor32(_hdcImage, _clrBk) == _clrBk; } if (_cImage > 0) { _ResetBkColor(0, _cImage - 1, _clrBk); } LEAVECRITICAL; return clrBkOld; } HRESULT CImageList::SetBkColor(COLORREF clrBk, COLORREF* pclr) { if (_pimlMirror) { _pimlMirror->_SetBkColor(clrBk); } *pclr = _SetBkColor(clrBk); return S_OK; } HRESULT CImageList::GetBkColor(COLORREF* pclr) { *pclr = _clrBk; return S_OK; } HRESULT CImageList::_ReAllocBitmaps(int cAllocI) { HBITMAP hbmImageNew; HBITMAP hbmMaskNew; int cxL, cyL; // HACK: don't shrink unless the caller passes a negative count if (cAllocI > 0) { if (_cAlloc >= cAllocI) return S_OK; } else cAllocI *= -1; hbmMaskNew = NULL; hbmImageNew = NULL; cxL = _cx * _cStrip; cyL = _cy * ((cAllocI + _cStrip - 1) / _cStrip); if (cAllocI > 0) { if (_flags & ILC_MASK) { hbmMaskNew = CreateMonoBitmap(cxL, cyL); if (!hbmMaskNew) { TraceMsg(TF_ERROR, "ImageList: Can't create bitmap"); return E_OUTOFMEMORY; } } hbmImageNew = _CreateBitmap(cxL, cyL); if (!hbmImageNew) { if (hbmMaskNew) CImageList::_DeleteBitmap(hbmMaskNew); TraceMsg(TF_ERROR, "ImageList: Can't create bitmap"); return E_OUTOFMEMORY; } } if (_cImage > 0) { int cyCopy = _cy * ((min(cAllocI, _cImage) + _cStrip - 1) / _cStrip); if (_flags & ILC_MASK) { CImageList::SelectDstBitmap(hbmMaskNew); BitBlt(g_hdcDst, 0, 0, cxL, cyCopy, _hdcMask, 0, 0, SRCCOPY); } CImageList::SelectDstBitmap(hbmImageNew); BitBlt(g_hdcDst, 0, 0, cxL, cyCopy, _hdcImage, 0, 0, SRCCOPY); } // select into DC's, delete then assign CImageList::SelectDstBitmap(NULL); CImageList::SelectSrcBitmap(NULL); SelectObject(_hdcImage, hbmImageNew); if (_hdcMask) SelectObject(_hdcMask, hbmMaskNew); if (_hbmMask) CImageList::_DeleteBitmap(_hbmMask); if (_hbmImage) CImageList::_DeleteBitmap(_hbmImage); _hbmMask = hbmMaskNew; _hbmImage = hbmImageNew; _clrBlend = CLR_NONE; _cAlloc = cAllocI; return S_OK; } HBITMAP CImageList::_CreateMirroredBitmap(HBITMAP hbmOrig) { HBITMAP hbm = NULL, hOld_bm1, hOld_bm2; BITMAP bm; if (!hbmOrig) return NULL; if (!GetObject(hbmOrig, sizeof(BITMAP), &bm)) return NULL; // Grab the screen DC HDC hdc = GetDC(NULL); HDC hdcMem1 = CreateCompatibleDC(hdc); if (!hdcMem1) { ReleaseDC(NULL, hdc); return NULL; } HDC hdcMem2 = CreateCompatibleDC(hdc); if (!hdcMem2) { DeleteDC(hdcMem1); ReleaseDC(NULL, hdc); return NULL; } hbm = CreateColorBitmap(bm.bmWidth, bm.bmHeight); if (!hbm) { DeleteDC(hdcMem2); DeleteDC(hdcMem1); ReleaseDC(NULL, hdc); return NULL; } // // Flip the bitmap // hOld_bm1 = (HBITMAP)SelectObject(hdcMem1, hbmOrig); hOld_bm2 = (HBITMAP)SelectObject(hdcMem2 , hbm ); SET_DC_RTL_MIRRORED(hdcMem2); BitBlt(hdcMem2, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem1, 0, 0, SRCCOPY); SelectObject(hdcMem1, hOld_bm1 ); SelectObject(hdcMem1, hOld_bm2 ); DeleteDC(hdcMem2); DeleteDC(hdcMem1); ReleaseDC(NULL, hdc); return hbm; } HRESULT CImageList::SetColorTable(int start, int len, RGBQUAD *prgb, int* pi) { // mark it that we have set the color table so that it won't be overwritten // by the first bitmap add.... _fColorsSet = TRUE; if (_hdcImage) { *pi = SetDIBColorTable(_hdcImage, start, len, prgb); return S_OK; } return E_FAIL; } HRESULT CImageList::_Add(HBITMAP hbmImageI, HBITMAP hbmMaskI, int cImageI, int xStart, int yStart, int* pi) { int i = -1; HRESULT hr = S_OK; ENTERCRITICAL; // // if the ImageList is empty clone the color table of the first // bitmap you add to the imagelist. // // the ImageList needs to be a 8bpp image list // the bitmap being added needs to be a 8bpp DIBSection // if (hbmImageI && _cImage == 0 && (_flags & ILC_COLORMASK) != ILC_COLORDDB) { if (!_fColorsSet) { int n; RGBQUAD argb[256]; CImageList::SelectDstBitmap(hbmImageI); if (n = GetDIBColorTable(g_hdcDst, 0, 256, argb)) { int i; SetColorTable(0, n, argb, &i); } CImageList::SelectDstBitmap(NULL); } _clrBlend = CLR_NONE; } if (_cImage + cImageI + 1 > _cAlloc) { hr = _ReAllocBitmaps(_cAlloc + max(cImageI, _cGrow) + 1); } if (SUCCEEDED(hr)) { i = _cImage; _cImage += cImageI; if (hbmImageI) { hr = _Replace(i, cImageI, hbmImageI, hbmMaskI, xStart, yStart); if (FAILED(hr)) { _cImage -= cImageI; i = -1; } } } LEAVECRITICAL; *pi = i; return hr; } HRESULT CImageList::_AddValidated(HBITMAP hbmImage, HBITMAP hbmMask, int* pi) { BITMAP bm; int cImageI; if (GetObject(hbmImage, sizeof(bm), &bm) != sizeof(bm) || bm.bmWidth < _cx) { return E_INVALIDARG; } ASSERT(hbmImage); ASSERT(_cx); cImageI = bm.bmWidth / _cx; // # of images in source // serialization handled within Add2. return _Add(hbmImage, hbmMask, cImageI, 0, 0, pi); } HRESULT CImageList::Add(HBITMAP hbmImage, HBITMAP hbmMask, int* pi) { if (_pimlMirror) { HBITMAP hbmMirroredImage = _CreateMirroredBitmap(hbmImage); HBITMAP hbmMirroredMask = _CreateMirroredBitmap(hbmMask); _pimlMirror->_AddValidated(hbmMirroredImage, hbmMirroredMask, pi); // The caller will take care of deleting hbmImage, hbmMask // He knows nothing about hbmMirroredImage, hbmMirroredMask DeleteObject(hbmMirroredImage); DeleteObject(hbmMirroredMask); } return _AddValidated(hbmImage, hbmMask, pi); } HRESULT CImageList::_AddMasked(HBITMAP hbmImageI, COLORREF crMask, int* pi) { HRESULT hr = S_OK; COLORREF crbO, crtO; HBITMAP hbmMaskI; int cImageI; int n,i; BITMAP bm; DWORD ColorTableSave[256]; DWORD ColorTable[256]; *pi = -1; if (GetObject(hbmImageI, sizeof(bm), &bm) != sizeof(bm)) return E_INVALIDARG; hbmMaskI = CreateMonoBitmap(bm.bmWidth, bm.bmHeight); if (!hbmMaskI) return E_OUTOFMEMORY; ENTERCRITICAL; // copy color to mono, with crMask turning 1 and all others 0, then // punch all crMask pixels in color to 0 CImageList::SelectSrcBitmap(hbmImageI); CImageList::SelectDstBitmap(hbmMaskI); // crMask == CLR_DEFAULT, means use the pixel in the upper left // if (crMask == CLR_DEFAULT) crMask = GetPixel(g_hdcSrc, 0, 0); // DIBSections dont do color->mono like DDBs do, so we have to do it. // this only works for <=8bpp DIBSections, this method does not work // for HiColor DIBSections. // // This code is a workaround for a problem in Win32 when a DIB is converted to // monochrome. The conversion is done according to closeness to white or black // and without regard to the background color. This workaround is is not required // under MainWin. // // Please note, this code has an endianship problems the comparision in the if statement // below is sensitive to endianship // ----> if (ColorTableSave[i] == RGB(GetBValue(crMask),GetGValue(crMask),GetRValue(crMask)) // if (bm.bmBits != NULL && bm.bmBitsPixel <= 8) { n = GetDIBColorTable(g_hdcSrc, 0, 256, (RGBQUAD*)ColorTableSave); for (i=0; i_AddMasked(hbmMirroredImage, crMask, pi); // The caller will take care of deleting hbmImage // He knows nothing about hbmMirroredImage DeleteObject(hbmMirroredImage); } return _AddMasked(hbmImage, crMask, pi); } HRESULT CImageList::_ReplaceValidated(int i, HBITMAP hbmImage, HBITMAP hbmMask) { HRESULT hr = E_INVALIDARG; if (!IsImageListIndex(i)) return hr; ENTERCRITICAL; hr = _Replace(i, 1, hbmImage, hbmMask, 0, 0); LEAVECRITICAL; return hr; } HRESULT CImageList::Replace(int i, HBITMAP hbmImage, HBITMAP hbmMask) { if (_pimlMirror) { HBITMAP hbmMirroredImage = CImageList::_CreateMirroredBitmap(hbmImage); if (hbmMirroredImage) { HBITMAP hbmMirroredMask = CImageList::_CreateMirroredBitmap(hbmMask); if (hbmMirroredMask) { _pimlMirror->_ReplaceValidated(i, hbmMirroredImage, hbmMirroredMask); // The caller will take care of deleting hbmImage, hbmMask // He knows nothing about hbmMirroredImage, hbmMirroredMask DeleteObject(hbmMirroredMask); } DeleteObject(hbmMirroredImage); } } return _ReplaceValidated(i, hbmImage, hbmMask); } // replaces images in piml with images from bitmaps // // in: // piml // i index in image list to start at (replace) // _cImage count of images in source (hbmImage, hbmMask) // HRESULT CImageList::_Replace(int i, int cImageI, HBITMAP hbmImageI, HBITMAP hbmMaskI, int xStart, int yStart) { RECT rcImage; int x, iImage; ASSERT(_hbmImage); CImageList::SelectSrcBitmap(hbmImageI); if (_hdcMask) CImageList::SelectDstBitmap(hbmMaskI); // using as just a second source hdc for (x = xStart, iImage = 0; iImage < cImageI; iImage++, x += _cx) { GetImageRect(i + iImage, &rcImage); if (_hdcMask) { BitBlt(_hdcMask, rcImage.left, rcImage.top, _cx, _cy, g_hdcDst, x, yStart, SRCCOPY); } BitBlt(_hdcImage, rcImage.left, rcImage.top, _cx, _cy, g_hdcSrc, x, yStart, SRCCOPY); } _ResetBkColor(i, i + cImageI - 1, _clrBk); CImageList::SelectSrcBitmap(NULL); if (_hdcMask) CImageList::SelectDstBitmap(NULL); return S_OK; } HRESULT CImageList::GetIcon(int i, UINT flags, HICON* phicon) { UINT cxImage, cyImage; HICON hIcon = NULL; HBITMAP hbmMask, hbmColor; ICONINFO ii; HRESULT hr = E_OUTOFMEMORY; if (!IsImageListIndex(i)) return E_INVALIDARG; cxImage = _cx; cyImage = _cy; hbmColor = CreateColorBitmap(cxImage, cyImage); if (hbmColor) { hbmMask = CreateMonoBitmap(cxImage, cyImage); if (hbmMask) { ENTERCRITICAL; CImageList::SelectDstBitmap(hbmMask); PatBlt(g_hdcDst, 0, 0, cxImage, cyImage, WHITENESS); WimpyDraw(SAFECAST(this, IImageList*), i, g_hdcDst, 0, 0, ILD_MASK | flags); CImageList::SelectDstBitmap(hbmColor); PatBlt(g_hdcDst, 0, 0, cxImage, cyImage, BLACKNESS); WimpyDraw(SAFECAST(this, IImageList*), i, g_hdcDst, 0, 0, ILD_TRANSPARENT | flags); CImageList::SelectDstBitmap(NULL); LEAVECRITICAL; ii.fIcon = TRUE; ii.xHotspot = 0; ii.yHotspot = 0; ii.hbmColor = hbmColor; ii.hbmMask = hbmMask; hIcon = CreateIconIndirect(&ii); DeleteObject(hbmMask); hr = S_OK; } DeleteObject(hbmColor); } *phicon = hIcon; return hr; } // this removes an image from the bitmap but doing all the // proper shuffling. // // this does the following: // if the bitmap being removed is not the last in the row // it blts the images to the right of the one being deleted // to the location of the one being deleted (covering it up) // // for all rows until the last row (where the last image is) // move the image from the next row up to the last position // in the current row. then slide over all images in that // row to the left. void CImageList::_RemoveItemBitmap(int i) { RECT rc1; RECT rc2; int dx, y; int x; GetImageRect(i, &rc1); GetImageRect(_cImage - 1, &rc2); // the row with the image being deleted, do we need to shuffle? // amount of stuff to shuffle dx = _cStrip * _cx - rc1.right; if (dx) { // yes, shuffle things left BitBlt(_hdcImage, rc1.left, rc1.top, dx, _cy, _hdcImage, rc1.right, rc1.top, SRCCOPY); if (_hdcMask) BitBlt(_hdcMask, rc1.left, rc1.top, dx, _cy, _hdcMask, rc1.right, rc1.top, SRCCOPY); } y = rc1.top; // top of row we are working on x = _cx * (_cStrip - 1); // x coord of last bitmaps in each row while (y < rc2.top) { // copy first from row below to last image position on this row BitBlt(_hdcImage, x, y, _cx, _cy, _hdcImage, 0, y + _cy, SRCCOPY); if (_hdcMask) BitBlt(_hdcMask, x, y, _cx, _cy, _hdcMask, 0, y + _cy, SRCCOPY); y += _cy; // jump to row to slide left if (y <= rc2.top) { // slide the rest over to the left BitBlt(_hdcImage, 0, y, x, _cy, _hdcImage, _cx, y, SRCCOPY); // slide the rest over to the left if (_hdcMask) { BitBlt(_hdcMask, 0, y, x, _cy, _hdcMask, _cx, y, SRCCOPY); } } } } // // ImageList_Remove - remove a image from the image list // // i - image to remove, or -1 to remove all images. // // NOTE all images are "shifted" down, ie all image index's // above the one deleted are changed by 1 // HRESULT CImageList::_Remove(int i) { HRESULT hr = S_OK; ENTERCRITICAL; if (i == -1) { _cImage = 0; _cAlloc = 0; for (i=0; i _cGrow) _ReAllocBitmaps(_cAlloc - _cGrow); } } LEAVECRITICAL; return hr; } HRESULT CImageList::Remove(int i) { if (_pimlMirror) { _pimlMirror->_Remove(i); } return _Remove(i); } BOOL CImageList::_IsSameObject(IUnknown* punk) { BOOL fRet = FALSE; IUnknown* me; IUnknown* them; if (punk == NULL) return FALSE; QueryInterface(IID_PPV_ARG(IUnknown, &me)); if (SUCCEEDED(punk->QueryInterface(IID_PPV_ARG(IUnknown, &them)))) { fRet = (me == them); them->Release(); } me->Release(); return fRet; } // // ImageList_Copy - move an image in the image list // HRESULT CImageList::Copy(int iDst, IUnknown* punkSrc, int iSrc, UINT uFlags) { RECT rcDst, rcSrc, rcTmp; CImageList* pimlTmp; CImageList* pimlSrc; HRESULT hr = E_FAIL; if (uFlags & ~ILCF_VALID) { // don't let hosers pass bogus flags RIPMSG(0, "ImageList_Copy: Invalid flags %08x", uFlags); return E_INVALIDARG; } // Not supported if (!_IsSameObject(punkSrc)) { return E_INVALIDARG; } // We only support copies on ourself... Weird pimlSrc = this; ENTERCRITICAL; pimlTmp = (uFlags & ILCF_SWAP)? pimlSrc : NULL; if (SUCCEEDED(GetImageRect(iDst, &rcDst)) && SUCCEEDED(pimlSrc->GetImageRect(iSrc, &rcSrc)) && (!pimlTmp || pimlTmp->GetSpareImageRect(&rcTmp))) { int cx = pimlSrc->_cx; int cy = pimlSrc->_cy; // // iff we are swapping we need to save the destination image // if (pimlTmp) { BitBlt(pimlTmp->_hdcImage, rcTmp.left, rcTmp.top, cx, cy, _hdcImage, rcDst.left, rcDst.top, SRCCOPY); if (pimlTmp->_hdcMask) { BitBlt(pimlTmp->_hdcMask, rcTmp.left, rcTmp.top, cx, cy, _hdcMask, rcDst.left, rcDst.top, SRCCOPY); } } // // copy the image // BitBlt(_hdcImage, rcDst.left, rcDst.top, cx, cy, pimlSrc->_hdcImage, rcSrc.left, rcSrc.top, SRCCOPY); if (pimlSrc->_hdcMask) { BitBlt(_hdcMask, rcDst.left, rcDst.top, cx, cy, pimlSrc->_hdcMask, rcSrc.left, rcSrc.top, SRCCOPY); } // // iff we are swapping we need to copy the saved image too // if (pimlTmp) { BitBlt(pimlSrc->_hdcImage, rcSrc.left, rcSrc.top, cx, cy, pimlTmp->_hdcImage, rcTmp.left, rcTmp.top, SRCCOPY); if (pimlSrc->_hdcMask) { BitBlt(pimlSrc->_hdcMask, rcSrc.left, rcSrc.top, cx, cy, pimlTmp->_hdcMask, rcTmp.left, rcTmp.top, SRCCOPY); } } hr = S_OK; } LEAVECRITICAL; return hr; } // IS_WHITE_PIXEL, BITS_ALL_WHITE are macros for looking at monochrome bits // to determine if certain pixels are white or black. Note that within a byte // the most significant bit represents the left most pixel. // #define IS_WHITE_PIXEL(pj,x,y,cScan) \ ((pj)[((y) * (cScan)) + ((x) >> 3)] & (1 << (7 - ((x) & 7)))) #define BITS_ALL_WHITE(b) (b == 0xff) // Set the image iImage as one of the special images for us in combine // drawing. to draw with these specify the index of this // in: // piml imagelist // iImage image index to use in speical drawing // iOverlay index of special image, values 1-4 HRESULT CImageList::_SetOverlayImage(int iImage, int iOverlay) { RECT rcImage; RECT rc; int x,y; int cxI,cyI; ULONG cScan; ULONG cBits; HBITMAP hbmMem; HRESULT hr = S_FALSE; iOverlay--; // make zero based if (_hdcMask == NULL || iImage < 0 || iImage >= _cImage || iOverlay < 0 || iOverlay >= NUM_OVERLAY_IMAGES) { return E_INVALIDARG; } if (_aOverlayIndexes[iOverlay] == (SHORT)iImage) return S_OK; _aOverlayIndexes[iOverlay] = (SHORT)iImage; // // find minimal rect that bounds the image // GetImageRect(iImage, &rcImage); SetRect(&rc, 0x7FFF, 0x7FFF, 0, 0); // // now compute the black box. This is much faster than GetPixel but // could still be improved by doing more operations looking at entire // bytes. We basicaly get the bits in monochrome form and then use // a private GetPixel. This decreased time on NT from 50 milliseconds to // 1 millisecond for a 32X32 image. // cxI = rcImage.right - rcImage.left; cyI = rcImage.bottom - rcImage.top; // compute the number of bytes in a scan. Note that they are WORD alligned cScan = (((cxI + (sizeof(SHORT)*8 - 1)) / 16) * 2); cBits = cScan * cyI; hbmMem = CreateBitmap(cxI,cyI,1,1,NULL); if (hbmMem) { HDC hdcMem = CreateCompatibleDC(_hdcMask); if (hdcMem) { PBYTE pBits = (PBYTE)LocalAlloc(LMEM_FIXED,cBits); PBYTE pScan; if (pBits) { SelectObject(hdcMem,hbmMem); // // map black pixels to 0, white to 1 // BitBlt(hdcMem, 0, 0, cxI, cyI, _hdcMask, rcImage.left, rcImage.top, SRCCOPY); // // fill in the bits // GetBitmapBits(hbmMem,cBits,pBits); // // for each scan, find the bounds // for (y = 0, pScan = pBits; y < cyI; ++y,pScan += cScan) { int i; // // first go byte by byte through white space // for (x = 0, i = 0; (i < (cxI >> 3)) && BITS_ALL_WHITE(pScan[i]); ++i) { x += 8; } // // now finish the scan bit by bit // for (; x < cxI; ++x) { if (!IS_WHITE_PIXEL(pBits, x,y,cScan)) { rc.left = min(rc.left, x); rc.right = max(rc.right, x+1); rc.top = min(rc.top, y); rc.bottom = max(rc.bottom, y+1); // now that we found one, quickly jump to the known right edge if ((x >= rc.left) && (x < rc.right)) { x = rc.right-1; } } } } if (rc.left == 0x7FFF) { rc.left = 0; ASSERT(0); } if (rc.top == 0x7FFF) { rc.top = 0; ASSERT(0); } _aOverlayDX[iOverlay] = (SHORT)(rc.right - rc.left); _aOverlayDY[iOverlay] = (SHORT)(rc.bottom- rc.top); _aOverlayX[iOverlay] = (SHORT)(rc.left); _aOverlayY[iOverlay] = (SHORT)(rc.top); _aOverlayF[iOverlay] = 0; // // see if the image is non-rectanglar // // if the overlay does not require a mask to be drawn set the // ILD_IMAGE flag, this causes ImageList_DrawEx to just // draw the image, ignoring the mask. // for (y=rc.top; y_SetOverlayImage(iImage, iOverlay); } return _SetOverlayImage(iImage, iOverlay); } /* ** BlendCT ** */ void BlendCT(DWORD *pdw, DWORD rgb, UINT n, UINT count) { UINT i; for (i=0; i_hbrBk; break; default: if (rgb == piml->_clrBk) hbr = piml->_hbrBk; else hbr = hbrFree = CreateSolidBrush(rgb); break; } hbrT = (HBRUSH)SelectObject(hdcDst, hbr); PatBlt(hdcDst, xDst, yDst, cx, cy, PATCOPY); SelectObject(hdcDst, hbrT); hbrT = (HBRUSH)SelectObject(hdcDst, hbrMask); BitBlt(hdcDst, xDst, yDst, cx, cy, piml->_hdcImage, x, y, ROP_MaskPat); SelectObject(hdcDst, hbrT); if (hbrFree) DeleteBrush(hbrFree); } /* ** ImageList_BlendCT ** ** copy the source to the dest blended with the given color. ** */ void ImageList_BlendCT(HDC hdcDst, int xDst, int yDst, CImageList* piml, int x, int y, int cx, int cy, COLORREF rgb, UINT fStyle) { BITMAP bm; GetObject(piml->_hbmImage, sizeof(bm), &bm); if (rgb == CLR_DEFAULT) rgb = GetSysColor(COLOR_HIGHLIGHT); ASSERT(rgb != CLR_NONE); // // get the DIB color table and blend it, only do this when the // blend color changes // if (piml->_clrBlend != rgb) { int n,cnt; piml->_clrBlend = rgb; GetObject(piml->_hbmImage, sizeof(piml->dib), &piml->dib.bm); cnt = GetDIBColorTable(piml->_hdcImage, 0, 256, (LPRGBQUAD)&piml->dib.ct); if ((fStyle & ILD_BLENDMASK) == ILD_BLEND50) n = 50; else n = 25; BlendCT(piml->dib.ct, rgb, n, cnt); } // // draw the image with a different color table // StretchDIBits(hdcDst, xDst, yDst, cx, cy, x, piml->dib.bi.biHeight-(y+cy), cx, cy, bm.bmBits, (LPBITMAPINFO)&piml->dib.bi, DIB_RGB_COLORS, SRCCOPY); } /* ** RGB555 macros */ #define RGB555(r,g,b) (((((r)>>3)&0x1F)<<10) | ((((g)>>3)&0x1F)<<5) | (((b)>>3)&0x1F)) #define R_555(w) (int)(((w) >> 7) & 0xF8) #define G_555(w) (int)(((w) >> 2) & 0xF8) #define B_555(w) (int)(((w) << 3) & 0xF8) /* ** DIBXY16() macro - compute a pointer to a pixel given a (x,y) */ #define DIBXY16(bm,x,y) \ (WORD*)((BYTE*)bm.bmBits + (bm.bmHeight-1-(y))*bm.bmWidthBytes + (x)*2) /* ** Blend16 ** ** dest.r = source.r * (1-a) + (rgb.r * a) */ void Blend16( WORD* dst, // destination RGB 555 bits int dst_pitch, // width in bytes of a dest scanline WORD* src, // source RGB 555 bits int src_pitch, // width in bytes of a source scanline int cx, // width in pixels int cy, // height in pixels DWORD rgb, // color to blend int a) // alpha value { int i,x,y,r,g,b,sr,sg,sb; // subtract off width from pitch dst_pitch = dst_pitch - cx*2; src_pitch = src_pitch - cx*2; if (rgb == CLR_NONE) { // blending with the destination, we ignore the alpha and always // do 50% (this is what the old dither mask code did) for (y=0; y> 1) + ((*src++ & 0x7BDE) >> 1); } dst = (WORD *)((BYTE *)dst + dst_pitch); src = (WORD *)((BYTE *)src + src_pitch); } } else { // blending with a solid color // pre multiply source (constant) rgb by alpha sr = GetRValue(rgb) * a; sg = GetGValue(rgb) * a; sb = GetBValue(rgb) * a; // compute inverse alpha for inner loop a = 256 - a; // special case a 50% blend, to avoid a multiply if (a == 128) { sr = RGB555(sr>>8,sg>>8,sb>>8); for (y=0; y> 1); *dst++ = (WORD) i; } dst = (WORD *)((BYTE *)dst + dst_pitch); src = (WORD *)((BYTE *)src + src_pitch); } } else { for (y=0; y> 8; g = (G_555(i) * a + sg) >> 8; b = (B_555(i) * a + sb) >> 8; *dst++ = RGB555(r,g,b); } dst = (WORD *)((BYTE *)dst + dst_pitch); src = (WORD *)((BYTE *)src + src_pitch); } } } } /* ** ImageList_Blend16 ** ** copy the source to the dest blended with the given color. ** ** source is assumed to be a 16 bit (RGB 555) bottom-up DIBSection ** (this is the only kind of DIBSection we create) */ void ImageList_Blend16(HDC hdcDst, int xDst, int yDst, CImageList* piml, int x, int y, int cx, int cy, COLORREF rgb, UINT fStyle) { BITMAP bm; RECT rc; int a; // get bitmap info for source bitmap GetObject(piml->_hbmImage, sizeof(bm), &bm); ASSERT(bm.bmBitsPixel==16); // get blend RGB if (rgb == CLR_DEFAULT) rgb = GetSysColor(COLOR_HIGHLIGHT); // get blend factor as a fraction of 256 // only 50% or 25% is currently used. if ((fStyle & ILD_BLENDMASK) == ILD_BLEND50) a = 128; else a = 64; // blend the image with the specified color and place at end of image list piml->GetSpareImageRect(&rc); // if blending with the destination, copy the dest to our work buffer if (rgb == CLR_NONE) BitBlt(piml->_hdcImage, rc.left, rc.top, cx, cy, hdcDst, xDst, yDst, SRCCOPY); // sometimes the user can change the icon size (via plustab) between 32x32 and 48x48, // thus the values we have might be bigger than the actual bitmap. To prevent us from // crashing in Blend16 when this happens we do some bounds checks here if (rc.left + cx <= bm.bmWidth && rc.top + cy <= bm.bmHeight && x + cx <= bm.bmWidth && y + cy <= bm.bmHeight) { Blend16(DIBXY16(bm,rc.left,rc.top), -(int)bm.bmWidthBytes, DIBXY16(bm,x,y), -(int)bm.bmWidthBytes, cx, cy, rgb, a); } // blt blended image to the dest DC BitBlt(hdcDst, xDst, yDst, cx, cy, piml->_hdcImage, rc.left, rc.top, SRCCOPY); } /* ** ImageList_Blend ** ** copy the source to the dest blended with the given color. ** top level function to decide what blend function to call */ void ImageList_Blend(HDC hdcDst, int xDst, int yDst, CImageList* piml, int x, int y, int cx, int cy, COLORREF rgb, UINT fStyle) { BITMAP bm; int bpp = GetDeviceCaps(hdcDst, BITSPIXEL); GetObject(piml->_hbmImage, sizeof(bm), &bm); // // if _hbmImage is a DIBSection and we are on a HiColor device // the do a "real" blend // if (bm.bmBits && bm.bmBitsPixel <= 8 && (bpp > 8 || bm.bmBitsPixel==8)) { // blend from a 4bit or 8bit DIB ImageList_BlendCT(hdcDst, xDst, yDst, piml, x, y, cx, cy, rgb, fStyle); } else if (bm.bmBits && bm.bmBitsPixel == 16 && bpp > 8) { // blend from a 16bit 555 DIB ImageList_Blend16(hdcDst, xDst, yDst, piml, x, y, cx, cy, rgb, fStyle); } else { // simulate a blend with a dither pattern. ImageList_BlendDither(hdcDst, xDst, yDst, piml, x, y, cx, cy, rgb, fStyle); } } BOOL BlurBitmap(ULONG* plBitmapBits, SIZE size, COLORREF crFill) { USHORT aus0[64]; USHORT aus1[64]; USHORT aus2[64]; USHORT aus3[64]; USHORT aus4[64]; PUSHORT apus[5]; PULONG pulIn = (PULONG) plBitmapBits; PULONG pulTmp; USHORT *pus, *pusEnd; ULONG j; PULONG pulOut = (PULONG) (plBitmapBits + 2 * size.cx) + 2; ULONG ulNumScans = size.cy - 4; ULONG ulNext = 0; if (size.cx > 64) { apus[0] = (PUSHORT) LocalAlloc(LPTR, size.cx * sizeof(USHORT) * 5); if (apus[0]) { apus[1] = apus[0] + size.cx; apus[2] = apus[1] + size.cx; apus[3] = apus[2] + size.cx; apus[4] = apus[3] + size.cx; } } else { apus[0] = aus0; apus[1] = aus1; apus[2] = aus2; apus[3] = aus3; apus[4] = aus4; } if (apus[0] == NULL) { return FALSE; } // Fill up the scanline memory with 3x1 boxcar sums for the // first three scanlines. for (j = 0; j < 5; j++) { // Compute the scanline sum. Note that output is two pixels // smaller than the input. pus = apus[j]; pusEnd = pus + (size.cx - 4); pulTmp = pulIn; while (pus < pusEnd) { *pus = (USHORT) ((pulTmp[0] >> 24) + (pulTmp[1] >> 24) + (pulTmp[2] >> 24) + (pulTmp[3] >> 24) + (pulTmp[4] >> 24)); pus += 1; pulTmp += 1; } // Next scanline. pulIn = (PULONG)(pulIn + size.cx); } // Compute the average (3x3 boxcar convolution) for each output // scanline. while (ulNumScans--) { // Setup output pointers. PULONG pulAvg = pulOut; PULONG pulAvgEnd = pulAvg + (size.cx - 4); // Setup pointers to run the scanline 3x1 sums. PUSHORT pusTmp[5]; pusTmp[0] = apus[0]; pusTmp[1] = apus[1]; pusTmp[2] = apus[2]; pusTmp[3] = apus[4]; pusTmp[4] = apus[3]; // Compute the average scanline. while (pulAvg < pulAvgEnd) { USHORT usSum; BYTE alpha; // Unroll this... // Strictly speaking we should divide the sum by 9, but since // this is just for looks, we can approximate as a divide by 8 // minus a divide by 64 (will produce in a slightly too small // result). // // 1/9 = 0.111111111... in decimal // = 0.000111000111... in binary // 1/25 // // Approximations: // // 1/8 - 1/64 = 0.109375 // 1/8 - 1/64 + 1/512 = 0.111328125 // 1/8 - 1/64 + 1/512 - 1/4096 = 0.111083984 usSum = *pusTmp[0] + *pusTmp[1] + *pusTmp[2] + *pusTmp[3] + *pusTmp[4]; //*pulAvg = (usSum / 9) << 24; //*pulAvg = ((usSum >> 3) - (usSum >> 6)) << 24; alpha = usSum/25; //(usSum >> 5) - (usSum >> 4); ((RGBQUAD*)pulAvg)->rgbReserved = (BYTE)alpha; ((RGBQUAD*)pulAvg)->rgbRed = ((GetRValue(crFill) * alpha) + 128) / 255; ((RGBQUAD*)pulAvg)->rgbGreen = ((GetGValue(crFill) * alpha) + 128) / 255; ((RGBQUAD*)pulAvg)->rgbBlue = ((GetBValue(crFill) * alpha) + 128) / 255; pulAvg += 1; pusTmp[0] += 1; pusTmp[1] += 1; pusTmp[2] += 1; pusTmp[3] += 1; pusTmp[4] += 1; } // Next output scanline. pulOut = (PULONG) (pulOut + size.cx); // Need to compute 3x1 boxcar sum for the next scanline. if (ulNumScans) { // Compute the scanline sum. Note that output is two pixels // smaller than the input. pus = apus[ulNext]; pusEnd = pus + (size.cx - 4); pulTmp = pulIn; while (pus < pusEnd) { *pus = (USHORT) ((pulTmp[0] >> 24) + (pulTmp[1] >> 24) + (pulTmp[2] >> 24) + (pulTmp[3] >> 24) + (pulTmp[4] >> 24)); pus += 1; pulTmp += 1; } // Next scanline. pulIn = (PULONG)(pulIn + size.cx); // Next scanline summation buffer. ulNext++; if (ulNext >= 5) ulNext = 0; } } // Cleanup temporary memory. if (apus[0] != aus0) { LocalFree(apus[0]); } return TRUE; } /* ** Draw the image, either selected, transparent, or just a blt ** ** For the selected case, a new highlighted image is generated ** and used for the final output. ** ** piml ImageList to get image from. ** i the image to get. ** hdc DC to draw image to ** x,y where to draw image (upper left corner) ** cx,cy size of image to draw (0,0 means normal size) ** ** rgbBk background color ** CLR_NONE - draw tansparent ** CLR_DEFAULT - use bk color of the image list ** ** rgbFg foreground (blend) color (only used if ILD_BLENDMASK set) ** CLR_NONE - blend with destination (transparent) ** CLR_DEFAULT - use windows hilight color ** ** if blend ** if blend with color ** copy image, and blend it with color. ** else if blend with dst ** copy image, copy mask, blend mask 50% ## ** if ILD_TRANSPARENT ** draw transparent (two blts) special case black or white background ** unless we copied the mask or image ** else if (rgbBk == piml->rgbBk && _fSolidBk) ** just blt it ** else if mask ** copy image ** replace bk color ** blt it. ** else ** just blt it */ extern "C" void SaturateDC(void* pvBitmapBits, int Amount, RECT* prcColumn, RECT* prcImage); HRESULT CImageList::Draw(IMAGELISTDRAWPARAMS* pimldp) { RECT rcImage; RECT rc; HBRUSH hbrT; BOOL fImage; HDC hdcMaskI; HDC hdcImageI; int xMask, yMask; int xImage, yImage; IMAGELISTDRAWPARAMS imldp = {0}; if (pimldp->cbSize != sizeof(IMAGELISTDRAWPARAMS)) { if (pimldp->cbSize == IMAGELISTDRAWPARAMS_V3_SIZE) { memcpy(&imldp, pimldp, IMAGELISTDRAWPARAMS_V3_SIZE); imldp.cbSize = sizeof(IMAGELISTDRAWPARAMS); pimldp = &imldp; } else return E_INVALIDARG; } if (!IsImageListIndex(pimldp->i)) return E_INVALIDARG; // // If we need to use the mirrored imagelist, then let's set it. // if (_pimlMirror && (IS_DC_RTL_MIRRORED(pimldp->hdcDst))) { return _pimlMirror->Draw(pimldp); } ENTERCRITICAL; GetImageRect(pimldp->i, &rcImage); rcImage.left += pimldp->xBitmap; rcImage.top += pimldp->yBitmap; if (pimldp->rgbBk == CLR_DEFAULT) pimldp->rgbBk = _clrBk; if (pimldp->rgbBk == CLR_NONE) pimldp->fStyle |= ILD_TRANSPARENT; if (pimldp->cx == 0) pimldp->cx = rcImage.right - rcImage.left; if (pimldp->cy == 0) pimldp->cy = rcImage.bottom - rcImage.top; again: hdcMaskI = _hdcMask; xMask = rcImage.left; yMask = rcImage.top; hdcImageI = _hdcImage; xImage = rcImage.left; yImage = rcImage.top; if (pimldp->fStyle & ILD_BLENDMASK) { // make a copy of the image, because we will have to modify it hdcImageI = ImageList_GetWorkDC(pimldp->hdcDst, pimldp->cx, pimldp->cy); xImage = 0; yImage = 0; // // blend with the destination // by "oring" the mask with a 50% dither mask // if (pimldp->rgbFg == CLR_NONE && hdcMaskI) { if ((_flags & ILC_COLORMASK) == ILC_COLOR16 && !(pimldp->fStyle & ILD_MASK)) { // copy dest to our work buffer BitBlt(hdcImageI, 0, 0, pimldp->cx, pimldp->cy, pimldp->hdcDst, pimldp->x, pimldp->y, SRCCOPY); // blend source into our work buffer ImageList_Blend16(hdcImageI, 0, 0, this, rcImage.left, rcImage.top, pimldp->cx, pimldp->cy, pimldp->rgbFg, pimldp->fStyle); } else { GetSpareImageRect(&rc); xMask = rc.left; yMask = rc.top; // copy the source image BitBlt(hdcImageI, 0, 0, pimldp->cx, pimldp->cy, _hdcImage, rcImage.left, rcImage.top, SRCCOPY); // make a dithered copy of the mask hbrT = (HBRUSH)SelectObject(hdcMaskI, g_hbrMonoDither); BitBlt(hdcMaskI, rc.left, rc.top, pimldp->cx, pimldp->cy, _hdcMask, rcImage.left, rcImage.top, ROP_PSo); SelectObject(hdcMaskI, hbrT); } pimldp->fStyle |= ILD_TRANSPARENT; } else { // blend source into our work buffer ImageList_Blend(hdcImageI, 0, 0, this, rcImage.left, rcImage.top, pimldp->cx, pimldp->cy, pimldp->rgbFg, pimldp->fStyle); } } // is the source image from the image list (not hdcWork) fImage = hdcImageI == _hdcImage; if ((pimldp->fStyle & ILD_MASK) && hdcMaskI) { // // ILD_MASK means draw the mask only // DWORD dwRop; ASSERT(GetTextColor(pimldp->hdcDst) == CLR_BLACK); ASSERT(::GetBkColor(pimldp->hdcDst) == CLR_WHITE); if (pimldp->fStyle & ILD_ROP) dwRop = pimldp->dwRop; else if (pimldp->fStyle & ILD_TRANSPARENT) dwRop = SRCAND; else dwRop = SRCCOPY; BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcMaskI, xMask, yMask, dwRop); } else if (pimldp->fStyle & ILD_IMAGE) { COLORREF clrBk = ::GetBkColor(hdcImageI); DWORD dwRop; if (pimldp->rgbBk != CLR_DEFAULT) { ::SetBkColor(hdcImageI, pimldp->rgbBk); } if (pimldp->fStyle & ILD_ROP) dwRop = pimldp->dwRop; else dwRop = SRCCOPY; BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcImageI, xImage, yImage, dwRop); ::SetBkColor(hdcImageI, clrBk); } else if ((pimldp->fStyle & ILD_TRANSPARENT) && hdcMaskI) { // // if there is a mask and the drawing is to be transparent, // use the mask for the drawing. // // // on NT dont mess around, just call MaskBlt // #if defined(USE_MASKBLT) && !defined(MAINWIN) MaskBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcImageI, xImage, yImage, _hbmMask, xMask, yMask, 0xCCAA0000); #else COLORREF clrTextSave; COLORREF clrBkSave; // // we have some special cases: // // if the background color is black, we just do a AND then OR // if the background color is white, we just do a OR then AND // otherwise change source, then AND then OR // clrTextSave = SetTextColor(pimldp->hdcDst, CLR_BLACK); clrBkSave = ::SetBkColor(pimldp->hdcDst, CLR_WHITE); // we cant do white/black special cases if we munged the mask or image if (fImage && _clrBk == CLR_WHITE) { BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcMaskI, xMask, yMask, ROP_DSno); BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcImageI, xImage, yImage, ROP_DSa); } else if (fImage && (_clrBk == CLR_BLACK || _clrBk == CLR_NONE)) { BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcMaskI, xMask, yMask, ROP_DSa); BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcImageI, xImage, yImage, ROP_DSo); } else { ASSERT(GetTextColor(hdcImageI) == CLR_BLACK); ASSERT(::GetBkColor(hdcImageI) == CLR_WHITE); // black out the source image. BitBlt(hdcImageI, xImage, yImage, pimldp->cx, pimldp->cy, hdcMaskI, xMask, yMask, ROP_DSna); BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcMaskI, xMask, yMask, ROP_DSa); BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcImageI, xImage, yImage, ROP_DSo); // restore the bkcolor, if it came from the image list if (fImage) _ResetBkColor(pimldp->i, pimldp->i, _clrBk); } SetTextColor(pimldp->hdcDst, clrTextSave); ::SetBkColor(pimldp->hdcDst, clrBkSave); #endif } else if (fImage && pimldp->rgbBk == _clrBk && _fSolidBk) { BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcImageI, xImage, yImage, SRCCOPY); } else if (hdcMaskI) { if (fImage && ((pimldp->rgbBk == _clrBk && !_fSolidBk) || GetNearestColor32(hdcImageI, pimldp->rgbBk) != pimldp->rgbBk)) { // make a copy of the image, because we will have to modify it hdcImageI = ImageList_GetWorkDC(pimldp->hdcDst, pimldp->cx, pimldp->cy); xImage = 0; yImage = 0; fImage = FALSE; BitBlt(hdcImageI, 0, 0, pimldp->cx, pimldp->cy, _hdcImage, rcImage.left, rcImage.top, SRCCOPY); } SetBrushOrgEx(hdcImageI, xImage-pimldp->x, yImage-pimldp->y, NULL); hbrT = SelectBrush(hdcImageI, CreateSolidBrush(pimldp->rgbBk)); BitBlt(hdcImageI, xImage, yImage, pimldp->cx, pimldp->cy, hdcMaskI, xMask, yMask, ROP_PatMask); DeleteObject(SelectBrush(hdcImageI, hbrT)); SetBrushOrgEx(hdcImageI, 0, 0, NULL); BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcImageI, xImage, yImage, SRCCOPY); if (fImage) _ResetBkColor(pimldp->i, pimldp->i, _clrBk); } else { BitBlt(pimldp->hdcDst, pimldp->x, pimldp->y, pimldp->cx, pimldp->cy, hdcImageI, xImage, yImage, SRCCOPY); } // // now deal with a overlay image, use the minimal bounding rect (and flags) // we computed in ImageList_SetOverlayImage() // if (pimldp->fStyle & ILD_OVERLAYMASK) { int n = OVERLAYMASKTOINDEX(pimldp->fStyle); if (n < NUM_OVERLAY_IMAGES) { pimldp->i = _aOverlayIndexes[n]; GetImageRect(pimldp->i, &rcImage); pimldp->cx = _aOverlayDX[n]; pimldp->cy = _aOverlayDY[n]; pimldp->x += _aOverlayX[n]; pimldp->y += _aOverlayY[n]; rcImage.left += _aOverlayX[n]+pimldp->xBitmap; rcImage.top += _aOverlayY[n]+pimldp->yBitmap; pimldp->fStyle &= ILD_MASK; pimldp->fStyle |= ILD_TRANSPARENT; pimldp->fStyle |= _aOverlayF[n]; if (pimldp->cx > 0 && pimldp->cy > 0) goto again; // ImageList_DrawEx(piml, i, hdcDst, x, y, 0, 0, CLR_DEFAULT, CLR_NONE, fStyle); } } if (!fImage) { ImageList_ReleaseWorkDC(hdcImageI); } LEAVECRITICAL; return S_OK; } HRESULT CImageList::GetImageInfo(int i, IMAGEINFO * pImageInfo) { RIPMSG(pImageInfo != NULL, "ImageList_GetImageInfo: Invalid NULL pointer"); RIPMSG(IsImageListIndex(i), "ImageList_GetImageInfo: Invalid image index %d", i); if (!pImageInfo || !IsImageListIndex(i)) return E_POINTER; pImageInfo->hbmImage = _hbmImage; pImageInfo->hbmMask = _hbmMask; return GetImageRect(i, &pImageInfo->rcImage); } // // Parameter: // i -- -1 to add // HRESULT CImageList::_ReplaceIcon(int i, HICON hIcon, int* pi) { HICON hIconT = hIcon; RECT rc; HRESULT hr = S_OK; *pi = -1; // be win95 compatible if (i < -1) return E_INVALIDARG; // // re-size the icon (iff needed) by calling CopyImage // hIcon = (HICON)CopyImage(hIconT, IMAGE_ICON, _cx, _cy,LR_COPYFROMRESOURCE | LR_COPYRETURNORG); if (hIcon == NULL) return E_OUTOFMEMORY; // // alocate a slot for the icon // if (i == -1) hr = _Add(NULL,NULL,1,0,0,&i); if (i == -1) return hr; // // now draw it into the image bitmaps // hr = GetImageRect(i, &rc); if (FAILED(hr)) return hr; FillRect(_hdcImage, &rc, _hbrBk); DrawIconEx(_hdcImage, rc.left, rc.top, hIcon, 0, 0, 0, NULL, DI_NORMAL); if (_hdcMask) DrawIconEx(_hdcMask, rc.left, rc.top, hIcon, 0, 0, 0, NULL, DI_MASK); // // if we had user size a new icon, delete it. // if (hIcon != hIconT) DestroyIcon(hIcon); *pi = i; return S_OK; } HRESULT CImageList::ReplaceIcon(int i, HICON hIcon, int* pi) { // Let's add it first to the mirrored image list, if one exists if (_pimlMirror) { HICON hIconT = CopyIcon(hIcon); if (hIconT) { MirrorIcon(&hIconT, NULL); _pimlMirror->_ReplaceIcon(i, hIconT, pi); DestroyIcon(hIconT); } } return _ReplaceIcon(i, hIcon,pi); } // make a dithered copy of the source image in the destination image. // allows placing of the final image in the destination. HRESULT CImageList::CopyDitherImage(WORD iDst, int xDst, int yDst, IUnknown* punkSrc, int iSrc, UINT fStyle) { IImageList* pux; HRESULT hr = punkSrc->QueryInterface(IID_PPV_ARG(IImageList, &pux)); if (FAILED(hr)) return hr; RECT rc; int x, y; GetImageRect(iDst, &rc); // coordinates in destination image list x = xDst + rc.left; y = yDst + rc.top; fStyle &= ILD_OVERLAYMASK; WimpyDrawEx(pux, iSrc, _hdcImage, x, y, 0, 0, CLR_DEFAULT, CLR_NONE, ILD_IMAGE | fStyle); // // dont dither the mask on a hicolor device, we will draw the image // with blending while dragging. // if (_hdcMask && GetScreenDepth() > 8) { WimpyDrawEx(pux, iSrc, _hdcMask, x, y, 0, 0, CLR_NONE, CLR_NONE, ILD_MASK | fStyle); } else if (_hdcMask) { WimpyDrawEx(pux, iSrc, _hdcMask, x, y, 0, 0, CLR_NONE, CLR_NONE, ILD_BLEND50|ILD_MASK | fStyle); } _ResetBkColor(iDst, iDst+1, _clrBk); pux->Release(); return hr; } // // ImageList_CopyBitmap // // Worker function for ImageList_Duplicate. // // Given a bitmap and an hdc, creates and returns a copy of the passed in bitmap. // HBITMAP CImageList::_CopyBitmap(HBITMAP hbm, HDC hdc) { ASSERT(hbm); BITMAP bm; HBITMAP hbmCopy = NULL; if (GetObject(hbm, sizeof(bm), &bm) == sizeof(bm)) { ENTERCRITICAL; if (hbmCopy = CreateCompatibleBitmap(hdc, bm.bmWidth, bm.bmHeight)) { CImageList::SelectDstBitmap(hbmCopy); BitBlt(g_hdcDst, 0, 0, bm.bmWidth, bm.bmHeight, hdc, 0, 0, SRCCOPY); CImageList::SelectDstBitmap(NULL); } LEAVECRITICAL; } return hbmCopy; } HRESULT CImageList::Clone(REFIID riid, void** ppv) { HBITMAP hbmImageI; HBITMAP hbmMaskI = NULL; HRESULT hr = S_OK; CImageList* pimlCopy = NULL; *ppv = NULL; ENTERCRITICAL; hbmImageI = _CopyBitmap(_hbmImage, _hdcImage); if (!hbmImageI) hr = E_OUTOFMEMORY; if (SUCCEEDED(hr)) { if (_hdcMask) { hbmMaskI = _CopyBitmap(_hbmMask, _hdcMask); if (!hbmMaskI) hr = E_OUTOFMEMORY; } if (SUCCEEDED(hr)) { pimlCopy = CImageList::Create(_cx, _cy, _flags, 0, _cGrow); if (pimlCopy) { // Slam in our bitmap copies and delete the old ones SelectObject(pimlCopy->_hdcImage, hbmImageI); CImageList::_DeleteBitmap(pimlCopy->_hbmImage); if (pimlCopy->_hdcMask) { SelectObject(pimlCopy->_hdcMask, hbmMaskI); CImageList::_DeleteBitmap(pimlCopy->_hbmMask); } pimlCopy->_hbmImage = hbmImageI; pimlCopy->_hbmMask = hbmMaskI; // Make sure other info is correct pimlCopy->_cImage = _cImage; pimlCopy->_cAlloc = _cAlloc; pimlCopy->_cStrip = _cStrip; pimlCopy->_clrBlend = _clrBlend; pimlCopy->_clrBk = _clrBk; // Delete the old brush and create the correct one if (pimlCopy->_hbrBk) DeleteObject(pimlCopy->_hbrBk); if (pimlCopy->_clrBk == CLR_NONE) { pimlCopy->_hbrBk = (HBRUSH)GetStockObject(BLACK_BRUSH); pimlCopy->_fSolidBk = TRUE; } else { pimlCopy->_hbrBk = CreateSolidBrush(pimlCopy->_clrBk); pimlCopy->_fSolidBk = GetNearestColor32(pimlCopy->_hdcImage, pimlCopy->_clrBk) == pimlCopy->_clrBk; } } } LEAVECRITICAL; } if (FAILED(hr)) { if (hbmImageI) CImageList::_DeleteBitmap(hbmImageI); if (hbmMaskI) CImageList::_DeleteBitmap(hbmMaskI); } if (pimlCopy) { hr = pimlCopy->QueryInterface(riid, ppv); pimlCopy->Release(); } return hr; } void CImageList::_Merge(IImageList* pux, int i, int dx, int dy) { if (_hdcMask) { IImageListPriv* puxp; if (SUCCEEDED(pux->QueryInterface(IID_PPV_ARG(IImageListPriv, &puxp)))) { HDC hdcMaskI; if (SUCCEEDED(puxp->GetPrivateGoo(NULL, NULL, NULL, &hdcMaskI)) && hdcMaskI) { RECT rcMerge; int cxI, cyI; pux->GetIconSize(&cxI, &cyI); pux->GetImageRect(i, &rcMerge); BitBlt(_hdcMask, dx, dy, cxI, cyI, hdcMaskI, rcMerge.left, rcMerge.top, SRCAND); } puxp->Release(); } } WimpyDraw(pux, i, _hdcImage, dx, dy, ILD_TRANSPARENT); } HRESULT CImageList::_Merge(int i1, IUnknown* punk, int i2, int dx, int dy, CImageList** ppiml) { CImageList* pimlNew = NULL; IImageListPriv* puxp; HRESULT hr = punk->QueryInterface(IID_PPV_ARG(IImageListPriv, &puxp)); if (SUCCEEDED(hr)) { IImageList* pux; hr = punk->QueryInterface(IID_PPV_ARG(IImageList, &pux)); if (SUCCEEDED(hr)) { RECT rcNew; RECT rc1; RECT rc2; int cxI, cyI; int c1, c2; UINT wFlags; UINT uSrcFlags; puxp->GetFlags(&uSrcFlags); pux->GetIconSize(&cxI, &cyI); ENTERCRITICAL; SetRect(&rc1, 0, 0, _cx, _cy); SetRect(&rc2, dx, dy, cxI + dx, cyI + dy); UnionRect(&rcNew, &rc1, &rc2); cxI = RECTWIDTH(rcNew); cyI = RECTHEIGHT(rcNew); // // If one of images are shared, create a shared image. // wFlags = (_flags | uSrcFlags) & ~ILC_COLORMASK; c1 = (_flags & ILC_COLORMASK); c2 = (uSrcFlags & ILC_COLORMASK); if (c1 == 16 && c2 == ILC_COLORDDB) { c2 = 16; } wFlags |= max(c1,c2); pimlNew = CImageList::Create(cxI, cyI, ILC_MASK|wFlags, 1, 0); if (pimlNew) { pimlNew->_cImage++; if (pimlNew->_hdcMask) PatBlt(pimlNew->_hdcMask, 0, 0, cxI, cyI, WHITENESS); PatBlt(pimlNew->_hdcImage, 0, 0, cxI, cyI, BLACKNESS); pimlNew->_Merge(SAFECAST(this, IImageList*), i1, rc1.left - rcNew.left, rc1.top - rcNew.top); pimlNew->_Merge(pux, i2, rc2.left - rcNew.left, rc2.top - rcNew.top); } else hr = E_OUTOFMEMORY; LEAVECRITICAL; pux->Release(); } puxp->Release(); } *ppiml = pimlNew; return hr; } HRESULT CImageList::Merge(int i1, IUnknown* punk, int i2, int dx, int dy, REFIID riid, void** ppv) { CImageList* piml; HRESULT hr = _Merge(i1, punk, i2, dx, dy, &piml); if (piml) { hr = piml->QueryInterface(riid, ppv); piml->Release(); } return hr; } HRESULT CImageList::_Read(ILFILEHEADER *pilfh, HBITMAP hbmImageI, HBITMAP hbmMaskI) { int i; HRESULT hr = Initialize(pilfh->cx, pilfh->cy, pilfh->flags, 1, pilfh->cGrow); if (SUCCEEDED(hr)) { // select into DC's before deleting existing bitmaps // patch in the bitmaps we loaded SelectObject(_hdcImage, hbmImageI); DeleteObject(_hbmImage); _hbmImage = hbmImageI; _clrBlend = CLR_NONE; // Same for the mask (if necessary) if (_hdcMask) { SelectObject(_hdcMask, hbmMaskI); DeleteObject(_hbmMask); _hbmMask = hbmMaskI; } _cAlloc = pilfh->cAlloc; // // Call ImageList_SetBkColor with 0 in piml->_cImage to avoid // calling expensive ImageList__ResetBkColor // _cImage = 0; _SetBkColor(pilfh->clrBk); _cImage = pilfh->cImage; for (i=0; iaOverlayIndexes[i], i+1); } else { DeleteObject(hbmImageI); DeleteObject(hbmMaskI); } return hr; } STDMETHODIMP CImageList::Load(IStream *pstm) { if (pstm == NULL) return E_INVALIDARG; HRESULT hr = ImageList_InitGlobals(); if (SUCCEEDED(hr)) { ENTERCRITICAL; ILFILEHEADER ilfh = {0}; HBITMAP hbmImageI; HBITMAP hbmMaskI; HBITMAP hbmMirroredImage; HBITMAP hbmMirroredMask; BOOL bMirroredIL = FALSE; // fist read in the old struct hr = pstm->Read(&ilfh, ILFILEHEADER_SIZE0, NULL); if (SUCCEEDED(hr) && (ilfh.magic != IMAGELIST_MAGIC || ilfh.version != IMAGELIST_VER0)) { hr = E_FAIL; } if (SUCCEEDED(hr)) { hbmMaskI = NULL; hbmMirroredMask = NULL; hr = Stream_ReadBitmap(pstm, (ilfh.flags&ILC_COLORMASK), &hbmImageI); if (SUCCEEDED(hr)) { if (ilfh.flags & ILC_MASK) { hr = Stream_ReadBitmap(pstm, FALSE, &hbmMaskI); if (FAILED(hr)) { DeleteBitmap(hbmImageI); } } if (SUCCEEDED(hr)) { // Read in the rest of the struct, new overlay stuff. if (ilfh.flags & ILC_MOREOVERLAY) { hr = pstm->Read((LPBYTE)&ilfh + ILFILEHEADER_SIZE0, sizeof(ilfh) - ILFILEHEADER_SIZE0, NULL); if (SUCCEEDED(hr)) ilfh.flags &= ~ILC_MOREOVERLAY; } } if (SUCCEEDED(hr)) { if (ilfh.flags & ILC_MIRROR) { ilfh.flags &= ~ILC_MIRROR; bMirroredIL = TRUE; hr = Stream_ReadBitmap(pstm, (ilfh.flags&ILC_COLORMASK), &hbmMirroredImage); if (SUCCEEDED(hr) && ilfh.flags & ILC_MASK) { hr = Stream_ReadBitmap(pstm, FALSE, &hbmMirroredMask); if (FAILED(hr)) { DeleteBitmap(hbmMirroredImage); } } } if (SUCCEEDED(hr)) { hr = _Read(&ilfh, hbmImageI, hbmMaskI); if(SUCCEEDED(hr) && bMirroredIL) { _pimlMirror = new CImageList(); if (_pimlMirror) { _pimlMirror->_Read(&ilfh, hbmMirroredImage, hbmMirroredMask); } else { hr = E_OUTOFMEMORY; // if we failed to read mirrored imagelist, let's force fail. DeleteBitmap(hbmImageI); if (hbmMaskI) DeleteBitmap(hbmMaskI); } } } } } } LEAVECRITICAL; } return hr; } BOOL CImageList::_MoreOverlaysUsed() { int i; for (i = NUM_OVERLAY_IMAGES_0; i < NUM_OVERLAY_IMAGES; i++) if (_aOverlayIndexes[i] != -1) return TRUE; return FALSE; } STDMETHODIMP CImageList::Save(IStream *pstm, int fClearDirty) { int i; ILFILEHEADER ilfh; HRESULT hr = S_OK; if (pstm == NULL) return E_INVALIDARG; ilfh.magic = IMAGELIST_MAGIC; ilfh.version = IMAGELIST_VER0; ilfh.cImage = (SHORT) _cImage; ilfh.cAlloc = (SHORT) _cAlloc; ilfh.cGrow = (SHORT) _cGrow; ilfh.cx = (SHORT) _cx; ilfh.cy = (SHORT) _cy; ilfh.clrBk = _clrBk; ilfh.flags = (SHORT) _flags; // // Store mirror flags // if (_pimlMirror) ilfh.flags |= ILC_MIRROR; if (_MoreOverlaysUsed()) ilfh.flags |= ILC_MOREOVERLAY; for (i=0; i < NUM_OVERLAY_IMAGES; i++) ilfh.aOverlayIndexes[i] = (SHORT) _aOverlayIndexes[i]; hr = pstm->Write(&ilfh, ILFILEHEADER_SIZE0, NULL); hr = Stream_WriteBitmap(pstm, _hbmImage, 0); if (SUCCEEDED(hr)) { if (_hdcMask) { hr = Stream_WriteBitmap(pstm, _hbmMask, 1); } if (SUCCEEDED(hr)) { if (ilfh.flags & ILC_MOREOVERLAY) hr = pstm->Write((LPBYTE)&ilfh + ILFILEHEADER_SIZE0, sizeof(ilfh) - ILFILEHEADER_SIZE0, NULL); if (_pimlMirror) { // Don't call pidlMirror's Save, because of the header difference. hr = Stream_WriteBitmap(pstm, _pimlMirror->_hbmImage, 0); if (_pimlMirror->_hdcMask) { hr = Stream_WriteBitmap(pstm, _pimlMirror->_hbmMask, 1); } } } } return hr; } HRESULT Stream_WriteBitmap(LPSTREAM pstm, HBITMAP hbm, int cBitsPerPixel) { BOOL fSuccess; BITMAP bm; int cx, cy; BITMAPFILEHEADER bf; BITMAPINFOHEADER bi; BITMAPINFOHEADER * pbi; BYTE * pbuf; HDC hdc; UINT cbColorTable; int cLines; int cLinesWritten; HRESULT hr = E_INVALIDARG; ASSERT(pstm); fSuccess = FALSE; hdc = NULL; pbi = NULL; pbuf = NULL; if (GetObject(hbm, sizeof(bm), &bm) != sizeof(bm)) goto Error; hdc = GetDC(HWND_DESKTOP); cx = bm.bmWidth; cy = bm.bmHeight; if (cBitsPerPixel == 0) cBitsPerPixel = bm.bmPlanes * bm.bmBitsPixel; if (cBitsPerPixel <= 8) cbColorTable = (1 << cBitsPerPixel) * sizeof(RGBQUAD); else cbColorTable = 0; bi.biSize = sizeof(bi); bi.biWidth = cx; bi.biHeight = cy; bi.biPlanes = 1; bi.biBitCount = (WORD) cBitsPerPixel; bi.biCompression = BI_RGB; // RLE not supported! bi.biSizeImage = 0; bi.biXPelsPerMeter = 0; bi.biYPelsPerMeter = 0; bi.biClrUsed = 0; bi.biClrImportant = 0; bf.bfType = BFTYPE_BITMAP; bf.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + cbColorTable; bf.bfSize = bf.bfOffBits + bi.biSizeImage; bf.bfReserved1 = 0; bf.bfReserved2 = 0; hr = E_OUTOFMEMORY; pbi = (BITMAPINFOHEADER *)LocalAlloc(LPTR, sizeof(BITMAPINFOHEADER) + cbColorTable); if (!pbi) goto Error; // Get the color table and fill in the rest of *pbi // *pbi = bi; if (GetDIBits(hdc, hbm, 0, cy, NULL, (BITMAPINFO *)pbi, DIB_RGB_COLORS) == 0) goto Error; if (cBitsPerPixel == 1) { ((DWORD *)(pbi+1))[0] = CLR_BLACK; ((DWORD *)(pbi+1))[1] = CLR_WHITE; } pbi->biSizeImage = WIDTHBYTES(cx, cBitsPerPixel) * cy; hr = pstm->Write(&bf, sizeof(bf), NULL); if (FAILED(hr)) goto Error; hr = pstm->Write(pbi, sizeof(bi) + cbColorTable, NULL); if (FAILED(hr)) goto Error; // // if we have a DIBSection just write the bits out // if (bm.bmBits != NULL) { hr = pstm->Write(bm.bmBits, pbi->biSizeImage, NULL); if (FAILED(hr)) goto Error; goto Done; } // Calculate number of horizontal lines that'll fit into our buffer... // cLines = CBDIBBUF / WIDTHBYTES(cx, cBitsPerPixel); hr = E_OUTOFMEMORY; pbuf = (PBYTE)LocalAlloc(LPTR, CBDIBBUF); if (!pbuf) goto Error; for (cLinesWritten = 0; cLinesWritten < cy; cLinesWritten += cLines) { hr = E_OUTOFMEMORY; if (cLines > cy - cLinesWritten) cLines = cy - cLinesWritten; if (GetDIBits(hdc, hbm, cLinesWritten, cLines, pbuf, (BITMAPINFO *)pbi, DIB_RGB_COLORS) == 0) goto Error; hr = pstm->Write(pbuf, WIDTHBYTES(cx, cBitsPerPixel) * cLines, NULL); if (FAILED(hr)) goto Error; } Done: hr = S_OK; Error: if (hdc) ReleaseDC(HWND_DESKTOP, hdc); if (pbi) LocalFree((HLOCAL)pbi); if (pbuf) LocalFree((HLOCAL)pbuf); return hr; } HRESULT Stream_ReadBitmap(LPSTREAM pstm, BOOL fDS, HBITMAP* phbmp) { HDC hdc; HBITMAP hbm; BITMAPFILEHEADER bf; BITMAPINFOHEADER bi; BITMAPINFOHEADER * pbi; BYTE * pbuf=NULL; int cBitsPerPixel; UINT cbColorTable; int cx, cy; int cLines, cLinesRead; ASSERT(pstm); hdc = NULL; hbm = NULL; pbi = NULL; HRESULT hr = pstm->Read(&bf, sizeof(bf), NULL); if (FAILED(hr)) goto Error; hr = E_INVALIDARG; if (bf.bfType != BFTYPE_BITMAP) goto Error; hr = pstm->Read(&bi, sizeof(bi), NULL); if (FAILED(hr)) goto Error; hr = E_INVALIDARG; if (bi.biSize != sizeof(bi)) goto Error; cx = (int)bi.biWidth; cy = (int)bi.biHeight; cBitsPerPixel = (int)bi.biBitCount * (int)bi.biPlanes; if (cBitsPerPixel <= 8) cbColorTable = (1 << cBitsPerPixel) * sizeof(RGBQUAD); else cbColorTable = 0; hr = E_OUTOFMEMORY; pbi = (BITMAPINFOHEADER*)LocalAlloc(LPTR, sizeof(bi) + cbColorTable); if (!pbi) goto Error; *pbi = bi; pbi->biSizeImage = WIDTHBYTES(cx, cBitsPerPixel) * cy; if (cbColorTable) { hr = pstm->Read(pbi + 1, cbColorTable, NULL); if (FAILED(hr)) goto Error; } hdc = GetDC(HWND_DESKTOP); // // see if we can make a DIBSection // if ((cBitsPerPixel > 1) && (fDS != ILC_COLORDDB)) { // // create DIBSection and read the bits directly into it! // hr = E_OUTOFMEMORY; hbm = CreateDIBSection(hdc, (LPBITMAPINFO)pbi, DIB_RGB_COLORS, (void**)&pbuf, NULL, 0); if (hbm == NULL) goto Error; hr = pstm->Read(pbuf, pbi->biSizeImage, NULL); if (FAILED(hr)) goto Error; pbuf = NULL; // dont free this goto Done; } // // cant make a DIBSection make a mono or color bitmap. // else if (cBitsPerPixel > 1) hbm = CreateColorBitmap(cx, cy); else hbm = CreateMonoBitmap(cx, cy); hr = E_OUTOFMEMORY; if (!hbm) return NULL; // Calculate number of horizontal lines that'll fit into our buffer... // cLines = CBDIBBUF / WIDTHBYTES(cx, cBitsPerPixel); hr = E_OUTOFMEMORY; pbuf = (PBYTE)LocalAlloc(LPTR, CBDIBBUF); if (!pbuf) goto Error; for (cLinesRead = 0; cLinesRead < cy; cLinesRead += cLines) { if (cLines > cy - cLinesRead) cLines = cy - cLinesRead; hr = pstm->Read(pbuf, WIDTHBYTES(cx, cBitsPerPixel) * cLines, NULL); if (FAILED(hr)) goto Error; hr = E_OUTOFMEMORY; if (!SetDIBits(hdc, hbm, cLinesRead, cLines, pbuf, (BITMAPINFO *)pbi, DIB_RGB_COLORS)) { goto Error; } } Done: hr = S_OK; Error: if (hdc) ReleaseDC(HWND_DESKTOP, hdc); if (pbi) LocalFree((HLOCAL)pbi); if (pbuf) LocalFree((HLOCAL)pbuf); if (FAILED(hr) && hbm) { DeleteBitmap(hbm); hbm = NULL; } *phbmp = hbm; return hr; } HRESULT CImageList::GetImageRect(int i, RECT * prcImage) { int x, y; ASSERT(prcImage); if (!prcImage || !IsImageListIndex(i)) return E_FAIL; x = _cx * (i % _cStrip); y = _cy * (i / _cStrip); SetRect(prcImage, x, y, x + _cx, y + _cy); return S_OK; } BOOL CImageList::GetSpareImageRect(RECT * prcImage) { BOOL fRet; // special hacking to use the one scratch image at tail of list :) _cImage++; fRet = (S_OK == GetImageRect(_cImage-1, prcImage)); _cImage--; return fRet; } // Drag Drop // copy an image from one imagelist to another at x,y within iDst in pimlDst. // pimlDst's image size should be larger than pimlSrc void CImageList::_CopyOneImage(int iDst, int x, int y, CImageList* piml, int iSrc) { RECT rcSrc, rcDst; piml->GetImageRect(iSrc, &rcSrc); GetImageRect(iDst, &rcDst); if (piml->_hdcMask && _hdcMask) { BitBlt(_hdcMask, rcDst.left + x, rcDst.top + y, piml->_cx, piml->_cy, piml->_hdcMask, rcSrc.left, rcSrc.top, SRCCOPY); } BitBlt(_hdcImage, rcDst.left + x, rcDst.top + y, piml->_cx, piml->_cy, piml->_hdcImage, rcSrc.left, rcSrc.top, SRCCOPY); } // // Cached bitmaps that we use during drag&drop. We re-use those bitmaps // across multiple drag session as far as the image size is the same. // struct DRAGRESTOREBMP { int BitsPixel; HBITMAP hbmOffScreen; HBITMAP hbmRestore; SIZE sizeRestore; } g_drb = { 0, NULL, NULL, {-1,-1} }; BOOL CImageList::CreateDragBitmaps() { HDC hdc; hdc = GetDC(NULL); if (_cx != g_drb.sizeRestore.cx || _cy != g_drb.sizeRestore.cy || GetDeviceCaps(hdc, BITSPIXEL) != g_drb.BitsPixel) { ImageList_DeleteDragBitmaps(); g_drb.BitsPixel = GetDeviceCaps(hdc, BITSPIXEL); g_drb.sizeRestore.cx = _cx; g_drb.sizeRestore.cy = _cy; g_drb.hbmRestore = CreateColorBitmap(g_drb.sizeRestore.cx, g_drb.sizeRestore.cy); g_drb.hbmOffScreen = CreateColorBitmap(g_drb.sizeRestore.cx * 2 - 1, g_drb.sizeRestore.cy * 2 - 1); if (!g_drb.hbmRestore || !g_drb.hbmOffScreen) { ImageList_DeleteDragBitmaps(); ReleaseDC(NULL, hdc); return FALSE; } } ReleaseDC(NULL, hdc); return TRUE; } void ImageList_DeleteDragBitmaps() { if (g_drb.hbmRestore) { CImageList::_DeleteBitmap(g_drb.hbmRestore); g_drb.hbmRestore = NULL; } if (g_drb.hbmOffScreen) { CImageList::_DeleteBitmap(g_drb.hbmOffScreen); g_drb.hbmOffScreen = NULL; } g_drb.sizeRestore.cx = -1; g_drb.sizeRestore.cy = -1; } // // Drag context. We don't reuse none of them across two different // drag sessions. I'm planning to allocate it for each session // to minimize critical sections. // struct DRAGCONTEXT { CImageList* pimlDrag; // Image to be drawin while dragging IImageList* puxCursor; // Overlap cursor image CImageList* pimlDither; // Dithered image IImageList* puxDragImage; // The context of the drag. int iCursor; // Image index of the cursor POINT ptDrag; // current drag position (hwndDC coords) POINT ptDragHotspot; POINT ptCursor; BOOL fDragShow; BOOL fHiColor; HWND hwndDC; } g_dctx = { (CImageList*)NULL, (CImageList*)NULL, (CImageList*)NULL, (IImageList*)NULL, -1, {0, 0}, {0, 0}, {0, 0}, FALSE, FALSE, (HWND)NULL }; HDC ImageList_GetDragDC() { HDC hdc = GetDCEx(g_dctx.hwndDC, NULL, DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE); // // If hdc is mirrored then mirror the 2 globals DCs. // if (IS_DC_RTL_MIRRORED(hdc)) { SET_DC_RTL_MIRRORED(g_hdcDst); SET_DC_RTL_MIRRORED(g_hdcSrc); } return hdc; } void ImageList_ReleaseDragDC(HDC hdc) { // // If the hdc is mirrored then unmirror the 2 globals DCs. // if (IS_DC_RTL_MIRRORED(hdc)) { SET_DC_LAYOUT(g_hdcDst, 0); SET_DC_LAYOUT(g_hdcSrc, 0); } ReleaseDC(g_dctx.hwndDC, hdc); } // // x, y -- Specifies the initial cursor position in the coords of hwndLock, // which is specified by the previous ImageList_StartDrag call. // HRESULT CImageList::DragMove(int x, int y) { int IncOne = 0; ENTERCRITICAL; if (g_dctx.fDragShow) { RECT rcOld, rcNew, rcBounds; int dx, dy; dx = x - g_dctx.ptDrag.x; dy = y - g_dctx.ptDrag.y; rcOld.left = g_dctx.ptDrag.x - g_dctx.ptDragHotspot.x; rcOld.top = g_dctx.ptDrag.y - g_dctx.ptDragHotspot.y; rcOld.right = rcOld.left + g_drb.sizeRestore.cx; rcOld.bottom = rcOld.top + g_drb.sizeRestore.cy; rcNew = rcOld; OffsetRect(&rcNew, dx, dy); if (!IntersectRect(&rcBounds, &rcOld, &rcNew)) { // // No intersection. Simply hide the old one and show the new one. // ImageList_DragShowNolock(FALSE); g_dctx.ptDrag.x = x; g_dctx.ptDrag.y = y; ImageList_DragShowNolock(TRUE); } else { // // Some intersection. // HDC hdcScreen; int cx, cy; UnionRect(&rcBounds, &rcOld, &rcNew); hdcScreen = ImageList_GetDragDC(); if (hdcScreen) { // // If the DC is RTL mirrored, then restrict the // screen bitmap not to go beyond the screen since // we will end up copying the wrong bits from the // hdcScreen to the hbmOffScreen when the DC is mirrored. // GDI will skip invalid screen coord from the screen into // the destination bitmap. This will result in copying un-init // bits back to the screen (since the screen is mirrored). // [samera] // if (IS_DC_RTL_MIRRORED(hdcScreen)) { RECT rcWindow; GetWindowRect(g_dctx.hwndDC, &rcWindow); rcWindow.right -= rcWindow.left; if (rcBounds.right > rcWindow.right) { rcBounds.right = rcWindow.right; } if (rcBounds.left < 0) { rcBounds.left = 0; } } cx = rcBounds.right - rcBounds.left; cy = rcBounds.bottom - rcBounds.top; // // Copy the union rect from the screen to hbmOffScreen. // CImageList::SelectDstBitmap(g_drb.hbmOffScreen); BitBlt(g_hdcDst, 0, 0, cx, cy, hdcScreen, rcBounds.left, rcBounds.top, SRCCOPY); // // Hide the cursor on the hbmOffScreen by copying hbmRestore. // CImageList::SelectSrcBitmap(g_drb.hbmRestore); BitBlt(g_hdcDst, rcOld.left - rcBounds.left, rcOld.top - rcBounds.top, g_drb.sizeRestore.cx, g_drb.sizeRestore.cy, g_hdcSrc, 0, 0, SRCCOPY); // // Copy the original screen bits to hbmRestore // BitBlt(g_hdcSrc, 0, 0, g_drb.sizeRestore.cx, g_drb.sizeRestore.cy, g_hdcDst, rcNew.left - rcBounds.left, rcNew.top - rcBounds.top, SRCCOPY); // // Draw the image on hbmOffScreen // if (g_dctx.fHiColor) { WimpyDrawEx(SAFECAST(g_dctx.pimlDrag, IImageList*), 0, g_hdcDst, rcNew.left - rcBounds.left + IncOne, rcNew.top - rcBounds.top, 0, 0, CLR_NONE, CLR_NONE, ILD_BLEND50); if (g_dctx.puxCursor) { WimpyDraw(g_dctx.puxCursor, g_dctx.iCursor, g_hdcDst, rcNew.left - rcBounds.left + g_dctx.ptCursor.x + IncOne, rcNew.top - rcBounds.top + g_dctx.ptCursor.y, ILD_NORMAL); } } else { WimpyDraw(SAFECAST(g_dctx.pimlDrag, IImageList*), 0, g_hdcDst, rcNew.left - rcBounds.left + IncOne, rcNew.top - rcBounds.top, ILD_NORMAL); } // // Copy the hbmOffScreen back to the screen. // BitBlt(hdcScreen, rcBounds.left, rcBounds.top, cx, cy, g_hdcDst, 0, 0, SRCCOPY); ImageList_ReleaseDragDC(hdcScreen); } g_dctx.ptDrag.x = x; g_dctx.ptDrag.y = y; } } LEAVECRITICAL; return S_OK; } HRESULT CImageList::BeginDrag(int iTrack, int dxHotspot, int dyHotspot) { HRESULT hr = E_ACCESSDENIED; ENTERCRITICAL; if (!g_dctx.pimlDrag) { UINT newflags; int cxI = 0, cyI = 0; g_dctx.fDragShow = FALSE; g_dctx.hwndDC = NULL; g_dctx.fHiColor = GetScreenDepth() > 8; newflags = _flags|ILC_SHARED; if (g_dctx.fHiColor) { newflags = (newflags & ~ILC_COLORMASK) | ILC_COLOR16; } g_dctx.pimlDither = CImageList::Create(_cx, _cy, newflags, 1, 0); if (g_dctx.pimlDither) { g_dctx.pimlDither->_cImage++; g_dctx.ptDragHotspot.x = dxHotspot; g_dctx.ptDragHotspot.y = dyHotspot; g_dctx.pimlDither->_CopyOneImage(0, 0, 0, this, iTrack); hr = ImageList_SetDragImage(NULL, 0, dxHotspot, dyHotspot); } } LEAVECRITICAL; return hr; } HRESULT CImageList::DragEnter(HWND hwndLock, int x, int y) { HRESULT hr = S_FALSE; hwndLock = hwndLock ? hwndLock : GetDesktopWindow(); ENTERCRITICAL; if (!g_dctx.hwndDC) { g_dctx.hwndDC = hwndLock; g_dctx.ptDrag.x = x; g_dctx.ptDrag.y = y; ImageList_DragShowNolock(TRUE); hr = S_OK; } LEAVECRITICAL; return hr; } HRESULT CImageList::DragLeave(HWND hwndLock) { HRESULT hr = S_FALSE; hwndLock = hwndLock ? hwndLock : GetDesktopWindow(); ENTERCRITICAL; if (g_dctx.hwndDC == hwndLock) { ImageList_DragShowNolock(FALSE); g_dctx.hwndDC = NULL; hr = S_OK; } LEAVECRITICAL; return hr; } HRESULT CImageList::DragShowNolock(BOOL fShow) { HDC hdcScreen; int x, y; int IncOne = 0; x = g_dctx.ptDrag.x - g_dctx.ptDragHotspot.x; y = g_dctx.ptDrag.y - g_dctx.ptDragHotspot.y; if (!g_dctx.pimlDrag) return E_ACCESSDENIED; // // REVIEW: Why this block is in the critical section? We are supposed // to have only one dragging at a time, aren't we? // ENTERCRITICAL; if (fShow && !g_dctx.fDragShow) { hdcScreen = ImageList_GetDragDC(); CImageList::SelectSrcBitmap(g_drb.hbmRestore); BitBlt(g_hdcSrc, 0, 0, g_drb.sizeRestore.cx, g_drb.sizeRestore.cy, hdcScreen, x, y, SRCCOPY); if (g_dctx.fHiColor) { WimpyDrawEx(SAFECAST(g_dctx.pimlDrag, IImageList*), 0, hdcScreen, x + IncOne, y, 0, 0, CLR_NONE, CLR_NONE, ILD_BLEND50); if (g_dctx.puxCursor) { WimpyDraw(g_dctx.puxCursor, g_dctx.iCursor, hdcScreen, x + g_dctx.ptCursor.x + IncOne, y + g_dctx.ptCursor.y, ILD_NORMAL); } } else { WimpyDraw(SAFECAST(g_dctx.pimlDrag, IImageList*), 0, hdcScreen, x + IncOne, y, ILD_NORMAL); } ImageList_ReleaseDragDC(hdcScreen); } else if (!fShow && g_dctx.fDragShow) { hdcScreen = ImageList_GetDragDC(); CImageList::SelectSrcBitmap(g_drb.hbmRestore); BitBlt(hdcScreen, x, y, g_drb.sizeRestore.cx, g_drb.sizeRestore.cy, g_hdcSrc, 0, 0, SRCCOPY); ImageList_ReleaseDragDC(hdcScreen); } g_dctx.fDragShow = fShow; LEAVECRITICAL; return S_OK; } // this hotspot stuff is broken in design BOOL ImageList_MergeDragImages(int dxHotspot, int dyHotspot) { CImageList* pimlNew; BOOL fRet = FALSE; if (g_dctx.pimlDither) { if (g_dctx.puxCursor) { IImageList* pux = NULL; IImageListPriv* puxpCursor; if (SUCCEEDED(g_dctx.puxCursor->QueryInterface(IID_PPV_ARG(IImageListPriv, &puxpCursor)))) { // If the cursor list has a mirrored list, let's use that. if (FAILED(puxpCursor->GetMirror(IID_PPV_ARG(IImageList, &pux)))) { pux = g_dctx.puxCursor; if (pux) pux->AddRef(); } puxpCursor->Release(); } g_dctx.pimlDither->_Merge(0, pux, g_dctx.iCursor, dxHotspot, dyHotspot, &pimlNew); if (pimlNew && pimlNew->CreateDragBitmaps()) { // WARNING: Don't destroy pimlDrag if it is pimlDither. if (g_dctx.pimlDrag && (g_dctx.pimlDrag != g_dctx.pimlDither)) { g_dctx.pimlDrag->Release(); } g_dctx.pimlDrag = pimlNew; fRet = TRUE; } pux->Release(); } else { if (g_dctx.pimlDither->CreateDragBitmaps()) { g_dctx.pimlDrag = g_dctx.pimlDither; fRet = TRUE; } } } else { // not an error case if both aren't set yet // only an error if we actually tried the merge and failed fRet = TRUE; } return fRet; } BOOL ImageList_SetDragImage(HIMAGELIST piml, int i, int dxHotspot, int dyHotspot) { BOOL fVisible = g_dctx.fDragShow; BOOL fRet; ENTERCRITICAL; if (fVisible) ImageList_DragShowNolock(FALSE); // only do this last step if everything is there. fRet = ImageList_MergeDragImages(dxHotspot, dyHotspot); if (fVisible) ImageList_DragShowNolock(TRUE); LEAVECRITICAL; return fRet; } HRESULT CImageList::GetDragImage(POINT * ppt, POINT * pptHotspot, REFIID riid, void** ppv) { if (ppt) { ppt->x = g_dctx.ptDrag.x; ppt->y = g_dctx.ptDrag.y; } if (pptHotspot) { pptHotspot->x = g_dctx.ptDragHotspot.x; pptHotspot->y = g_dctx.ptDragHotspot.y; } if (g_dctx.pimlDrag) { return g_dctx.pimlDrag->QueryInterface(riid, ppv); } return E_ACCESSDENIED; } HRESULT CImageList::GetItemFlags(int i, DWORD *dwFlags) { return E_NOTIMPL; } HRESULT CImageList::GetOverlayImage(int iOverlay, int* piIndex) { return E_NOTIMPL; } HRESULT CImageList::SetDragCursorImage(IUnknown* punk, int i, int dxHotspot, int dyHotspot) { HRESULT hr = E_INVALIDARG; BOOL fVisible = g_dctx.fDragShow; IImageList* pux; if (SUCCEEDED(punk->QueryInterface(IID_PPV_ARG(IImageList, &pux)))) { ENTERCRITICAL; // do work only if something has changed if ((g_dctx.puxCursor != pux) || (g_dctx.iCursor != i)) { if (fVisible) ImageList_DragShowNolock(FALSE); IImageList* puxOld = g_dctx.puxCursor; g_dctx.puxCursor = pux; g_dctx.puxCursor->AddRef(); if (puxOld) puxOld->Release(); g_dctx.iCursor = i; g_dctx.ptCursor.x = dxHotspot; g_dctx.ptCursor.y = dyHotspot; hr = ImageList_MergeDragImages(dxHotspot, dyHotspot)? S_OK: E_FAIL; if (fVisible) ImageList_DragShowNolock(TRUE); } LEAVECRITICAL; pux->Release(); } return hr; } HRESULT CImageList::EndDrag() { ENTERCRITICAL; ImageList_DragShowNolock(FALSE); // WARNING: Don't destroy pimlDrag if it is pimlDither. if (g_dctx.pimlDrag && (g_dctx.pimlDrag != g_dctx.pimlDither)) { g_dctx.pimlDrag->Release(); } g_dctx.pimlDrag = NULL; if (g_dctx.pimlDither) { g_dctx.pimlDither->Release(); g_dctx.pimlDither = NULL; } if (g_dctx.puxCursor) { g_dctx.puxCursor->Release(); g_dctx.puxCursor = NULL; } g_dctx.iCursor = -1; g_dctx.hwndDC = NULL; LEAVECRITICAL; return S_OK; } // APIs BOOL WINAPI ImageList_SetDragCursorImage(HIMAGELIST piml, int i, int dxHotspot, int dyHotspot) { BOOL fRet = FALSE; IUnknown* punk; HRESULT hr = HIMAGELIST_QueryInterface(piml, IID_PPV_ARG(IUnknown, &punk)); if (SUCCEEDED(hr)) { if (g_dctx.puxDragImage) { fRet = (S_OK == g_dctx.puxDragImage->SetDragCursorImage(punk, i, dxHotspot, dyHotspot)); } punk->Release(); } return fRet; } HIMAGELIST WINAPI ImageList_GetDragImage(POINT * ppt, POINT * pptHotspot) { if (g_dctx.puxDragImage) { IImageList* punk; g_dctx.puxDragImage->GetDragImage(ppt, pptHotspot, IID_PPV_ARG(IImageList, &punk)); return reinterpret_cast(punk); } return NULL; } void WINAPI ImageList_EndDrag() { ENTERCRITICAL; if (g_dctx.puxDragImage) { g_dctx.puxDragImage->EndDrag(); g_dctx.puxDragImage->Release(); g_dctx.puxDragImage = NULL; } LEAVECRITICAL; } BOOL WINAPI ImageList_BeginDrag(HIMAGELIST pimlTrack, int iTrack, int dxHotspot, int dyHotspot) { IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(pimlTrack, IID_PPV_ARG(IImageList, &pux)))) { if (SUCCEEDED(pux->BeginDrag(iTrack, dxHotspot, dyHotspot))) { g_dctx.puxDragImage = pux; return TRUE; } } return FALSE; } BOOL WINAPI ImageList_DragEnter(HWND hwndLock, int x, int y) { BOOL fRet = FALSE; if (g_dctx.puxDragImage) { fRet = (S_OK == g_dctx.puxDragImage->DragEnter(hwndLock, x, y)); } return fRet; } BOOL WINAPI ImageList_DragMove(int x, int y) { BOOL fRet = FALSE; if (g_dctx.puxDragImage) { fRet = (S_OK == g_dctx.puxDragImage->DragMove(x, y)); } return fRet; } BOOL WINAPI ImageList_DragLeave(HWND hwndLock) { BOOL fRet = FALSE; if (g_dctx.puxDragImage) { fRet = (S_OK == g_dctx.puxDragImage->DragLeave(hwndLock)); } return fRet; } BOOL WINAPI ImageList_DragShowNolock(BOOL fShow) { BOOL fRet = FALSE; if (g_dctx.puxDragImage) { fRet = (S_OK == g_dctx.puxDragImage->DragShowNolock(fShow)); } return fRet; } //============================================================================ // ImageList_Clone - clone a image list // // create a new imagelist with the same properties as the given // imagelist, except mabey a new icon size // // piml - imagelist to clone // cx,cy - new icon size (0,0) to use clone icon size. // flags - new flags (used if no clone) // cInitial- initial size // cGrow - grow value (used if no clone) //============================================================================ EXTERN_C HIMAGELIST WINAPI ImageList_Clone(HIMAGELIST himl, int cx, int cy, UINT flags, int cInitial, int cGrow) { IImageListPriv* puxp; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageListPriv, &puxp)))) { // always use the clone flags puxp->GetFlags(&flags); IUnknown* punkMirror; if (SUCCEEDED(puxp->GetMirror(IID_PPV_ARG(IUnknown, &punkMirror)))) { flags |= ILC_MIRROR; punkMirror->Release(); } IImageList* pux; if (SUCCEEDED(puxp->QueryInterface(IID_PPV_ARG(IImageList, &pux)))) { int cxI, cyI; pux->GetIconSize(&cxI, &cyI); if (cx == 0) cx = cxI; if (cy == 0) cy = cyI; pux->Release(); } puxp->Release(); } return ImageList_Create(cx,cy,flags,cInitial,cGrow); } HRESULT WINAPI ImageList_CreateInstance(int cx, int cy, UINT flags, int cInitial, int cGrow, REFIID riid, void** ppv) { CImageList* piml=NULL; HRESULT hr = E_OUTOFMEMORY; *ppv = NULL; piml = CImageList::Create(cx, cy, flags, cInitial, cGrow); if (piml) { // // Let's create a mirrored imagelist, if requested. // if (piml->_flags & ILC_MIRROR) { piml->_flags &= ~ILC_MIRROR; piml->_pimlMirror = CImageList::Create(cx, cy, flags, cInitial, cGrow); if (piml->_pimlMirror) { piml->_pimlMirror->_flags &= ~ILC_MIRROR; } } hr = piml->QueryInterface(riid, ppv); piml->Release(); } return hr; } HIMAGELIST WINAPI ImageList_Create(int cx, int cy, UINT flags, int cInitial, int cGrow) { IImageList* pux; ImageList_CreateInstance(cx, cy, flags, cInitial, cGrow, IID_PPV_ARG(IImageList, &pux)); return reinterpret_cast(pux); } #ifdef UNICODE // // When this code is compiled Unicode, this implements the // ANSI version of the ImageList_LoadImage api. // HIMAGELIST WINAPI ImageList_LoadImageA(HINSTANCE hi, LPCSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags) { HIMAGELIST lpResult; LPWSTR lpBmpW; if (!IS_INTRESOURCE(lpbmp)) { lpBmpW = ProduceWFromA(CP_ACP, lpbmp); if (!lpBmpW) { return NULL; } } else { lpBmpW = (LPWSTR)lpbmp; } lpResult = ImageList_LoadImageW(hi, lpBmpW, cx, cGrow, crMask, uType, uFlags); if (!IS_INTRESOURCE(lpbmp)) FreeProducedString(lpBmpW); return lpResult; } #else // // When this code is compiled ANSI, this stubs the // Unicode version of the ImageList_LoadImage api. // IMAGELIST* WINAPI ImageList_LoadImageW(HINSTANCE hi, LPCWSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags) { SetLastErrorEx(ERROR_CALL_NOT_IMPLEMENTED, SLE_WARNING); return NULL; } #endif HIMAGELIST WINAPI ImageList_LoadImage(HINSTANCE hi, LPCTSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags) { HBITMAP hbmImage; HIMAGELIST piml = NULL; BITMAP bm; int cy, cInitial; UINT flags; hbmImage = (HBITMAP)LoadImage(hi, lpbmp, uType, 0, 0, uFlags); if (hbmImage && (sizeof(bm) == GetObject(hbmImage, sizeof(bm), &bm))) { // If cx is not stated assume it is the same as cy. // ASSERT(cx); cy = bm.bmHeight; if (cx == 0) cx = cy; cInitial = bm.bmWidth / cx; ENTERCRITICAL; flags = 0; if (crMask != CLR_NONE) flags |= ILC_MASK; if (bm.bmBits) flags |= (bm.bmBitsPixel & ILC_COLORMASK); piml = ImageList_Create(cx, cy, flags, cInitial, cGrow); if (piml) { int added; if (crMask == CLR_NONE) added = ImageList_Add(piml, hbmImage, NULL); else added = ImageList_AddMasked(piml, hbmImage, crMask); if (added < 0) { ImageList_Destroy(piml); piml = NULL; } } LEAVECRITICAL; } if (hbmImage) DeleteObject(hbmImage); return reinterpret_cast((IImageList*)piml); } // // #undef ImageList_AddIcon EXTERN_C int WINAPI ImageList_AddIcon(HIMAGELIST himl, HICON hIcon) { return ImageList_ReplaceIcon(himl, -1, hIcon); } EXTERN_C void WINAPI ImageList_CopyDitherImage(HIMAGELIST himlDst, WORD iDst, int xDst, int yDst, HIMAGELIST himlSrc, int iSrc, UINT fStyle) { IImageListPriv* puxp; if (SUCCEEDED(HIMAGELIST_QueryInterface(himlDst, IID_PPV_ARG(IImageListPriv, &puxp)))) { IUnknown* punk; if (SUCCEEDED(HIMAGELIST_QueryInterface(himlSrc, IID_PPV_ARG(IUnknown, &punk)))) { puxp->CopyDitherImage(iDst, xDst, yDst, punk, iSrc, fStyle); punk->Release(); } puxp->Release(); } } // // ImageList_Duplicate // // Makes a copy of the passed in imagelist. // HIMAGELIST WINAPI ImageList_Duplicate(HIMAGELIST himl) { IImageList* pret = NULL; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { pux->Clone(IID_PPV_ARG(IImageList, &pret)); pux->Release(); } return reinterpret_cast(pret); } BOOL WINAPI ImageList_Write(HIMAGELIST himl, LPSTREAM pstm) { BOOL fRet = FALSE; IPersistStream* pps; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IPersistStream, &pps)))) { if (SUCCEEDED(pps->Save(pstm, TRUE))) { fRet = TRUE; } pps->Release(); } return fRet; } HIMAGELIST WINAPI ImageList_Read(LPSTREAM pstm) { CImageList* piml = new CImageList(); if (piml) { if (SUCCEEDED(piml->Load(pstm))) { return reinterpret_cast((IImageList*)piml); } piml->Release(); } return NULL; } BOOL WINAPI ImageList_GetImageRect(HIMAGELIST himl, int i, RECT * prcImage) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { if (SUCCEEDED(pux->GetImageRect(i, prcImage))) { fRet = TRUE; } pux->Release(); } return fRet; } BOOL WINAPI ImageList_Destroy(HIMAGELIST himl) { BOOL fRet = FALSE; IImageList* pux; // Weirdness: We are doing a Query Interface first to verify that // this is actually a valid imagelist, then we are calling release twice if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { // Release the interface we QI'd for pux->Release(); // Release a second time to destroy the object pux->Release(); fRet = TRUE; } return fRet; } int WINAPI ImageList_GetImageCount(HIMAGELIST himl) { int fRet = 0; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { pux->GetImageCount(&fRet); pux->Release(); } return fRet; } BOOL WINAPI ImageList_SetImageCount(HIMAGELIST himl, UINT uNewCount) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->SetImageCount(uNewCount)); pux->Release(); } return fRet; } int WINAPI ImageList_Add(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask) { int fRet = -1; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { pux->Add(hbmImage, hbmMask, &fRet); pux->Release(); } return fRet; } int WINAPI ImageList_ReplaceIcon(HIMAGELIST himl, int i, HICON hicon) { int fRet = -1; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { pux->ReplaceIcon(i, hicon, &fRet); pux->Release(); } return fRet; } COLORREF WINAPI ImageList_SetBkColor(HIMAGELIST himl, COLORREF clrBk) { COLORREF fRet = clrBk; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { pux->SetBkColor(clrBk, &fRet); pux->Release(); } return fRet; } COLORREF WINAPI ImageList_GetBkColor(HIMAGELIST himl) { COLORREF fRet = RGB(0,0,0); IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { pux->GetBkColor(&fRet); pux->Release(); } return fRet; } BOOL WINAPI ImageList_SetOverlayImage(HIMAGELIST himl, int iImage, int iOverlay) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->SetOverlayImage(iImage, iOverlay)); pux->Release(); } return fRet; } BOOL WINAPI ImageList_Replace(HIMAGELIST himl, int i, HBITMAP hbmImage, HBITMAP hbmMask) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->Replace(i, hbmImage, hbmMask)); pux->Release(); } return fRet; } int WINAPI ImageList_AddMasked(HIMAGELIST himl, HBITMAP hbmImage, COLORREF crMask) { int fRet = -1; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { pux->AddMasked(hbmImage, crMask, &fRet); pux->Release(); } return fRet; } BOOL WINAPI ImageList_DrawEx(HIMAGELIST himl, int i, HDC hdcDst, int x, int y, int dx, int dy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { IMAGELISTDRAWPARAMS imldp = {0}; imldp.cbSize = sizeof(imldp); imldp.himl = himl; imldp.i = i; imldp.hdcDst = hdcDst; imldp.x = x; imldp.y = y; imldp.cx = dx; imldp.cy = dy; imldp.rgbBk = rgbBk; imldp.rgbFg = rgbFg; imldp.fStyle = fStyle; fRet = (S_OK == pux->Draw(&imldp)); pux->Release(); } return fRet; } BOOL WINAPI ImageList_Draw(HIMAGELIST himl, int i, HDC hdcDst, int x, int y, UINT fStyle) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { IMAGELISTDRAWPARAMS imldp = {0}; imldp.cbSize = sizeof(imldp); imldp.himl = himl; imldp.i = i; imldp.hdcDst = hdcDst; imldp.x = x; imldp.y = y; imldp.rgbBk = CLR_DEFAULT; imldp.rgbFg = CLR_DEFAULT; imldp.fStyle = fStyle; fRet = (S_OK == pux->Draw(&imldp)); pux->Release(); } return fRet; } BOOL WINAPI ImageList_DrawIndirect(IMAGELISTDRAWPARAMS* pimldp) { BOOL fRet = FALSE; IImageList* pux; if (!pimldp) return fRet; if (SUCCEEDED(HIMAGELIST_QueryInterface(pimldp->himl, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->Draw(pimldp)); pux->Release(); } return fRet; } BOOL WINAPI ImageList_Remove(HIMAGELIST himl, int i) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->Remove(i)); pux->Release(); } return fRet; } HICON WINAPI ImageList_GetIcon(HIMAGELIST himl, int i, UINT flags) { HICON fRet = NULL; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { pux->GetIcon(i, flags, &fRet); pux->Release(); } return fRet; } BOOL WINAPI ImageList_Copy(HIMAGELIST himlDst, int iDst, HIMAGELIST himlSrc, int iSrc, UINT uFlags) { BOOL fRet = FALSE; if (himlDst == himlSrc) { IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himlDst, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->Copy(iDst,(IUnknown*)pux, iSrc, uFlags)); pux->Release(); } } return fRet; } BOOL WINAPI ImageList_GetIconSize(HIMAGELIST himl, int FAR *cx, int FAR *cy) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->GetIconSize(cx, cy)); pux->Release(); } return fRet; } BOOL WINAPI ImageList_SetIconSize(HIMAGELIST himl, int cx, int cy) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->SetIconSize(cx, cy)); pux->Release(); } return fRet; } BOOL WINAPI ImageList_GetImageInfo(HIMAGELIST himl, int i, IMAGEINFO FAR* pImageInfo) { BOOL fRet = FALSE; IImageList* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageList, &pux)))) { fRet = (S_OK == pux->GetImageInfo(i, pImageInfo)); pux->Release(); } return fRet; } HIMAGELIST WINAPI ImageList_Merge(HIMAGELIST himl1, int i1, HIMAGELIST himl2, int i2, int dx, int dy) { IImageList* fRet = NULL; IImageList* pux1; IImageList* pux2; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl1, IID_PPV_ARG(IImageList, &pux1)))) { if (SUCCEEDED(HIMAGELIST_QueryInterface(himl2, IID_PPV_ARG(IImageList, &pux2)))) { pux1->Merge(i1, (IUnknown*)pux2, i2, dx, dy, IID_PPV_ARG(IImageList, &fRet)); pux2->Release(); } pux1->Release(); } return reinterpret_cast(fRet); } BOOL WINAPI ImageList_SetFlags(HIMAGELIST himl, UINT flags) { BOOL fRet = FALSE; IImageListPriv* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageListPriv, &pux)))) { fRet = (S_OK == pux->SetFlags(flags)); pux->Release(); } return fRet; } BOOL WINAPI ImageList_SetFilter(HIMAGELIST himl, PFNIMLFILTER pfnFilter, LPARAM lParamFilter) { return FALSE; } int ImageList_SetColorTable(HIMAGELIST himl, int start, int len, RGBQUAD *prgb) { int fRet = -1; IImageListPriv* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageListPriv, &pux)))) { pux->SetColorTable(start, len, prgb, &fRet); pux->Release(); } return fRet; } UINT WINAPI ImageList_GetFlags(HIMAGELIST himl) { UINT fRet = 0; IImageListPriv* pux; if (SUCCEEDED(HIMAGELIST_QueryInterface(himl, IID_PPV_ARG(IImageListPriv, &pux)))) { pux->GetFlags(&fRet); pux->Release(); } return fRet; }