/////////////////////////////////////////////////////////////////////////////
-// 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
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
#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
#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
// ----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxCursorBase)
+IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxGDIObject)
// ----------------------------------------------------------------------------
// globals
}
};
+// ----------------------------------------------------------------------------
+// other types
+// ----------------------------------------------------------------------------
+
+wxDECLARE_SCOPED_ARRAY(unsigned char, ByteArray);
+wxDEFINE_SCOPED_ARRAY(unsigned char, ByteArray);
+
// ============================================================================
// implementation
// ============================================================================
// wxCursorRefData
// ----------------------------------------------------------------------------
-wxCursorRefData::wxCursorRefData()
+wxSize wxCursorRefData::ms_sizeStd;
+
+wxCoord wxCursorRefData::GetStandardWidth()
+{
+ if ( !ms_sizeStd.x )
+ ms_sizeStd.x = wxSystemSettings::GetMetric(wxSYS_CURSOR_X);
+
+ return ms_sizeStd.x;
+}
+
+wxCoord wxCursorRefData::GetStandardHeight()
{
- m_width = 32;
- m_height = 32;
+ if ( !ms_sizeStd.y )
+ ms_sizeStd.y = wxSystemSettings::GetMetric(wxSYS_CURSOR_Y);
- refData->m_destroyCursor = TRUE;
+ 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;
}
{
}
+wxCursor::wxCursor(const wxImage& image)
+{
+ // 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();
+
+ wxImage image32 = image.Scale(w, h);
+
+ 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
+ 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;
+ }
+ }
+
+ // 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;
+
+ 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;
+ if (hotSpotY < 0 || hotSpotY >= h)
+ hotSpotY = 0;
+
+ // 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)[],
int WXUNUSED(width),
int WXUNUSED(height),
{
}
-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)
- {
-#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)
+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, 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;
-
- 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:
- {
- 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:
+ // all wxWindows standard cursors
+ static const struct StdCursor
{
- 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:
+ // is this a standard Windows cursor?
+ bool isStd;
+
+ // the cursor name or id
+ LPCTSTR name;
+ } stdCursors[] =
{
- refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_PRIGHT"));
- break;
- }
- case wxCURSOR_QUESTION_ARROW:
+ { 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 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 )
{
-// refData->m_hCursor = (WXHCURSOR) LoadImage(wxGetInstance(), wxT("wxCURSOR_QARROW"), IMAGE_CURSOR, 16, 16, LR_MONOCHROME);
- refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_QARROW"));
- break;
+ wxLogLastError(_T("LoadCursor"));
}
- case wxCURSOR_BLANK:
+ else
{
- refData->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), wxT("wxCURSOR_BLANK"));
- break;
+ m_refData = new wxCursorRefData(hcursor);
}
- default:
- case wxCURSOR_ARROW:
- refData->m_hCursor = (WXHCURSOR) LoadCursor((HINSTANCE) NULL, IDC_ARROW);
- break;
- }
-#endif
-
- // no need to destroy the stock cursors
- refData->m_destroyCursor = FALSE;
}
+#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
// ----------------------------------------------------------------------------
{
if ( cursor.Ok() )
{
-#ifndef __WXMICROWIN__
::SetCursor(GetHcursorOf(cursor));
-#endif
if ( gs_globalCursor )
*gs_globalCursor = cursor;