Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

big wxCursor cleanup

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@19058 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2003-02-02 02:06:34 +00:00
parent 62a0bb2788
commit eff4ffbf4f
2 changed files with 316 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

554
src/msw/cursor.cpp
View File

@@ -1,12 +1,12 @@
/////////////////////////////////////////////////////////////////////////////
// Name: cursor.cpp
// Name: src/msw/cursor.cpp
// Purpose: wxCursor class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows licence
// Copyright: (c) 1997-2003 Julian Smart and Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
@@ -37,11 +37,14 @@
#include "wx/cursor.h"
#endif
#include "wx/ptr_scpd.h"
#include "wx/module.h"
#include "wx/image.h"
#include "wx/msw/private.h"
#ifndef __WXMICROWIN__
#include "wx/msw/dib.h"
#include "wx/msw/dib.h"
#endif
#if wxUSE_RESOURCE_LOADING_IN_MSW
@@ -49,6 +52,41 @@
#include "wx/msw/curicop.h"
#endif
// define functions missing in MicroWin
#ifdef __WXMICROWIN__
static inline void DestroyCursor(HCURSOR) { }
static inline void SetCursor(HCURSOR) { }
#endif // __WXMICROWIN__
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxCursorRefData : public wxGDIImageRefData
{
public:
// the second parameter is used to tell us to delete the cursor when we're
// done with it (normally we shouldn't call DestroyCursor() this is why it
// doesn't happen by default)
wxCursorRefData(HCURSOR hcursor = 0, bool takeOwnership = false);
virtual ~wxCursorRefData() { Free(); }
virtual void Free();
// return the size of the standard cursor: notice that the system only
// supports the cursors of this size
static wxCoord GetStandardWidth();
static wxCoord GetStandardHeight();
private:
bool m_destroyCursor;
// standard cursor size, computed on first use
static wxSize ms_sizeStd;
};
// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------
@@ -84,6 +122,13 @@ public:
}
};
// ----------------------------------------------------------------------------
// other types
// ----------------------------------------------------------------------------
wxDECLARE_SCOPED_ARRAY(unsigned char, ByteArray);
wxDEFINE_SCOPED_ARRAY(unsigned char, ByteArray);
// ============================================================================
// implementation
// ============================================================================
@@ -92,22 +137,43 @@ public:
// wxCursorRefData
// ----------------------------------------------------------------------------
wxCursorRefData::wxCursorRefData()
{
m_width = 32;
m_height = 32;
wxSize wxCursorRefData::ms_sizeStd;
m_destroyCursor = TRUE;
wxCoord wxCursorRefData::GetStandardWidth()
{
if ( !ms_sizeStd.x )
ms_sizeStd.x = wxSystemSettings::GetMetric(wxSYS_CURSOR_X);
return ms_sizeStd.x;
}
wxCoord wxCursorRefData::GetStandardHeight()
{
if ( !ms_sizeStd.y )
ms_sizeStd.y = wxSystemSettings::GetMetric(wxSYS_CURSOR_Y);
return ms_sizeStd.y;
}
wxCursorRefData::wxCursorRefData(HCURSOR hcursor, bool destroy)
{
m_hCursor = (WXHCURSOR)hcursor;
if ( m_hCursor )
{
m_width = GetStandardWidth();
m_height = GetStandardHeight();
}
m_destroyCursor = destroy;
}
void wxCursorRefData::Free()
{
if ( m_hCursor )
{
#ifndef __WXMICROWIN__
if ( m_destroyCursor )
::DestroyCursor((HCURSOR)m_hCursor);
#endif
m_hCursor = 0;
}
@@ -121,77 +187,103 @@ wxCursor::wxCursor()
{
}
wxCursor::wxCursor( const wxImage & image )
wxCursor::wxCursor(const wxImage& image)
{
//image has to be 32x32
wxImage image32 = image.Scale(32,32);
unsigned char * rgbBits = image32.GetData();
int w = image32.GetWidth() ;
int h = image32.GetHeight() ;
bool bHasMask = image32.HasMask() ;
int imagebitcount = (w*h)/8;
// image has to be of the standard cursor size, otherwise we won't be able
// to create it
const int w = wxCursorRefData::GetStandardWidth();
const int h = wxCursorRefData::GetStandardHeight();
unsigned char r, g, b ;
unsigned char * bits = new unsigned char [imagebitcount];
unsigned char * maskBits = new unsigned char [imagebitcount];
wxImage image32 = image.Scale(w, h);
int i,j, i8; unsigned char c, cMask;
for (i=0; i<imagebitcount; i++)
{
const int imagebitcount = (w*h)/8;
ByteArray bits(new unsigned char [imagebitcount]),
maskBits(new unsigned char [imagebitcount]);
int i, j, i8;
unsigned char c, cMask;
const unsigned char * const rgbBits = image32.GetData();
// first create the XOR mask
for ( i = 0; i < imagebitcount; i++ )
{
bits[i] = 0;
i8 = i * 8;
//unlike gtk, the pixels go in the opposite order in the bytes
// unlike gtk, the pixels go in the opposite order in the bytes
cMask = 128;
for (j=0; j<8; j++)
{
// possible overflow if we do the summation first ?
c = rgbBits[(i8+j)*3]/3 + rgbBits[(i8+j)*3+1]/3 + rgbBits[(i8+j)*3+2]/3 ;
//if average value is > mid grey
if (c>127)
bits[i] = bits[i] | cMask ;
cMask = cMask / 2 ;
}
}
if (bHasMask)
for ( j = 0; j < 8; j++ )
{
r = image32.GetMaskRed() ;
g = image32.GetMaskGreen() ;
b = image32.GetMaskBlue() ;
// possible overflow if we do the summation first ?
c = rgbBits[(i8+j)*3]/3 +
rgbBits[(i8+j)*3+1]/3 +
rgbBits[(i8+j)*3+2]/3;
for (i=0; i<imagebitcount; i++)
// if average value is > mid grey
if ( c > 127 )
bits[i] = bits[i] | cMask;
cMask = cMask / 2;
}
}
// now the AND one
if ( image32.HasMask() )
{
unsigned char r = image32.GetMaskRed(),
g = image32.GetMaskGreen(),
b = image32.GetMaskBlue();
for ( i = 0; i < imagebitcount; i++ )
{
maskBits[i] = 0x0;
i8 = i * 8;
maskBits[i] = 0x0;
i8 = i * 8;
cMask = 128;
for (j=0; j<8; j++)
{
if (rgbBits[(i8+j)*3] == r && rgbBits[(i8+j)*3+1] == g && rgbBits[(i8+j)*3+2] == b)
maskBits[i] = maskBits[i] | cMask ;
cMask = cMask / 2 ;
}
}
}
else
{
for (i=0; i<imagebitcount; i++)
maskBits[i]= 0x0 ;
}
cMask = 128;
for ( j = 0; j < 8; j++ )
{
if ( rgbBits[(i8+j)*3] == r &&
rgbBits[(i8+j)*3+1] == g &&
rgbBits[(i8+j)*3+2] == b )
{
maskBits[i] = maskBits[i] | cMask;
}
cMask = cMask / 2;
}
}
}
else // no mask in the image
{
memset(maskBits.get(), 0, sizeof(unsigned char)*imagebitcount);
}
// determine where should the cursors hot spot be
int hotSpotX = image32.GetOptionInt(wxCUR_HOTSPOT_X);
int hotSpotY = image32.GetOptionInt(wxCUR_HOTSPOT_Y);
if (hotSpotX < 0 || hotSpotX >= w)
hotSpotX = 0;
hotSpotX = 0;
if (hotSpotY < 0 || hotSpotY >= h)
hotSpotY = 0;
hotSpotY = 0;
wxCursorRefData *refData = new wxCursorRefData;
m_refData = refData;
refData->m_hCursor = (WXHCURSOR) CreateCursor ( wxGetInstance(), hotSpotX, hotSpotY, w, h, /*AND*/ maskBits, /*XOR*/ bits );
delete [] bits ;
delete [] maskBits;
// do create cursor now
HCURSOR hcursor = ::CreateCursor
(
wxGetInstance(),
hotSpotX, hotSpotY,
w, h,
/* AND */ maskBits.get(),
/* XOR */ bits.get()
);
if ( !hcursor )
{
wxLogLastError(_T("CreateCursor"));
}
else
{
m_refData = new wxCursorRefData(hcursor, true /* delete it */);
}
}
wxCursor::wxCursor(const char WXUNUSED(bits)[],
@@ -202,210 +294,178 @@ wxCursor::wxCursor(const char WXUNUSED(bits)[],
{
}
wxCursor::wxCursor(const wxString& cursor_file,
long flags,
int hotSpotX, int hotSpotY)
{
// MicroWin doesn't have support needed for the other ctors
#ifdef __WXMICROWIN__
m_refData = NULL;
#else
wxCursorRefData *refData = new wxCursorRefData;
m_refData = refData;
if (flags == wxBITMAP_TYPE_CUR_RESOURCE)
wxCursor::wxCursor(const wxString& WXUNUSED(filename),
long WXUNUSED(kind),
int WXUNUSED(hotSpotX),
int WXUNUSED(hotSpotY))
{
}
wxCursor::wxCursor(int WXUNUSED(cursor_type))
{
}
#else // !__WXMICROWIN__
wxCursor::wxCursor(const wxString& filename,
long kind,
int hotSpotX,
int hotSpotY)
{
HCURSOR hcursor;
switch ( kind )
{
#ifdef __WIN95__
refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, 0);
#else
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), cursor_file);
#endif
}
else if (flags == wxBITMAP_TYPE_CUR)
{
#ifdef __WIN95__
refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), cursor_file, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
#else
case wxBITMAP_TYPE_CUR_RESOURCE:
hcursor = ::LoadCursor(wxGetInstance(), filename);
break;
case wxBITMAP_TYPE_CUR:
hcursor = ::LoadCursorFromFile(filename);
break;
case wxBITMAP_TYPE_ICO:
#if wxUSE_RESOURCE_LOADING_IN_MSW
refData->m_hCursor = (WXHCURSOR) ReadCursorFile(WXSTRINGCAST cursor_file, wxGetInstance(), &refData->m_width, &refData->m_height);
#endif
#endif
}
else if (flags == wxBITMAP_TYPE_ICO)
{
hcursor = IconToCursor((wxChar *)filename.c_str(),
wxGetInstance(),
hotSpotX, hotSpotY,
NULL, NULL);
#endif // wxUSE_RESOURCE_LOADING_IN_MSW
break;
case wxBITMAP_TYPE_BMP:
{
#if wxUSE_RESOURCE_LOADING_IN_MSW
refData->m_hCursor = (WXHCURSOR) IconToCursor(WXSTRINGCAST cursor_file, wxGetInstance(), hotSpotX, hotSpotY, &refData->m_width, &refData->m_height);
#endif
HBITMAP hBitmap = 0;
HPALETTE hPalette = 0;
if ( wxReadDIB((wxChar *)filename.c_str(), &hBitmap, &hPalette) )
{
if (hPalette)
DeleteObject(hPalette);
POINT pt;
pt.x = hotSpotX;
pt.y = hotSpotY;
hcursor = MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pt);
DeleteObject(hBitmap);
#endif // wxUSE_RESOURCE_LOADING_IN_MSW
}
else
{
hcursor = NULL;
}
}
break;
default:
wxFAIL_MSG( _T("unknown cursor resource type") );
hcursor = NULL;
}
else if (flags == wxBITMAP_TYPE_BMP)
if ( hcursor )
{
#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;
refData->m_hCursor = (WXHCURSOR) MakeCursorFromBitmap(wxGetInstance(), hBitmap, &pnt);
DeleteObject(hBitmap);
#endif
}
m_refData = new wxCursorRefData(hcursor, true /* delete it later */);
#if WXWIN_COMPATIBILITY_2
refData->SetOk();
refData->SetOk();
#endif // WXWIN_COMPATIBILITY_2
#endif
}
}
// Cursors by stock number
wxCursor::wxCursor(int cursor_type)
wxCursor::wxCursor(int idCursor)
{
#ifdef __WXMICROWIN__
m_refData = NULL;
#else
wxCursorRefData *refData = new wxCursorRefData;
m_refData = refData;
// all wxWindows standard cursors
static const struct StdCursor
{
// is this a standard Windows cursor?
bool isStd;
switch (cursor_type)
{
case wxCURSOR_ARROWWAIT:
#ifndef __WIN16__
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_APPSTARTING);
break;
#endif
case wxCURSOR_WAIT:
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_WAIT);
break;
case wxCURSOR_IBEAM:
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_IBEAM);
break;
case wxCURSOR_CROSS:
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_CROSS);
break;
case wxCURSOR_SIZENWSE:
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENWSE);
break;
case wxCURSOR_SIZENESW:
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENESW);
break;
case wxCURSOR_SIZEWE:
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZEWE);
break;
case wxCURSOR_SIZENS:
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_SIZENS);
break;
case wxCURSOR_CHAR:
// the cursor name or id
LPCTSTR name;
} stdCursors[] =
{
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
case wxCURSOR_HAND:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_HAND"));
break;
}
case wxCURSOR_BULLSEYE:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BULLSEYE"));
break;
}
case wxCURSOR_PENCIL:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PENCIL"));
break;
}
case wxCURSOR_MAGNIFIER:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_MAGNIFIER"));
break;
}
case wxCURSOR_NO_ENTRY:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_NO_ENTRY"));
break;
}
case wxCURSOR_LEFT_BUTTON:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
case wxCURSOR_RIGHT_BUTTON:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
case wxCURSOR_MIDDLE_BUTTON:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
case wxCURSOR_SIZING:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_SIZING"));
break;
}
case wxCURSOR_WATCH:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_WATCH"));
break;
}
case wxCURSOR_SPRAYCAN:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_ROLLER"));
break;
}
case wxCURSOR_PAINT_BRUSH:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PBRUSH"));
break;
}
case wxCURSOR_POINT_LEFT:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PLEFT"));
break;
}
case wxCURSOR_POINT_RIGHT:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PRIGHT"));
break;
}
case wxCURSOR_QUESTION_ARROW:
{
// refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), wxT("wxCURSOR_QARROW"), IMAGE_CURSOR, 16, 16, LR_MONOCHROME);
// refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_QARROW"));
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_HELP);
break;
}
case wxCURSOR_BLANK:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BLANK"));
break;
}
case wxCURSOR_RIGHT_ARROW:
{
refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_RIGHT_ARROW"));
break;
}
default:
case wxCURSOR_ARROW:
refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
break;
}
{ true, NULL }, // wxCURSOR_NONE
{ true, IDC_ARROW }, // wxCURSOR_ARROW
{ false, _T("wxCURSOR_RIGHT_ARROW") }, // wxCURSOR_RIGHT_ARROW
{ false, _T("wxCURSOR_BULLSEYE") }, // wxCURSOR_BULLSEYE
{ true, IDC_ARROW }, // wxCURSOR_CHAR
{ true, IDC_CROSS }, // wxCURSOR_CROSS
{ false, _T("wxCURSOR_HAND") }, // wxCURSOR_HAND
{ true, IDC_IBEAM }, // wxCURSOR_IBEAM
{ true, IDC_ARROW }, // wxCURSOR_LEFT_BUTTON
{ false, _T("wxCURSOR_MAGNIFIER") }, // wxCURSOR_MAGNIFIER
{ true, IDC_ARROW }, // wxCURSOR_MIDDLE_BUTTON
{ true, IDC_NO }, // wxCURSOR_NO_ENTRY
{ false, _T("wxCURSOR_PAINT_BRUSH") }, // wxCURSOR_PAINT_BRUSH
{ false, _T("wxCURSOR_PENCIL") }, // wxCURSOR_PENCIL
{ false, _T("wxCURSOR_POINT_LEFT") }, // wxCURSOR_POINT_LEFT
{ false, _T("wxCURSOR_POINT_RIGHT") }, // wxCURSOR_POINT_RIGHT
{ true, IDC_HELP }, // wxCURSOR_QUESTION_ARROW
{ true, IDC_ARROW }, // wxCURSOR_RIGHT_BUTTON
{ true, IDC_SIZENESW }, // wxCURSOR_SIZENESW
{ true, IDC_SIZENS }, // wxCURSOR_SIZENS
{ true, IDC_SIZENWSE }, // wxCURSOR_SIZENWSE
{ true, IDC_SIZEWE }, // wxCURSOR_SIZEWE
{ true, IDC_SIZEALL }, // wxCURSOR_SIZING
{ false, _T("wxCURSOR_SPRAYCAN") }, // wxCURSOR_SPRAYCAN
{ true, IDC_WAIT }, // wxCURSOR_WAIT
{ true, IDC_WAIT }, // wxCURSOR_WATCH
{ false, _T("wxCURSOR_BLANK") }, // wxCURSOR_BLANK
{ true, IDC_APPSTARTING }, // wxCURSOR_ARROWWAIT
// no need to destroy the stock cursors
// TODO: check this
//m_refData->m_destroyCursor = FALSE;
#endif
// no entry for wxCURSOR_MAX
};
wxCOMPILE_TIME_ASSERT( WXSIZEOF(stdCursors) == wxCURSOR_MAX,
CursorsIdArrayMismatch );
wxCHECK_RET( idCursor > 0 && (size_t)idCursor < WXSIZEOF(stdCursors),
_T("invalid cursor id in wxCursor() ctor") );
const StdCursor& stdCursor = stdCursors[idCursor];
HCURSOR hcursor = ::LoadCursor(stdCursor.isStd ? NULL : wxGetInstance(),
stdCursor.name);
if ( !hcursor )
{
wxLogLastError(_T("LoadCursor"));
}
else
{
m_refData = new wxCursorRefData(hcursor);
}
}
#endif // __WXMICROWIN__/!__WXMICROWIN__
wxCursor::~wxCursor()
{
}
// ----------------------------------------------------------------------------
// other wxCursor functions
// ----------------------------------------------------------------------------
bool wxCursor::operator==(const wxCursor& cursor) const
{
if ( !m_refData )
return !cursor.m_refData;
return cursor.m_refData &&
((wxCursorRefData *)m_refData)->m_hCursor ==
((wxCursorRefData *)cursor.m_refData)->m_hCursor;
}
wxGDIImageRefData *wxCursor::CreateData() const
{
return new wxCursorRefData;
}
// ----------------------------------------------------------------------------
// Global cursor setting
// ----------------------------------------------------------------------------
@@ -419,9 +479,7 @@ void wxSetCursor(const wxCursor& cursor)
{
if ( cursor.Ok() )
{
#ifndef __WXMICROWIN__
::SetCursor(GetHcursorOf(cursor));
#endif
if ( gs_globalCursor )
*gs_globalCursor = cursor;