// Created: 20.11.99
// RCS-ID: $Id$
// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// Licence: wxWindows license
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "gdiimage.h"
#endif
#include "wx/app.h"
-#include "wx/msw/dib.h"
-#include "wx/msw/bitmap.h"
-#include "wx/msw/gdiimage.h"
#include "wx/bitmap.h"
+#include "wx/msw/gdiimage.h"
+
+#if wxUSE_WXDIB
+#include "wx/msw/dib.h"
+#endif
+
+#ifdef __WXWINCE__
+#include <winreg.h>
+#include <shellapi.h>
+#endif
+
+#include "wx/file.h"
+
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxGDIImageHandlerList);
-#if wxUSE_XPM_IN_MSW
-# include "wx/xpmhand.h"
-#endif // wxUSE_XPM_IN_MSW
+// ----------------------------------------------------------------------------
+// auxiliary functions
+// ----------------------------------------------------------------------------
-#ifdef __WIN16__
-# include "wx/msw/curico.h"
-#endif // __WIN16__
+#ifdef __WXWINCE__
+// Used in wxBMPFileHandler::LoadFile
+HBITMAP wxLoadBMP(const wxString& filename) ;
+#endif
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
+#ifndef __WXMICROWIN__
+
// all image handlers are declared/defined in this file because the outside
// world doesn't have to know about them (but only about wxBITMAP_TYPE_XXX ids)
int WXUNUSED(height),
int WXUNUSED(depth) = 1)
{
- return FALSE;
+ return false;
}
virtual bool Save(wxGDIImage *WXUNUSED(image),
const wxString& WXUNUSED(name),
int WXUNUSED(type))
{
- return FALSE;
+ return false;
}
virtual bool Load(wxGDIImage *image,
int desiredWidth, int desiredHeight)
{
wxIcon *icon = wxDynamicCast(image, wxIcon);
- wxCHECK_MSG( icon, FALSE, _T("wxIconHandler only works with icons") );
+ wxCHECK_MSG( icon, false, _T("wxIconHandler only works with icons") );
return LoadIcon(icon, name, flags, desiredWidth, desiredHeight);
}
// wxWin macros
// ----------------------------------------------------------------------------
- IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
- IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
- IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxGDIImageHandler)
- IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxGDIImageHandler)
+IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
+IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
+IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxObject)
+IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxObject)
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
-static wxSize GetHiconSize(HICON hicon);
+#endif
+ // __MICROWIN__
// ============================================================================
// implementation
// ============================================================================
-wxList wxGDIImage::ms_handlers;
+wxGDIImageHandlerList wxGDIImage::ms_handlers;
// ----------------------------------------------------------------------------
// wxGDIImage functions forwarded to wxGDIImageRefData
GetGDIImageData()->m_handle = 0;
}
- return TRUE;
+ return true;
}
-WXHANDLE wxGDIImage::GetResourceHandle()
+WXHANDLE wxGDIImage::GetResourceHandle() const
{
return GetHandle();
}
if ( handler )
{
ms_handlers.DeleteObject(handler);
- return TRUE;
+ return true;
}
else
- return FALSE;
+ return false;
}
wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& name)
{
- wxNode *node = ms_handlers.First();
+ wxGDIImageHandlerList::compatibility_iterator node = ms_handlers.GetFirst();
while ( node )
{
- wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
+ wxGDIImageHandler *handler = node->GetData();
if ( handler->GetName() == name )
return handler;
- node = node->Next();
+ node = node->GetNext();
}
return NULL;
wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& extension,
long type)
{
- wxNode *node = ms_handlers.First();
+ wxGDIImageHandlerList::compatibility_iterator node = ms_handlers.GetFirst();
while ( node )
{
- wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
+ wxGDIImageHandler *handler = node->GetData();
if ( (handler->GetExtension() = extension) &&
(type == -1 || handler->GetType() == type) )
{
return handler;
}
- node = node->Next();
+ node = node->GetNext();
}
return NULL;
}
wxGDIImageHandler *wxGDIImage::FindHandler(long type)
{
- wxNode *node = ms_handlers.First();
+ wxGDIImageHandlerList::compatibility_iterator node = ms_handlers.GetFirst();
while ( node )
{
- wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
+ wxGDIImageHandler *handler = node->GetData();
if ( handler->GetType() == type )
return handler;
- node = node->Next();
+ node = node->GetNext();
}
return NULL;
void wxGDIImage::CleanUpHandlers()
{
- wxNode *node = ms_handlers.First();
+ wxGDIImageHandlerList::compatibility_iterator node = ms_handlers.GetFirst();
while ( node )
{
- wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
- wxNode *next = node->Next();
+ wxGDIImageHandler *handler = node->GetData();
+ wxGDIImageHandlerList::compatibility_iterator next = node->GetNext();
delete handler;
- delete node;
+ ms_handlers.Erase( node );
node = next;
}
}
void wxGDIImage::InitStandardHandlers()
{
+#ifndef __WXMICROWIN__
AddHandler(new wxBMPResourceHandler);
AddHandler(new wxBMPFileHandler);
-
- // GRG: Add these handlers by default if XPM support is enabled
-
-#if wxUSE_XPM_IN_MSW
- AddHandler(new wxXPMFileHandler);
- AddHandler(new wxXPMDataHandler);
-#endif // wxUSE_XPM_IN_MSW
-
AddHandler(new wxICOResourceHandler);
AddHandler(new wxICOFileHandler);
+#endif
}
+#ifndef __WXMICROWIN__
+
// ----------------------------------------------------------------------------
// wxBitmap handlers
// ----------------------------------------------------------------------------
// TODO: load colourmap.
bitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), name));
- wxBitmapRefData *data = bitmap->GetBitmapData();
- if ( bitmap->Ok() )
- {
- BITMAP bm;
- if ( !::GetObject(GetHbitmapOf(*bitmap), sizeof(BITMAP), (LPSTR) &bm) )
- {
- wxLogLastError(wxT("GetObject(HBITMAP)"));
- }
-
- data->m_width = bm.bmWidth;
- data->m_height = bm.bmHeight;
- data->m_depth = bm.bmBitsPixel;
- }
- else
+ if ( !bitmap->Ok() )
{
// it's probably not found
wxLogError(wxT("Can't load bitmap '%s' from resources! Check .rc file."),
name.c_str());
+
+ return false;
+ }
+
+ BITMAP bm;
+ if ( !::GetObject(GetHbitmapOf(*bitmap), sizeof(BITMAP), (LPSTR) &bm) )
+ {
+ wxLogLastError(wxT("GetObject(HBITMAP)"));
}
- return bitmap->Ok();
+ bitmap->SetWidth(bm.bmWidth);
+ bitmap->SetHeight(bm.bmHeight);
+ bitmap->SetDepth(bm.bmBitsPixel);
+
+ // use 0xc0c0c0 as transparent colour by default
+ bitmap->SetMask(new wxMask(*bitmap, *wxLIGHT_GREY));
+
+ return true;
}
bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap,
int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight))
{
-#if wxUSE_IMAGE_LOADING_IN_MSW
- wxPalette *palette = NULL;
- bool success = wxLoadIntoBitmap(WXSTRINGCAST name, bitmap, &palette) != 0;
- if ( success && palette )
- {
- bitmap->SetPalette(*palette);
- }
+#if wxUSE_WXDIB
+ wxCHECK_MSG( bitmap, false, _T("NULL bitmap in LoadFile") );
- // it was copied by the bitmap if it was loaded successfully
- delete palette;
+ wxDIB dib(name);
- return success;
+ bool ok = dib.IsOk() && bitmap->CopyFromDIB(dib);
+ return ok;
#else
+ WXHBITMAP hBitmap = (WXHBITMAP)wxLoadBMP(name);
+ if(hBitmap) {
+ bitmap->SetHBITMAP(hBitmap);
+ return TRUE;
+ }
return FALSE;
#endif
}
bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap,
const wxString& name,
int WXUNUSED(type),
- const wxPalette *pal)
+ const wxPalette * WXUNUSED(pal))
{
-#if wxUSE_IMAGE_LOADING_IN_MSW
- wxPalette *actualPalette = (wxPalette *)pal;
- if ( !actualPalette )
- actualPalette = bitmap->GetPalette();
- return wxSaveBitmap(WXSTRINGCAST name, bitmap, actualPalette) != 0;
+#if wxUSE_WXDIB
+ wxCHECK_MSG( bitmap, false, _T("NULL bitmap in SaveFile") );
+
+ wxDIB dib(*bitmap);
+
+ return dib.Save(name);
#else
return FALSE;
#endif
bool wxICOFileHandler::LoadIcon(wxIcon *icon,
const wxString& name,
- long flags,
+ long WXUNUSED(flags),
int desiredWidth, int desiredHeight)
{
-#if wxUSE_RESOURCE_LOADING_IN_MSW
icon->UnRef();
// actual size
wxSize size;
-#ifdef __WIN32__
HICON hicon = NULL;
- // were we asked for a large icon?
+ // Parse the filename: it may be of the form "filename;n" in order to
+ // specify the nth icon in the file.
+ //
+ // For the moment, ignore the issue of possible semicolons in the
+ // filename.
+ int iconIndex = 0;
+ wxString nameReal(name);
+ wxString strIconIndex = name.AfterLast(wxT(';'));
+ if (strIconIndex != name)
+ {
+ iconIndex = wxAtoi(strIconIndex);
+ nameReal = name.BeforeLast(wxT(';'));
+ }
+
+#if 0
+ // If we don't know what size icon we're looking for,
+ // try to find out what's there.
+ // Unfortunately this doesn't work, because ExtractIconEx
+ // will scale the icon to the 'desired' size, even if that
+ // size of icon isn't explicitly stored. So we would have
+ // to parse the icon file outselves.
+ if ( desiredWidth == -1 &&
+ desiredHeight == -1)
+ {
+ // Try loading a large icon first
+ if ( ::ExtractIconEx(nameReal, iconIndex, &hicon, NULL, 1) == 1)
+ {
+ }
+ // Then try loading a small icon
+ else if ( ::ExtractIconEx(nameReal, iconIndex, NULL, &hicon, 1) == 1)
+ {
+ }
+ }
+ else
+#endif
+ // were we asked for a large icon?
if ( desiredWidth == ::GetSystemMetrics(SM_CXICON) &&
desiredHeight == ::GetSystemMetrics(SM_CYICON) )
{
- // get the first large icon from file
- if ( !::ExtractIconEx(name, 0, &hicon, NULL, 1) )
+ // get the specified large icon from file
+ if ( !::ExtractIconEx(nameReal, iconIndex, &hicon, NULL, 1) )
{
// it is not an error, but it might still be useful to be informed
// about it optionally
else if ( desiredWidth == ::GetSystemMetrics(SM_CXSMICON) &&
desiredHeight == ::GetSystemMetrics(SM_CYSMICON) )
{
- // get the first small icon from file
- if ( !::ExtractIconEx(name, 0, NULL, &hicon, 1) )
+ // get the specified small icon from file
+ if ( !::ExtractIconEx(nameReal, iconIndex, NULL, &hicon, 1) )
{
wxLogTrace(_T("iconload"),
_T("No small icons found in the file '%s'."),
}
//else: not standard size, load below
+#ifndef __WXWINCE__
if ( !hicon )
{
- // take any (the first one) icon from the file by default
- hicon = ::ExtractIcon(wxGetInstance(), name, 0 /* first */);
+ // take any size icon from the file by index
+ hicon = ::ExtractIcon(wxGetInstance(), nameReal, iconIndex);
}
+#endif
if ( !hicon )
{
wxLogSysError(_T("Failed to load icon from the file '%s'"),
name.c_str());
- return FALSE;
+ return false;
}
- size = GetHiconSize(hicon);
-#else // Win16
- HICON hicon = ReadIconFile((wxChar *)name.c_str(),
- wxGetInstance(),
- &size.x, &size.y);
-#endif // Win32/Win16
+ size = wxGetHiconSize(hicon);
if ( (desiredWidth != -1 && desiredWidth != size.x) ||
(desiredHeight != -1 && desiredHeight != size.y) )
{
wxLogTrace(_T("iconload"),
- _T("Returning FALSE from wxICOFileHandler::Load because of the size mismatch: actual (%d, %d), requested (%d, %d)"),
+ _T("Returning false from wxICOFileHandler::Load because of the size mismatch: actual (%d, %d), requested (%d, %d)"),
size.x, size.y,
desiredWidth, desiredHeight);
::DestroyIcon(hicon);
- return FALSE;
+ return false;
}
icon->SetHICON((WXHICON)hicon);
icon->SetSize(size.x, size.y);
return icon->Ok();
-#else
- return FALSE;
-#endif
}
bool wxICOResourceHandler::LoadIcon(wxIcon *icon,
const wxString& name,
- long flags,
+ long WXUNUSED(flags),
int desiredWidth, int desiredHeight)
{
HICON hicon;
-#if defined(__WIN32__) && !defined(__SC__)
- if ( desiredWidth != -1 && desiredHeight != -1 )
+ // do we need the icon of the specific size or would any icon do?
+ bool hasSize = desiredWidth != -1 || desiredHeight != -1;
+
+ wxASSERT_MSG( !hasSize || (desiredWidth != -1 && desiredHeight != -1),
+ _T("width and height should be either both -1 or not") );
+
+ // try to load the icon from this program first to allow overriding the
+ // standard icons (although why one would want to do it considering that
+ // we already have wxApp::GetStdIcon() is unclear)
+
+ // note that we can't just always call LoadImage() because it seems to do
+ // some icon rescaling internally which results in very ugly 16x16 icons
+ if ( hasSize )
{
hicon = (HICON)::LoadImage(wxGetInstance(), name, IMAGE_ICON,
desiredWidth, desiredHeight,
LR_DEFAULTCOLOR);
}
else
-#endif // Win32
{
hicon = ::LoadIcon(wxGetInstance(), name);
}
- wxSize size = GetHiconSize(hicon);
- icon->SetSize(size.x, size.y);
-
- // Override the found values with desired values
- if ( desiredWidth > -1 && desiredHeight > -1 )
+ // next check if it's not a standard icon
+#ifndef __WXWINCE__
+ if ( !hicon && !hasSize )
{
- icon->SetSize(desiredWidth, desiredHeight);
+ static const struct
+ {
+ const wxChar *name;
+ LPTSTR id;
+ } stdIcons[] =
+ {
+ { wxT("wxICON_QUESTION"), IDI_QUESTION },
+ { wxT("wxICON_WARNING"), IDI_EXCLAMATION },
+ { wxT("wxICON_ERROR"), IDI_HAND },
+ { wxT("wxICON_INFORMATION"), IDI_ASTERISK },
+ };
+
+ for ( size_t nIcon = 0; !hicon && nIcon < WXSIZEOF(stdIcons); nIcon++ )
+ {
+ if ( name == stdIcons[nIcon].name )
+ {
+ hicon = ::LoadIcon((HINSTANCE)NULL, stdIcons[nIcon].id);
+ }
+ }
}
+#endif
+
+ wxSize size = wxGetHiconSize(hicon);
+ icon->SetSize(size.x, size.y);
icon->SetHICON((WXHICON)hicon);
// private functions
// ----------------------------------------------------------------------------
-static wxSize GetHiconSize(HICON hicon)
+wxSize wxGetHiconSize(HICON hicon)
{
wxSize size(32, 32); // default
-
-#ifdef __WIN32__
- // Win32s doesn't have GetIconInfo function...
+#ifndef __WXWINCE__
if ( hicon && wxGetOsVersion() != wxWIN32S )
{
ICONINFO info;
}
}
#endif
-
return size;
}
+
+#endif // __WXMICROWIN__
+
+#ifdef __WXWINCE__
+// Used in wxBMPFileHandler::LoadFile
+HBITMAP wxLoadBMP(const wxString& filename)
+{
+ wxFile file;
+ if(!file.Open(filename))
+ return 0;
+
+ // The first part of the file contains the file header.
+ // This will tell us if it is a bitmap, how big the header is, and how big
+ // the file is. The header size in the file header includes the color table.
+ BITMAPFILEHEADER BmpFileHdr;
+ BITMAPINFO *pBmpInfo = (BITMAPINFO*)malloc(sizeof(BITMAPINFO)+255*sizeof(RGBQUAD));
+ BYTE* pBits = 0;
+ HBITMAP hBitmap = 0;
+
+ if(file.Read(&BmpFileHdr, sizeof(BmpFileHdr))==sizeof(BmpFileHdr)
+ && !strncmp((char*)&BmpFileHdr.bfType,"BM",2)
+ && file.Read(pBmpInfo, sizeof(BITMAPINFOHEADER))==sizeof(BITMAPINFOHEADER)
+ && pBmpInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER)) {
+
+
+ unsigned int nColors = pBmpInfo->bmiHeader.biClrUsed ?
+ pBmpInfo->bmiHeader.biClrUsed : 1 << pBmpInfo->bmiHeader.biBitCount;
+ if (nColors < 1
+ || file.Read(pBmpInfo->bmiColors, nColors * sizeof(RGBQUAD))
+ == (off_t)(nColors * sizeof(RGBQUAD))) {
+
+ // So how big the bitmap surface is.
+ int nBitsSize = BmpFileHdr.bfSize - BmpFileHdr.bfOffBits;
+
+ // Allocate the memory for the bits and read the bits from the file.
+ pBits = (BYTE*) malloc(nBitsSize*2);
+ if (pBits) {
+ // Seek to the bits in the file.
+ file.Seek(BmpFileHdr.bfOffBits);
+
+ // read the bits
+ if(file.Read(pBits, nBitsSize)==nBitsSize) {
+ // Everything went OK.
+ pBmpInfo->bmiHeader.biSizeImage = nBitsSize;
+
+ //HBITMAP hBitmap=SetBitmap((LPBITMAPINFO)pBmpInfo, pBits);
+ DWORD dwBitmapInfoSize = sizeof(BITMAPINFO) + nColors*sizeof(RGBQUAD);
+
+ // Create a DC which will be used to get DIB, then create DIBsection
+ HDC hDC = ::GetDC(NULL);
+ if (hDC) {
+ LPVOID bits;
+ hBitmap = CreateDIBSection(hDC, (const BITMAPINFO*) pBmpInfo,
+ DIB_RGB_COLORS, &bits, NULL, 0);
+ ReleaseDC(0,hDC);
+
+ if (hBitmap) {
+ DWORD dwImageSize = pBmpInfo->bmiHeader.biSizeImage;
+ if (dwImageSize == 0) {
+ int nBytesPerLine = pBmpInfo->bmiHeader.biWidth * pBmpInfo->bmiHeader.biBitCount;
+ nBytesPerLine = ( (nBytesPerLine + 31) & (~31) ) / 8;
+ dwImageSize = nBytesPerLine * pBmpInfo->bmiHeader.biHeight;
+ }
+ memcpy(bits, pBits, dwImageSize);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if(pBmpInfo)
+ free(pBmpInfo);
+ if(pBits)
+ free(pBits);
+
+ return hBitmap;
+}
+#endif
+
projects / wxWidgets.git / blobdiff