AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

1. wxIcon/wxCursor change, wxGDIImage class added

Browse Source 
2. wxCriticalSection doesn't alloc memory any more
3. many minor fixes in bitmap/icon code


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4674 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin 1999-11-24 12:55:02 +00:00
parent 6d167489bd
commit 0d0512bd8f
21 changed files with 1021 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
distrib/msw/tmake/filelist.txt
View File

@ -230,6 +230,7 @@ fontutil.cpp M
frame.cpp M
gauge95.cpp M 32
gaugemsw.cpp M 16
gdiimage.cpp M
gdiobj.cpp M
helpwin.cpp M
icon.cpp M
@ -772,6 +773,7 @@ frame.h 9
gauge.h 9
gauge95.h 9
gaugemsw.h 9
gdiimage.h 9
gdiobj.h 9
helpwin.h 9
icon.h 9

190
include/wx/msw/gdiimage.h Normal file
View File

@ -0,0 +1,190 @@
///////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/gdiimage.h
// Purpose: wxGDIImage class: base class for wxBitmap, wxIcon, wxCursor
// under MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.11.99
// RCS-ID: $Id$
// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
// NB: this is a private header, it is not intended to be directly included by
// user code (but may be included from other, public, wxWin headers
#ifndef _WX_MSW_GDIIMAGE_H_
#define _WX_MSW_GDIIMAGE_H_
#ifdef __GNUG__
#pragma interface "gdiimage.h"
#endif
#include "wx/gdiobj.h" // base class
class WXDLLEXPORT wxGDIImageRefData;
class WXDLLEXPORT wxGDIImageHandler;
class WXDLLEXPORT wxGDIImage;
// ----------------------------------------------------------------------------
// wxGDIImageRefData: common data fields for all derived classes
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxGDIImageRefData : public wxGDIRefData
{
public:
wxGDIImageRefData()
{
m_width = m_height = m_depth = 0;
m_handle = 0;
#if WXWIN_COMPATIBILITY_2
m_ok = FALSE;
#endif // WXWIN_COMPATIBILITY_2
}
// accessors
bool IsOk() const { return m_handle != 0; }
void SetSize(int w, int h) { m_width = w; m_height = h; }
// free the ressources we allocated
virtual void Free() = 0;
// for compatibility, the member fields are public
// the size of the image
int m_width, m_height;
// the depth of the image
int m_depth;
// the handle to it
union
{
WXHANDLE m_handle; // for untyped access
WXHBITMAP m_hBitmap;
WXHICON m_hIcon;
WXHCURSOR m_hCursor;
};
// this filed is redundant and using it is error prone but keep it for
// backwards compatibility
#if WXWIN_COMPATIBILITY_2
void SetOk() { m_ok = m_handle != 0; }
bool m_ok;
#endif // WXWIN_COMPATIBILITY_2
};
// ----------------------------------------------------------------------------
// wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxGDIImageHandler : public wxObject
{
public:
// ctor
wxGDIImageHandler() { m_type = wxBITMAP_TYPE_INVALID; }
wxGDIImageHandler(const wxString& name,
const wxString& ext,
long type)
: m_name(name), m_extension(ext)
{
m_type = type;
}
// accessors
void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; }
void SetType(long type) { m_type = type; }
wxString GetName() const { return m_name; }
wxString GetExtension() const { return m_extension; }
long GetType() const { return m_type; }
// real handler operations: to implement in derived classes
virtual bool Create(wxGDIImage *image,
void *data,
long flags,
int width, int height, int depth = 1) = 0;
virtual bool Load(wxGDIImage *image,
const wxString& name,
long flags,
int desiredWidth, int desiredHeight) = 0;
virtual bool Save(wxGDIImage *image,
const wxString& name,
int type) = 0;
protected:
wxString m_name;
wxString m_extension;
long m_type;
};
// ----------------------------------------------------------------------------
// wxGDIImage: this class supports GDI image handlers which may be registered
// dynamically and will be used for loading/saving the images in the specified
// format. It also falls back to wxImage if no appropriate image is found.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxGDIImage : public wxGDIObject
{
public:
// handlers list interface
static wxList& GetHandlers() { return ms_handlers; }
static void AddHandler(wxGDIImageHandler *handler);
static void InsertHandler(wxGDIImageHandler *handler);
static bool RemoveHandler(const wxString& name);
static wxGDIImageHandler *FindHandler(const wxString& name);
static wxGDIImageHandler *FindHandler(const wxString& extension, long type);
static wxGDIImageHandler *FindHandler(long type);
static void InitStandardHandlers();
static void CleanUpHandlers();
// access to the ref data casted to the right type
wxGDIImageRefData *GetGDIImageData() const
{ return (wxGDIImageRefData *)m_refData; }
// create data if we don't have it yet
void EnsureHasData() { if ( IsNull() ) m_refData = CreateData(); }
// accessors
WXHANDLE GetHandle() const
{ return IsNull() ? 0 : GetGDIImageData()->m_handle; }
void SetHandle(WXHANDLE handle)
{ EnsureHasData(); GetGDIImageData()->m_handle = handle; }
bool Ok() const { return GetHandle() != 0; }
int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_width; }
int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_height; }
int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_depth; }
void SetWidth(int w) { EnsureHasData(); GetGDIImageData()->m_width = w; }
void SetHeight(int h) { EnsureHasData(); GetGDIImageData()->m_height = h; }
void SetDepth(int d) { EnsureHasData(); GetGDIImageData()->m_depth = d; }
void SetSize(int w, int h)
{
EnsureHasData();
GetGDIImageData()->SetSize(w, h);
}
void SetSize(const wxSize& size) { SetSize(size.x, size.y); }
// forward some of base class virtuals to wxGDIImageRefData
bool FreeResource(bool force = FALSE);
virtual WXHANDLE GetResourceHandle();
protected:
// create the data for the derived class here
virtual wxGDIImageRefData *CreateData() const = 0;
static wxList ms_handlers;
};
#endif // _WX_MSW_GDIIMAGE_H_

232
src/msw/cursor.cpp
View File

@ -9,271 +9,271 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "cursor.h"
#pragma implementation "cursor.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include <stdio.h>
#include "wx/setup.h"
#include "wx/list.h"
#include "wx/utils.h"
#include "wx/app.h"
#include "wx/cursor.h"
#include "wx/icon.h"
#include "wx/list.h"
#include "wx/utils.h"
#include "wx/app.h"
#include "wx/cursor.h"
#include "wx/icon.h"
#endif
#include "wx/msw/private.h"
#include "wx/msw/dib.h"
#include "assert.h"
#if wxUSE_RESOURCE_LOADING_IN_MSW
#include "wx/msw/curico.h"
#include "wx/msw/curicop.h"
#include "wx/msw/curico.h"
#include "wx/msw/curicop.h"
#endif
// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxCursorBase)
#endif
wxCursorRefData::wxCursorRefData(void)
// ----------------------------------------------------------------------------
// wxCursorRefData
// ----------------------------------------------------------------------------
wxCursorRefData::wxCursorRefData()
{
m_width = 32; m_height = 32;
m_hCursor = 0 ;
m_width = 32;
m_height = 32;
m_destroyCursor = FALSE;
}
wxCursorRefData::~wxCursorRefData(void)
void wxCursorRefData::Free()
{
if ( m_hCursor && m_destroyCursor)
#ifdef __WXWINE__
::DestroyCursor((HCURSOR) m_hCursor);
#else
::DestroyCursor((HICON) m_hCursor);
#endif
if ( m_hCursor && m_destroyCursor )
::DestroyCursor((HCURSOR)m_hCursor);
}
// ----------------------------------------------------------------------------
// Cursors
wxCursor::wxCursor(void)
// ----------------------------------------------------------------------------
wxCursor::wxCursor()
{
}
wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
wxCursor::wxCursor(const char WXUNUSED(bits)[],
int WXUNUSED(width),
int WXUNUSED(height),
int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY),
const char WXUNUSED(maskBits)[])
{
}
wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
wxCursor::wxCursor(const wxString& cursor_file,
long flags,
int hotSpotX, int hotSpotY)
{
m_refData = new wxCursorRefData;
wxCursorRefData *refData = new wxCursorRefData;
m_refData = refData;
M_CURSORDATA->m_destroyCursor = FALSE;
M_CURSORDATA->m_hCursor = 0;
M_CURSORDATA->m_ok = FALSE;
if (flags == wxBITMAP_TYPE_CUR_RESOURCE)
{
refData->m_destroyCursor = FALSE;
if (flags == wxBITMAP_TYPE_CUR_RESOURCE)
{
#ifdef __WIN95__
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, 0);
refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, 0);
#else
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), cursor_file);
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), cursor_file);
#endif
if (M_CURSORDATA->m_hCursor)
M_CURSORDATA->m_ok = TRUE;
else
M_CURSORDATA->m_ok = FALSE;
}
else if (flags == wxBITMAP_TYPE_CUR)
{
}
else if (flags == wxBITMAP_TYPE_CUR)
{
#ifdef __WIN95__
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
#else
#if wxUSE_RESOURCE_LOADING_IN_MSW
M_CURSORDATA->m_hCursor = (WXHCURSOR) ReadCursorFile(WXSTRINGCAST cursor_file, wxGetInstance(), &M_CURSORDATA->m_width, &M_CURSORDATA->m_height);
M_CURSORDATA->m_destroyCursor = TRUE;
refData->m_hCursor = (WXHCURSOR) ReadCursorFile(WXSTRINGCAST cursor_file, wxGetInstance(), &refData->m_width, &refData->m_height);
refData->m_destroyCursor = TRUE;
#endif
#endif
}
else if (flags == wxBITMAP_TYPE_ICO)
{
}
else if (flags == wxBITMAP_TYPE_ICO)
{
#if wxUSE_RESOURCE_LOADING_IN_MSW
M_CURSORDATA->m_hCursor = (WXHCURSOR) IconToCursor(WXSTRINGCAST cursor_file, wxGetInstance(), hotSpotX, hotSpotY, &M_CURSORDATA->m_width, &M_CURSORDATA->m_height);
M_CURSORDATA->m_destroyCursor = TRUE;
refData->m_hCursor = (WXHCURSOR) IconToCursor(WXSTRINGCAST cursor_file, wxGetInstance(), hotSpotX, hotSpotY, &refData->m_width, &refData->m_height);
refData->m_destroyCursor = TRUE;
#endif
}
else if (flags == wxBITMAP_TYPE_BMP)
{
}
else if (flags == wxBITMAP_TYPE_BMP)
{
#if wxUSE_RESOURCE_LOADING_IN_MSW
HBITMAP hBitmap = 0;
HPALETTE hPalette = 0;
bool success = wxReadDIB(WXSTRINGCAST cursor_file, &hBitmap, &hPalette) != 0;
if (!success)
return;
if (hPalette)
DeleteObject(hPalette);
POINT pnt;
pnt.x = hotSpotX;
pnt.y = hotSpotY;
M_CURSORDATA->m_hCursor = (WXHCURSOR) MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pnt);
M_CURSORDATA->m_destroyCursor = TRUE;
DeleteObject(hBitmap);
if (M_CURSORDATA->m_hCursor)
M_CURSORDATA->m_ok = TRUE;
HBITMAP hBitmap = 0;
HPALETTE hPalette = 0;
bool success = wxReadDIB(WXSTRINGCAST cursor_file, &hBitmap, &hPalette) != 0;
if (!success)
return;
if (hPalette)
DeleteObject(hPalette);
POINT pnt;
pnt.x = hotSpotX;
pnt.y = hotSpotY;
refData->m_hCursor = (WXHCURSOR) MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pnt);
refData->m_destroyCursor = TRUE;
DeleteObject(hBitmap);
#endif
}
}
#if WXWIN_COMPATIBILITY_2
refData->SetOk();
#endif // WXWIN_COMPATIBILITY_2
}
// Cursors by stock number
wxCursor::wxCursor(int cursor_type)
{
m_refData = new wxCursorRefData;
wxCursorRefData *refData = new wxCursorRefData;
m_refData = refData;
switch (cursor_type)
{
case wxCURSOR_WAIT:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_WAIT);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_WAIT);
break;
case wxCURSOR_IBEAM:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_IBEAM);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_IBEAM);
break;
case wxCURSOR_CROSS:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_CROSS);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_CROSS);
break;
case wxCURSOR_SIZENWSE:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENWSE);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENWSE);
break;
case wxCURSOR_SIZENESW:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENESW);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENESW);
break;
case wxCURSOR_SIZEWE:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZEWE);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZEWE);
break;
case wxCURSOR_SIZENS:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENS);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENS);
break;
case wxCURSOR_CHAR:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
case wxCURSOR_HAND:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_HAND"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_HAND"));
break;
}
case wxCURSOR_BULLSEYE:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BULLSEYE"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BULLSEYE"));
break;
}
case wxCURSOR_PENCIL:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PENCIL"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PENCIL"));
break;
}
case wxCURSOR_MAGNIFIER:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_MAGNIFIER"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_MAGNIFIER"));
break;
}
case wxCURSOR_NO_ENTRY:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_NO_ENTRY"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_NO_ENTRY"));
break;
}
case wxCURSOR_LEFT_BUTTON:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
case wxCURSOR_RIGHT_BUTTON:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
case wxCURSOR_MIDDLE_BUTTON:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
case wxCURSOR_SIZING:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_SIZING"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_SIZING"));
break;
}
case wxCURSOR_WATCH:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_WATCH"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_WATCH"));
break;
}
case wxCURSOR_SPRAYCAN:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_ROLLER"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_ROLLER"));
break;
}
case wxCURSOR_PAINT_BRUSH:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PBRUSH"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PBRUSH"));
break;
}
case wxCURSOR_POINT_LEFT:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PLEFT"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PLEFT"));
break;
}
case wxCURSOR_POINT_RIGHT:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PRIGHT"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PRIGHT"));
break;
}
case wxCURSOR_QUESTION_ARROW:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_QARROW"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_QARROW"));
break;
}
case wxCURSOR_BLANK:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BLANK"));
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BLANK"));
break;
}
default:
case wxCURSOR_ARROW:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
}
wxCursor::~wxCursor(void)
wxCursor::~wxCursor()
{
// FreeResource(TRUE);
}
bool wxCursor::FreeResource(bool WXUNUSED(force))
{
if (M_CURSORDATA && M_CURSORDATA->m_hCursor && M_CURSORDATA->m_destroyCursor)
{
DestroyCursor((HCURSOR) M_CURSORDATA->m_hCursor);
M_CURSORDATA->m_hCursor = 0;
}
return TRUE;
}
void wxCursor::SetHCURSOR(WXHCURSOR cursor)
{
if ( !M_CURSORDATA )
m_refData = new wxCursorRefData;
M_CURSORDATA->m_hCursor = cursor;
}
// ----------------------------------------------------------------------------
// Global cursor setting
// ----------------------------------------------------------------------------
void wxSetCursor(const wxCursor& cursor)
{
extern wxCursor *g_globalCursor;

2
src/msw/dib.cpp
View File

@ -731,7 +731,9 @@ bool wxLoadIntoBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette **pal)
bitmap->SetWidth(bm.bmWidth);
bitmap->SetHeight(bm.bmHeight);
bitmap->SetDepth(bm.bmPlanes * bm.bmBitsPixel);
#if WXWIN_COMPATIBILITY_2
bitmap->SetOk(TRUE);
#endif // WXWIN_COMPATIBILITY_2
return TRUE;
}
else return FALSE;

2
src/msw/frame.cpp
View File

@ -357,6 +357,8 @@ wxStatusBar *wxFrame::OnCreateStatusBar(int number,
if ( UsesNativeStatusBar() )
{
statusBar = new wxStatusBar95(this, id, style);
statusBar->SetFieldsCount(number);
}
else
#endif

503
src/msw/gdiimage.cpp Normal file
View File

@ -0,0 +1,503 @@
///////////////////////////////////////////////////////////////////////////////
// Name: msw/gdiimage.cpp
// Purpose: wxGDIImage implementation
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.11.99
// RCS-ID: $Id$
// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "gdiimage.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/string.h"
#endif // WX_PRECOMP
#include "wx/app.h"
#include "wx/msw/dib.h"
#include "wx/msw/gdiimage.h"
#include "wx/msw/private.h"
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
// 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)
class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler
{
public:
wxBMPFileHandler() : wxBitmapHandler(_T("Windows bitmap file"), _T("bmp"),
wxBITMAP_TYPE_BMP)
{
}
virtual bool LoadFile(wxBitmap *bitmap,
const wxString& name, long flags,
int desiredWidth, int desiredHeight);
virtual bool SaveFile(wxBitmap *bitmap,
const wxString& name, int type,
const wxPalette *palette = NULL);
private:
DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
};
class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
{
public:
wxBMPResourceHandler() : wxBitmapHandler(_T("Windows bitmap resource"),
wxEmptyString,
wxBITMAP_TYPE_BMP_RESOURCE)
{
}
virtual bool LoadFile(wxBitmap *bitmap,
const wxString& name, long flags,
int desiredWidth, int desiredHeight);
private:
DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
};
class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
{
public:
wxIconHandler(const wxString& name, const wxString& ext, long type)
: wxGDIImageHandler(name, ext, type)
{
}
// creating and saving icons is not supported
virtual bool Create(wxGDIImage *WXUNUSED(image),
void *WXUNUSED(data),
long WXUNUSED(flags),
int WXUNUSED(width),
int WXUNUSED(height),
int WXUNUSED(depth) = 1)
{
return FALSE;
}
virtual bool Save(wxGDIImage *WXUNUSED(image),
const wxString& WXUNUSED(name),
int WXUNUSED(type))
{
return FALSE;
}
virtual bool Load(wxGDIImage *image,
const wxString& name,
long flags,
int desiredWidth, int desiredHeight)
{
wxIcon *icon = wxDynamicCast(image, wxIcon);
wxCHECK_MSG( icon, FALSE, _T("wxIconHandler only works with icons") );
return LoadIcon(icon, name, flags, desiredWidth, desiredHeight);
}
protected:
virtual bool LoadIcon(wxIcon *icon,
const wxString& name, long flags,
int desiredWidth = -1, int desiredHeight = -1) = 0;
};
class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
{
public:
wxICOFileHandler() : wxIconHandler(_T("ICO icon file"),
_T("ico"),
wxBITMAP_TYPE_ICO)
{
}
virtual bool LoadIcon(wxIcon *icon,
const wxString& name, long flags,
int desiredWidth = -1, int desiredHeight = -1);
private:
DECLARE_DYNAMIC_CLASS(wxICOFileHandler)
};
class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
{
public:
wxICOResourceHandler() : wxIconHandler(_T("ICO resource"),
_T("ico"),
wxBITMAP_TYPE_ICO_RESOURCE)
{
}
virtual bool LoadIcon(wxIcon *icon,
const wxString& name, long flags,
int desiredWidth = -1, int desiredHeight = -1);
private:
DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
};
// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxGDIImageHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxGDIImageHandler)
#endif
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
static wxSize GetHiconSize(HICON hicon);
// ============================================================================
// implementation
// ============================================================================
wxList wxGDIImage::ms_handlers;
// ----------------------------------------------------------------------------
// wxGDIImage functions forwarded to wxGDIImageRefData
// ----------------------------------------------------------------------------
bool wxGDIImage::FreeResource(bool WXUNUSED(force))
{
if ( !IsNull() )
{
GetGDIImageData()->Free();
GetGDIImageData()->m_handle = 0;
}
return TRUE;
}
WXHANDLE wxGDIImage::GetResourceHandle()
{
return GetHandle();
}
// ----------------------------------------------------------------------------
// wxGDIImage handler stuff
// ----------------------------------------------------------------------------
void wxGDIImage::AddHandler(wxGDIImageHandler *handler)
{
ms_handlers.Append(handler);
}
void wxGDIImage::InsertHandler(wxGDIImageHandler *handler)
{
ms_handlers.Insert(handler);
}
bool wxGDIImage::RemoveHandler(const wxString& name)
{
wxGDIImageHandler *handler = FindHandler(name);
if ( handler )
{
ms_handlers.DeleteObject(handler);
return TRUE;
}
else
return FALSE;
}
wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& name)
{
wxNode *node = ms_handlers.First();
while ( node )
{
wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
if ( handler->GetName() == name )
return handler;
node = node->Next();
}
return NULL;
}
wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& extension,
long type)
{
wxNode *node = ms_handlers.First();
while ( node )
{
wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
if ( (handler->GetExtension() = extension) &&
(type == -1 || handler->GetType() == type) )
{
return handler;
}
node = node->Next();
}
return NULL;
}
wxGDIImageHandler *wxGDIImage::FindHandler(long type)
{
wxNode *node = ms_handlers.First();
while ( node )
{
wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
if ( handler->GetType() == type )
return handler;
node = node->Next();
}
return NULL;
}
void wxGDIImage::CleanUpHandlers()
{
wxNode *node = ms_handlers.First();
while ( node )
{
wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
wxNode *next = node->Next();
delete handler;
delete node;
node = next;
}
}
void wxGDIImage::InitStandardHandlers()
{
AddHandler(new wxBMPResourceHandler);
AddHandler(new wxBMPFileHandler);
// Not added by default: include xpmhand.h in your app
// and call these in your wxApp::OnInit.
// AddHandler(new wxXPMFileHandler);
// AddHandler(new wxXPMDataHandler);
AddHandler(new wxICOResourceHandler);
AddHandler(new wxICOFileHandler);
}
// ----------------------------------------------------------------------------
// wxBitmap handlers
// ----------------------------------------------------------------------------
bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap,
const wxString& name, long WXUNUSED(flags),
int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight))
{
// 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("GetObject(HBITMAP)");
}
data->m_width = bm.bmWidth;
data->m_height = bm.bmHeight;
data->m_depth = bm.bmBitsPixel;
}
else
{
// it's probably not found
wxLogError(wxT("Can't load bitmap '%s' from resources! Check .rc file."),
name.c_str());
}
return bitmap->Ok();
}
bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap,
const wxString& name, long WXUNUSED(flags),
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);
}
// it was copied by the bitmap if it was loaded successfully
delete palette;
return success;
#else
return FALSE;
#endif
}
bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap,
const wxString& name,
int WXUNUSED(type),
const wxPalette *pal)
{
#if wxUSE_IMAGE_LOADING_IN_MSW
wxPalette *actualPalette = (wxPalette *)pal;
if ( !actualPalette )
actualPalette = bitmap->GetPalette();
return wxSaveBitmap(WXSTRINGCAST name, bitmap, actualPalette) != 0;
#else
return FALSE;
#endif
}
// ----------------------------------------------------------------------------
// wxIcon handlers
// ----------------------------------------------------------------------------
bool wxICOFileHandler::LoadIcon(wxIcon *icon,
const wxString& name,
long flags,
int desiredWidth, int desiredHeight)
{
#if wxUSE_RESOURCE_LOADING_IN_MSW
icon->UnRef();
// actual size
wxSize size;
#ifdef __WIN32__
HICON hicon = ::ExtractIcon(wxGetInstance(), name, 0 /* first */);
if ( !hicon )
{
wxLogSysError(_T("Failed to load icon from the file '%s'"),
name.c_str());
return FALSE;
}
size = GetHiconSize(hicon);
#else // Win16
HICON hicon = ReadIconFile((wxChar *)name.c_str(),
wxGetInstance(),
&size.x, &size.y);
#endif // Win32/Win16
if ( (desiredWidth != -1 && desiredWidth != size.x) ||
(desiredHeight != -1 && desiredHeight != size.y) )
{
wxLogDebug(_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;
}
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,
int desiredWidth, int desiredHeight)
{
HICON hicon;
#if defined(__WIN32__) && !defined(__SC__)
if ( desiredWidth != -1 && desiredHeight != -1 )
{
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 )
{
icon->SetSize(desiredWidth, desiredHeight);
}
icon->SetHICON((WXHICON)hicon);
return icon->Ok();
}
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
static wxSize GetHiconSize(HICON hicon)
{
wxSize size(32, 32); // default
#ifdef __WIN32__
// Win32s doesn't have GetIconInfo function...
if ( hicon && wxGetOsVersion() != wxWIN32S )
{
ICONINFO info;
if ( !::GetIconInfo(hicon, &info) )
{
wxLogLastError("GetIconInfo");
}
else
{
HBITMAP hbmp = info.hbmMask;
if ( hbmp )
{
BITMAP bm;
if ( ::GetObject(hbmp, sizeof(BITMAP), (LPSTR) &bm) )
{
size = wxSize(bm.bmWidth, bm.bmHeight);
}
::DeleteObject(info.hbmMask);
}
if ( info.hbmColor )
::DeleteObject(info.hbmColor);
}
}
#endif
return size;
}

188
src/msw/icon.cpp
View File

@ -1,189 +1,111 @@
/////////////////////////////////////////////////////////////////////////////
// Name: icon.cpp
// Name: msw/icon.cpp
// Purpose: wxIcon class
// Author: Julian Smart
// Modified by:
// Modified by: 20.11.99 (VZ): don't derive from wxBitmap any more
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "icon.h"
#pragma implementation "icon.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include <stdio.h>
#include "wx/setup.h"
#include "wx/list.h"
#include "wx/utils.h"
#include "wx/app.h"
#include "wx/icon.h"
#include "wx/defs.h"
#include "wx/list.h"
#include "wx/utils.h"
#include "wx/app.h"
#include "wx/icon.h"
#endif
#include "wx/msw/private.h"
#include "assert.h"
#if wxUSE_RESOURCE_LOADING_IN_MSW
#include "wx/msw/curico.h"
#include "wx/msw/curicop.h"
#include "wx/msw/curico.h"
#include "wx/msw/curicop.h"
#endif
// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxIconBase)
#endif
/*
* Icons
*/
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxIconRefData
// ----------------------------------------------------------------------------
wxIconRefData::wxIconRefData(void)
void wxIconRefData::Free()
{
m_hIcon = (WXHICON) NULL ;
if ( m_hIcon )
::DestroyIcon((HICON) m_hIcon);
}
wxIconRefData::~wxIconRefData(void)
{
if ( m_hIcon )
::DestroyIcon((HICON) m_hIcon);
}
// ----------------------------------------------------------------------------
// wxIcon
// ----------------------------------------------------------------------------
wxIcon::wxIcon(void)
wxIcon::wxIcon()
{
}
wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height))
wxIcon::wxIcon(const char WXUNUSED(bits)[],
int WXUNUSED(width),
int WXUNUSED(height))
{
}
wxIcon::wxIcon(const wxString& icon_file, long flags,
int desiredWidth, int desiredHeight)
wxIcon::wxIcon(const wxString& iconfile,
long flags,
int desiredWidth,
int desiredHeight)
{
LoadFile(icon_file, flags, desiredWidth, desiredHeight);
LoadFile(iconfile, flags, desiredWidth, desiredHeight);
}
wxIcon::~wxIcon(void)
wxIcon::~wxIcon()
{
}
bool wxIcon::FreeResource(bool force)
bool wxIcon::LoadFile(const wxString& filename,
long type,
int desiredWidth, int desiredHeight)
{
if (M_ICONDATA && M_ICONDATA->m_hIcon)
{
DestroyIcon((HICON) M_ICONDATA->m_hIcon);
M_ICONDATA->m_hIcon = (WXHICON) NULL;
}
return TRUE;
}
UnRef();
bool wxIcon::LoadFile(const wxString& filename, long type,
int desiredWidth, int desiredHeight)
{
UnRef();
wxGDIImageHandler *handler = FindHandler(type);
m_refData = new wxIconRefData;
wxBitmapHandler *handler = FindHandler(type);
if ( handler )
return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
else
return FALSE;
}
void wxIcon::SetHICON(WXHICON ico)
{
if ( !M_ICONDATA )
m_refData = new wxIconRefData;
M_ICONDATA->m_hIcon = ico;
}
bool wxICOFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
#if wxUSE_RESOURCE_LOADING_IN_MSW
if ( bitmap->IsKindOf(CLASSINFO(wxIcon)) )
{
wxIcon *icon = (wxIcon *)bitmap;
wxIconRefData *data = (wxIconRefData *)icon->GetRefData();
data->m_hIcon = (WXHICON)ReadIconFile((wxChar *)name.c_str(), wxGetInstance(),
&data->m_width, &data->m_height);
data->m_ok = data->m_hIcon != 0;
return data->m_ok;
}
else
return FALSE;
#else
return FALSE;
#endif
}
bool wxICOResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
if ( bitmap->IsKindOf(CLASSINFO(wxIcon)) )
{
#if defined(__WIN32__) && !defined(__SC__)
if (desiredWidth > -1 && desiredHeight > -1)
if ( !handler )
{
M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadImage(wxGetInstance(), name, IMAGE_ICON, desiredWidth, desiredHeight, LR_DEFAULTCOLOR);
}
else
#endif
{
M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadIcon(wxGetInstance(), name);
// say something?
return FALSE;
}
#ifdef __WIN32__
// Win32s doesn't have GetIconInfo function...
if (M_ICONHANDLERDATA->m_hIcon && wxGetOsVersion()!=wxWIN32S)
{
ICONINFO info ;
if (::GetIconInfo((HICON) M_ICONHANDLERDATA->m_hIcon, &info))
{
HBITMAP ms_bitmap = info.hbmMask ;
if (ms_bitmap)
{
BITMAP bm;
::GetObject(ms_bitmap, sizeof(BITMAP), (LPSTR) &bm);
M_ICONHANDLERDATA->m_width = bm.bmWidth;
M_ICONHANDLERDATA->m_height = bm.bmHeight;
}
if (info.hbmMask)
::DeleteObject(info.hbmMask) ;
if (info.hbmColor)
::DeleteObject(info.hbmColor) ;
}
}
#else
M_ICONHANDLERDATA->m_width = 32;
M_ICONHANDLERDATA->m_height = 32;
#endif
// Override the found values with desired values
if (desiredWidth > -1 && desiredHeight > -1)
{
M_ICONHANDLERDATA->m_width = desiredWidth;
M_ICONHANDLERDATA->m_height = desiredHeight;
}
M_ICONHANDLERDATA->m_ok = (M_ICONHANDLERDATA->m_hIcon != 0);
return M_ICONHANDLERDATA->m_ok;
}
else
return FALSE;
return handler->Load(this, filename, type, desiredWidth, desiredHeight);
}

5
src/msw/makefile.b32
View File

@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 14:56, 1999/11/15
# This file was automatically generated by tmake at 13:22, 1999/11/24
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE B32.T!
#
@ -245,6 +245,7 @@ MSWOBJS = $(MSWDIR)\accel.obj \
$(MSWDIR)\fontutil.obj \
$(MSWDIR)\frame.obj \
$(MSWDIR)\gauge95.obj \
$(MSWDIR)\gdiimage.obj \
$(MSWDIR)\gdiobj.obj \
$(MSWDIR)\gsocket.obj \
$(MSWDIR)\helpwin.obj \
@ -446,6 +447,8 @@ $(MSWDIR)\frame.obj: $(MSWDIR)\frame.$(SRCSUFF)
$(MSWDIR)\gauge95.obj: $(MSWDIR)\gauge95.$(SRCSUFF)
$(MSWDIR)\gdiimage.obj: $(MSWDIR)\gdiimage.$(SRCSUFF)
$(MSWDIR)\gdiobj.obj: $(MSWDIR)\gdiobj.$(SRCSUFF)
$(MSWDIR)\gsocket.obj: $(MSWDIR)\gsocket.c

5
src/msw/makefile.bcc
View File

@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 14:24, 1999/11/15
# This file was automatically generated by tmake at 13:22, 1999/11/24
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE BCC.T!
#
@ -215,6 +215,7 @@ MSWOBJS = $(MSWDIR)\accel.obj \
$(MSWDIR)\fontutil.obj \
$(MSWDIR)\frame.obj \
$(MSWDIR)\gaugemsw.obj \
$(MSWDIR)\gdiimage.obj \
$(MSWDIR)\gdiobj.obj \
$(MSWDIR)\gsocket.obj \
$(MSWDIR)\helpwin.obj \
@ -360,6 +361,8 @@ $(MSWDIR)\frame.obj: $(MSWDIR)\frame.$(SRCSUFF)
$(MSWDIR)\gaugemsw.obj: $(MSWDIR)\gaugemsw.$(SRCSUFF)
$(MSWDIR)\gdiimage.obj: $(MSWDIR)\gdiimage.$(SRCSUFF)
$(MSWDIR)\gdiobj.obj: $(MSWDIR)\gdiobj.$(SRCSUFF)
$(MSWDIR)\gsocket.obj: $(MSWDIR)\gsocket.c

8
src/msw/makefile.dos
View File

@ -1,4 +1,4 @@
# This file was automatically generated by tmake at 14:24, 1999/11/15
# This file was automatically generated by tmake at 13:22, 1999/11/24
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE DOS.T!
#
@ -204,6 +204,7 @@ MSWOBJS1 = $(MSWDIR)\accel.obj \
$(MSWDIR)\fontutil.obj \
$(MSWDIR)\frame.obj \
$(MSWDIR)\gaugemsw.obj \
$(MSWDIR)\gdiimage.obj \
$(MSWDIR)\gdiobj.obj \
$(MSWDIR)\gsocket.obj \
$(MSWDIR)\helpwin.obj \
@ -498,6 +499,11 @@ $(MSWDIR)/gaugemsw.obj: $*.$(SRCSUFF)
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
<<
$(MSWDIR)/gdiimage.obj: $*.$(SRCSUFF)
cl @<<
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
<<
$(MSWDIR)/gdiobj.obj: $*.$(SRCSUFF)
cl @<<
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)

3
src/msw/makefile.g95
View File

@ -1,4 +1,4 @@
# This file was automatically generated by tmake at 14:24, 1999/11/15
# This file was automatically generated by tmake at 13:22, 1999/11/24
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE G95.T!
#
@ -224,6 +224,7 @@ MSWOBJS = \
$(MSWDIR)/fontutil.$(OBJSUFF) \
$(MSWDIR)/frame.$(OBJSUFF) \
$(MSWDIR)/gauge95.$(OBJSUFF) \
$(MSWDIR)/gdiimage.$(OBJSUFF) \
$(MSWDIR)/gdiobj.$(OBJSUFF) \
$(MSWDIR)/gsocket.$(OBJSUFF) \
$(MSWDIR)/helpwin.$(OBJSUFF) \

3
src/msw/makefile.sc
View File

@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 14:24, 1999/11/15
# This file was automatically generated by tmake at 13:22, 1999/11/24
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE SC.T!
# Symantec C++ makefile for the msw objects
@ -184,6 +184,7 @@ MSWOBJS = $(MSWDIR)\accel.obj \
$(MSWDIR)\frame.obj \
$(MSWDIR)\gauge95.obj \
$(MSWDIR)\gaugemsw.obj \
$(MSWDIR)\gdiimage.obj \
$(MSWDIR)\gdiobj.obj \
$(MSWDIR)\gsocket.obj \
$(MSWDIR)\helpwin.obj \

3
src/msw/makefile.vc
View File

@ -1,4 +1,4 @@
# This file was automatically generated by tmake at 10:51, 1999/11/24
# This file was automatically generated by tmake at 13:22, 1999/11/24
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE VC.T!
# File: makefile.vc
@ -262,6 +262,7 @@ MSWOBJS = ..\msw\$D\accel.obj \
..\msw\$D\fontutil.obj \
..\msw\$D\frame.obj \
..\msw\$D\gauge95.obj \
..\msw\$D\gdiimage.obj \
..\msw\$D\gdiobj.obj \
..\msw\$D\gsocket.obj \
..\msw\$D\helpwin.obj \

6
src/msw/makefile.wat
View File

@ -1,6 +1,6 @@
#!/binb/wmake.exe
# This file was automatically generated by tmake at 14:24, 1999/11/15
# This file was automatically generated by tmake at 13:22, 1999/11/24
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE WAT.T!
#
@ -217,6 +217,7 @@ MSWOBJS = accel.obj &
frame.obj &
gauge95.obj &
gaugemsw.obj &
gdiimage.obj &
gdiobj.obj &
gsocket.obj &
helpwin.obj &
@ -422,6 +423,9 @@ gauge95.obj: $(MSWDIR)\gauge95.cpp
gaugemsw.obj: $(MSWDIR)\gaugemsw.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<
gdiimage.obj: $(MSWDIR)\gdiimage.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<
gdiobj.obj: $(MSWDIR)\gdiobj.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<

49
src/msw/ole/dataobj.cpp
View File

@ -18,26 +18,27 @@
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "dataobj.h"
#pragma implementation "dataobj.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#if defined(__BORLANDC__)
#pragma hdrstop
#pragma hdrstop
#endif
#if defined(__WIN32__) && !defined(__GNUWIN32_OLD__)
#ifndef WX_PRECOMP
#include "wx/intl.h"
#include "wx/intl.h"
#include "wx/log.h"
#endif
#include "wx/defs.h"
#if defined(__WIN32__) && !defined(__GNUWIN32__) || defined(wxUSE_NORLANDER_HEADERS)
#include "wx/log.h"
#include "wx/dataobj.h"
#include <windows.h>
#include "wx/msw/private.h" // includes <windows.h>
#ifdef wxUSE_NORLANDER_HEADERS
#include <ole2.h>
#endif
@ -50,7 +51,9 @@
#include <shlobj.h>
#include "wx/msw/ole/oleutils.h"
#include "wx/msw/ole/oleutils.h"
#include "wx/msw/dib.h"
// ----------------------------------------------------------------------------
// functions
@ -62,10 +65,6 @@
#define GetTymedName(tymed) ""
#endif // Debug/!Debug
// to be moved into wx/msw/bitmap.h
extern size_t wxConvertBitmapToDIB(BITMAPINFO *pbi, const wxBitmap& bitmap);
extern wxBitmap wxConvertDIBToBitmap(const BITMAPINFO *bmi);
// ----------------------------------------------------------------------------
// wxIEnumFORMATETC interface implementation
// ----------------------------------------------------------------------------
@ -124,22 +123,6 @@ private:
bool m_mustDelete;
};
// ----------------------------------------------------------------------------
// small helper class for getting screen DC (we're working with bitmaps and
// DIBs here)
// ----------------------------------------------------------------------------
class ScreenHDC
{
public:
ScreenHDC() { m_hdc = GetDC(NULL); }
~ScreenHDC() { ReleaseDC(NULL, m_hdc); }
operator HDC() const { return m_hdc; }
private:
HDC m_hdc;
};
// ============================================================================
// implementation
// ============================================================================
@ -736,12 +719,12 @@ size_t wxBitmapDataObject::GetDataSize() const
bool wxBitmapDataObject::GetDataHere(void *buf) const
{
return wxConvertBitmapToDIB((BITMAPINFO *)buf, GetBitmap()) != 0;
return wxConvertBitmapToDIB((LPBITMAPINFO)buf, GetBitmap()) != 0;
}
bool wxBitmapDataObject::SetData(size_t len, const void *buf)
{
wxBitmap bitmap(wxConvertDIBToBitmap((const BITMAPINFO *)buf));
wxBitmap bitmap(wxConvertDIBToBitmap((const LPBITMAPINFO)buf));
if ( !bitmap.Ok() ) {
wxFAIL_MSG(wxT("pasting/dropping invalid bitmap"));
@ -1065,7 +1048,7 @@ static size_t wxGetNumOfBitmapColors(size_t bitsPerPixel)
}
}
size_t wxConvertBitmapToDIB(BITMAPINFO *pbi, const wxBitmap& bitmap)
size_t wxConvertBitmapToDIB(LPBITMAPINFO pbi, const wxBitmap& bitmap)
{
wxASSERT_MSG( bitmap.Ok(), wxT("invalid bmp can't be converted to DIB") );
@ -1139,7 +1122,7 @@ size_t wxConvertBitmapToDIB(BITMAPINFO *pbi, const wxBitmap& bitmap)
return dwLen + bi.biSizeImage;
}
wxBitmap wxConvertDIBToBitmap(const BITMAPINFO *pbmi)
wxBitmap wxConvertDIBToBitmap(const LPBITMAPINFO pbmi)
{
// here we get BITMAPINFO struct followed by the actual bitmap bits and
// BITMAPINFO starts with BITMAPINFOHEADER followed by colour info

3
src/msw/pnghand.cpp
View File

@ -313,8 +313,9 @@ bool wxPNGReader::InstantiateBitmap(wxBitmap *bitmap)
bitmap->SetDepth(GetDepth());
if ( GetDepth() > 1 && Palette )
bitmap->SetPalette(*Palette);
#if WXWIN_COMPATIBILITY_2
bitmap->SetOk(TRUE);
#endif // WXWIN_COMPATIBILITY_2
// Make a mask if appropriate
if ( bgindex > -1 )

43
src/msw/statbmp.cpp
View File

@ -55,7 +55,7 @@
// ---------------------------------------------------------------------------
bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
const wxBitmap& bitmap,
const wxGDIImage& bitmap,
const wxPoint& pos,
const wxSize& size,
long style,
@ -108,7 +108,7 @@ bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
wxCHECK_MSG( m_hWnd, FALSE, wxT("Failed to create static bitmap") );
SetBitmap(bitmap);
SetImage(bitmap);
// Subclass again for purposes of dialog editing mode
SubclassWin(m_hWnd);
@ -122,22 +122,14 @@ bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
bool wxStaticBitmap::ImageIsOk() const
{
if ( m_isIcon && m_image.icon )
return m_image.icon->Ok();
else if ( m_image.bitmap )
return m_image.bitmap->Ok();
else
return FALSE;
return m_image && m_image->Ok();
}
void wxStaticBitmap::Free()
{
if ( m_isIcon )
delete m_image.icon;
else
delete m_image.bitmap;
delete m_image;
m_image.icon = NULL;
m_image = NULL;
}
wxSize wxStaticBitmap::DoGetBestSize() const
@ -147,15 +139,15 @@ wxSize wxStaticBitmap::DoGetBestSize() const
return wxWindow::DoGetBestSize();
}
void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
void wxStaticBitmap::SetImage(const wxGDIImage& bitmap)
{
Free();
m_isIcon = bitmap.IsKindOf(CLASSINFO(wxIcon));
if ( m_isIcon )
m_image.icon = new wxIcon((const wxIcon&)bitmap);
m_image = new wxIcon((const wxIcon&)bitmap);
else
m_image.bitmap = new wxBitmap(bitmap);
m_image = new wxBitmap((const wxBitmap &)bitmap);
int x, y;
int w, h;
@ -163,9 +155,8 @@ void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
GetSize(&w, &h);
#ifdef __WIN32__
HANDLE handle = m_isIcon ? (HANDLE)m_image.icon->GetHICON()
: (HANDLE)m_image.bitmap->GetHBITMAP();
::SendMessage((HWND)m_hWnd, STM_SETIMAGE,
HANDLE handle = (HANDLE)m_image->GetHandle();
::SendMessage(GetHwnd(), STM_SETIMAGE,
m_isIcon ? IMAGE_ICON : IMAGE_BITMAP, (LPARAM)handle);
#endif // Win32
@ -178,16 +169,16 @@ void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
w = width;
h = height;
::MoveWindow((HWND)GetHWND(), x, y, width, height, FALSE);
::MoveWindow(GetHwnd(), x, y, width, height, FALSE);
}
}
RECT rect ;
rect.left = x ;
rect.top = y ;
rect.right = x + w ;
rect.bottom = y + h ;
InvalidateRect((HWND)GetParent()->GetHWND(), &rect, TRUE);
RECT rect;
rect.left = x;
rect.top = y;
rect.right = x + w;
rect.bottom = y + h;
InvalidateRect(GetHwndOf(GetParent()), &rect, TRUE);
}
// under Win32 we use the standard static control style for this

35
src/msw/textctrl.cpp
View File

@ -57,7 +57,7 @@
# include <fstream>
#endif
#if wxUSE_RICHEDIT && (!defined(__GNUWIN32__) || defined(wxUSE_NORLANDER_HEADERS))
#if wxUSE_RICHEDIT
#include <richedit.h>
#endif
@ -115,8 +115,6 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
if ( !CreateBase(parent, id, pos, size, style, validator, name) )
return FALSE;
// Validator was set in CreateBase
//SetValidator(validator);
if ( parent )
parent->AddChild(this);
@ -130,7 +128,7 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
{
wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
wxT("wxTE_PROCESS_ENTER style is ignored for multiline "
"text controls (they always process it)") );
"text controls (they always process it)") );
msStyle |= ES_MULTILINE | ES_WANTRETURN;
if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
@ -172,9 +170,32 @@ bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
#if wxUSE_RICHEDIT
if ( m_windowStyle & wxTE_RICH )
{
msStyle |= ES_AUTOVSCROLL;
m_isRich = TRUE;
windowClass = wxT("RICHEDIT");
static bool s_errorGiven = FALSE; // MT-FIXME
// only give the error msg once if the DLL can't be loaded
if ( !s_errorGiven )
{
// first try to load the RichEdit DLL (will do nothing if already
// done)
if ( !wxTheApp->InitRichEdit() )
{
wxLogError(_("Impossible to create a rich edit control, "
"using simple text control instead."));
s_errorGiven = TRUE;
}
}
if ( s_errorGiven )
{
m_isRich = FALSE;
}
else
{
msStyle |= ES_AUTOVSCROLL;
m_isRich = TRUE;
windowClass = wxT("RICHEDIT");
}
}
else
m_isRich = FALSE;

34
src/msw/thread.cpp
View File

@ -31,9 +31,7 @@
#if wxUSE_THREADS
#include <stdio.h>
#include <windows.h>
#include "wx/msw/private.h"
#include "wx/module.h"
#include "wx/thread.h"
@ -84,6 +82,7 @@ static bool s_waitingForThread = FALSE;
// ----------------------------------------------------------------------------
// wxMutex implementation
// ----------------------------------------------------------------------------
class wxMutexInternal
{
public:
@ -237,42 +236,27 @@ void wxCondition::Broadcast()
// wxCriticalSection implementation
// ----------------------------------------------------------------------------
class wxCriticalSectionInternal
{
public:
// init the critical section object
wxCriticalSectionInternal()
{ ::InitializeCriticalSection(&m_data); }
// implicit cast to the associated data
operator CRITICAL_SECTION *() { return &m_data; }
// free the associated ressources
~wxCriticalSectionInternal()
{ ::DeleteCriticalSection(&m_data); }
private:
CRITICAL_SECTION m_data;
};
wxCriticalSection::wxCriticalSection()
{
m_critsect = new wxCriticalSectionInternal;
wxASSERT_MSG( sizeof(CRITICAL_SECTION) == sizeof(m_buffer),
_T("must increase buffer size in wx/thread.h") );
::InitializeCriticalSection((CRITICAL_SECTION *)m_buffer);
}
wxCriticalSection::~wxCriticalSection()
{
delete m_critsect;
::DeleteCriticalSection((CRITICAL_SECTION *)m_buffer);
}
void wxCriticalSection::Enter()
{
::EnterCriticalSection(*m_critsect);
::EnterCriticalSection((CRITICAL_SECTION *)m_buffer);
}
void wxCriticalSection::Leave()
{
::LeaveCriticalSection(*m_critsect);
::LeaveCriticalSection((CRITICAL_SECTION *)m_buffer);
}
// ----------------------------------------------------------------------------

5
src/msw/window.cpp
View File

@ -1841,8 +1841,9 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
short y = HIWORD(lParam);
processed = HandleMouseMove(x, y, wParam);
break;
}
}
break;
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_LBUTTONDBLCLK:

99
src/msw/xpmhand.cpp
View File

@ -45,6 +45,25 @@
#include "wx/xpmhand.h"
#include "wx/msw/dib.h"
static void XpmToBitmap(wxBitmap *bitmap,
const XImage *ximage,
const XpmAttributes& xpmAttr)
{
wxBitmapRefData *refData = bitmap->GetBitmapData();
refData->m_hBitmap = (WXHBITMAP)ximage->bitmap;
BITMAP bm;
if ( !::GetObject(GetHbitmapOf(*bitmap), sizeof(bm), (LPSTR) & bm) )
{
wxLogLastError("GetObject(bitmap)");
}
refData->m_width = bm.bmWidth;
refData->m_height = bm.bmHeight;
refData->m_depth = bm.bmPlanes * bm.bmBitsPixel;
refData->m_numColors = xpmAttr.npixels;
}
IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
@ -55,7 +74,6 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long fla
XpmAttributes xpmAttr;
HDC dc;
M_BITMAPHANDLERDATA->m_ok = FALSE;
dc = CreateCompatibleDC(NULL);
if (dc)
{
@ -64,26 +82,17 @@ bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long fla
DeleteDC(dc);
if (errorStatus == XpmSuccess)
{
M_BITMAPHANDLERDATA->m_hBitmap = (WXHBITMAP) ximage->bitmap;
XpmToBitmap(bitmap, ximage, xpmAttr);
BITMAP bm;
GetObject((HBITMAP)M_BITMAPHANDLERDATA->m_hBitmap, sizeof(bm), (LPSTR) & bm);
M_BITMAPHANDLERDATA->m_width = (bm.bmWidth);
M_BITMAPHANDLERDATA->m_height = (bm.bmHeight);
M_BITMAPHANDLERDATA->m_depth = (bm.bmPlanes * bm.bmBitsPixel);
M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
XpmFreeAttributes(&xpmAttr);
XImageFree(ximage);
}
M_BITMAPHANDLERDATA->m_ok = TRUE;
return TRUE;
}
else
{
M_BITMAPHANDLERDATA->m_ok = FALSE;
return FALSE;
}
#if WXWIN_COMPATIBILITY_2
bitmap->SetOk(errorStatus == XpmSuccess);
#endif // WXWIN_COMPATIBILITY_2
return bitmap->Ok();
}
#endif
@ -94,26 +103,28 @@ bool wxXPMFileHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type
{
#if wxUSE_XPM_IN_MSW
HDC dc = NULL;
XImage ximage;
dc = CreateCompatibleDC(NULL);
if (dc)
{
if (SelectObject(dc, (HBITMAP) M_BITMAPHANDLERDATA->m_hBitmap))
if ( SelectObject(dc, GetHbitmapOf(*bitmap)) )
{
/* for following SetPixel */
/* fill the XImage struct 'by hand' */
ximage.width = M_BITMAPHANDLERDATA->m_width;
ximage.height = M_BITMAPHANDLERDATA->m_height;
ximage.depth = M_BITMAPHANDLERDATA->m_depth;
ximage.bitmap = (HBITMAP)M_BITMAPHANDLERDATA->m_hBitmap;
wxBitmapRefData *refData = bitmap->GetBitmapData();
ximage.width = refData->m_width;
ximage.height = refData->m_height;
ximage.depth = refData->m_depth;
ximage.bitmap = (HBITMAP)refData->m_hBitmap;
int errorStatus = XpmWriteFileFromImage(&dc, wxMBSTRINGCAST name.fn_str(),
&ximage, (XImage *) NULL, (XpmAttributes *) NULL);
&ximage, (XImage *) NULL,
(XpmAttributes *) NULL);
if (dc)
DeleteDC(dc);
if (errorStatus == XpmSuccess)
return TRUE; /* no error */
else
@ -135,45 +146,35 @@ bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *data, long flags, int widt
XpmAttributes xpmAttr;
HDC dc;
M_BITMAPHANDLERDATA->m_ok = FALSE;
M_BITMAPHANDLERDATA->m_numColors = 0;
dc = CreateCompatibleDC(NULL); /* memory DC */
if (dc)
{
xpmAttr.valuemask = XpmReturnInfos; /* get infos back */
ErrorStatus = XpmCreateImageFromData(&dc, (char **)data,
&ximage, (XImage **) NULL, &xpmAttr);
&ximage, (XImage **) NULL, &xpmAttr);
if (ErrorStatus == XpmSuccess)
{
/* ximage is malloced and contains bitmap and attributes */
M_BITMAPHANDLERDATA->m_hBitmap = (WXHBITMAP) ximage->bitmap;
XpmToBitmap(bitmap, ximage, xpmAttr);
BITMAP bm;
GetObject((HBITMAP) M_BITMAPHANDLERDATA->m_hBitmap, sizeof(bm), (LPSTR) & bm);
M_BITMAPHANDLERDATA->m_width = (bm.bmWidth);
M_BITMAPHANDLERDATA->m_height = (bm.bmHeight);
M_BITMAPHANDLERDATA->m_depth = (bm.bmPlanes * bm.bmBitsPixel);
M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
XpmFreeAttributes(&xpmAttr);
XImageFree(ximage); // releases the malloc, but does not detroy
// the bitmap
M_BITMAPHANDLERDATA->m_ok = TRUE;
DeleteDC(dc);
return TRUE;
}
}
else
{
M_BITMAPHANDLERDATA->m_ok = FALSE;
// XpmDebugError(ErrorStatus, NULL);
DeleteDC(dc);
return FALSE;
// XpmDebugError(ErrorStatus, NULL);
}
DeleteDC(dc);
#if WXWIN_COMPATIBILITY_2
bitmap->SetOk(errorStatus == XpmSuccess);
#endif // WXWIN_COMPATIBILITY_2
return bitmap->Ok();
}
#endif