/////////////////////////////////////////////////////////////////////////////
-// Name: cursor.cpp
+// Name: src/mgl/cursor.cpp
// Purpose:
// Author: Vaclav Slavik
// Id: $Id$
-// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
+// Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __GNUG__
-#pragma implementation "cursor.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#endif
#include "wx/cursor.h"
-#include "wx/utils.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#include <mgraph.hpp>
+#ifndef WX_PRECOMP
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/utils.h"
+ #include "wx/hashmap.h"
+ #include "wx/module.h"
+#endif
+
+#include "wx/mgl/private.h"
//-----------------------------------------------------------------------------
public:
wxCursorRefData();
- ~wxCursorRefData();
+ virtual ~wxCursorRefData();
MGLCursor *m_cursor;
};
delete m_cursor;
}
+#define M_CURSORDATA ((wxCursorRefData *)m_refData)
+
//-----------------------------------------------------------------------------
-#define M_CURSORDATA ((wxCursorRefData *)m_refData)
+WX_DECLARE_HASH_MAP(int, wxCursor, wxIntegerHash, wxIntegerEqual, wxCursorsHash);
+
+static wxCursorsHash *gs_cursorsHash = NULL;
IMPLEMENT_DYNAMIC_CLASS(wxCursor,wxObject)
wxCursor::wxCursor(int cursorId)
{
+ if ( !gs_cursorsHash )
+ gs_cursorsHash = new wxCursorsHash;
+
+ if ( gs_cursorsHash->find(cursorId) != gs_cursorsHash->end() )
+ {
+ wxLogTrace(_T("mglcursor"), _T("cursor id %i fetched from cache"), cursorId);
+ *this = (*gs_cursorsHash)[cursorId];
+ return;
+ }
+
const char *cursorname = NULL;
m_refData = new wxCursorRefData();
switch (cursorId)
{
- // FIXME_MGL -- what about storing these default cursors in executable
- // as XPMs so that wxMGL binary wouldn't depend on
- // tons of files in $MGL_ROOT/cursors? I don't know yet...
case wxCURSOR_ARROW: cursorname = "arrow.cur"; break;
+ case wxCURSOR_RIGHT_ARROW: cursorname = "rightarr.cur"; break;
case wxCURSOR_BULLSEYE: cursorname = "bullseye.cur"; break;
case wxCURSOR_CHAR: cursorname = "char.cur"; break;
case wxCURSOR_CROSS: cursorname = "cross.cur"; break;
case wxCURSOR_BLANK: cursorname = "blank.cur"; break;
case wxCURSOR_NONE:
- // FIXME_MGL - make sure wxWindow uses cursor with
- // GetMGLCursor() == NULL correctly, i.e. calls MS_hide()
*this = wxNullCursor;
return;
- break;
default:
wxFAIL_MSG(wxT("unsupported cursor type"));
break;
}
-
+
M_CURSORDATA->m_cursor = new MGLCursor(cursorname);
// if we cannot load arrow cursor, use MGL's default arrow cursor:
delete M_CURSORDATA->m_cursor;
M_CURSORDATA->m_cursor = new MGLCursor(MGL_DEF_CURSOR);
}
-
+
if ( !M_CURSORDATA->m_cursor->valid() )
{
wxLogError(_("Couldn't create cursor."));
UnRef();
}
+ else
+ {
+ (*gs_cursorsHash)[cursorId] = *this;
+ wxLogTrace(_T("mglcursor"), _T("cursor id %i added to cache (%s)"),
+ cursorId, cursorname);
+ }
}
wxCursor::wxCursor(const char WXUNUSED(bits)[],
wxCursor::wxCursor(const wxString& cursor_file,
long flags,
- int hotSpotX, int hotSpotY)
+ int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY))
{
if ( flags == wxBITMAP_TYPE_CUR || flags == wxBITMAP_TYPE_CUR_RESOURCE )
{
}
}
-wxCursor::wxCursor(const wxCursor &cursor)
-{
- Ref(cursor);
-}
-
wxCursor::~wxCursor()
{
// wxObject unrefs data
}
-wxCursor& wxCursor::operator = (const wxCursor& cursor)
-{
- if ( *this == cursor )
- return (*this);
- Ref(cursor);
- return *this;
-}
-
-bool wxCursor::operator == (const wxCursor& cursor) const
-{
- return (m_refData == cursor.m_refData);
-}
-
-bool wxCursor::operator != (const wxCursor& cursor) const
-{
- return (m_refData != cursor.m_refData);
-}
-
-bool wxCursor::Ok() const
-{
- return (m_refData != NULL);
-}
-
MGLCursor *wxCursor::GetMGLCursor() const
{
return M_CURSORDATA->m_cursor;
// Global cursor setting
// ----------------------------------------------------------------------------
+static wxCursor gs_globalCursor = wxNullCursor;
void wxSetCursor(const wxCursor& cursor)
{
if ( cursor.Ok() )
{
- //MGL_setGlobalCursor(cursor.GetMGLCursor());
- // FIXME_MGL -- needs MGL WM first
+ if ( g_winMng )
+ MGL_wmSetGlobalCursor(g_winMng, *cursor.GetMGLCursor());
+ gs_globalCursor = cursor;
+ }
+ else
+ {
+ if ( g_winMng )
+ MGL_wmSetGlobalCursor(g_winMng, NULL);
+ gs_globalCursor = wxNullCursor;
}
}
// busy cursor routines
//-----------------------------------------------------------------------------
-// FIXME_MGL -- do we need this? It may be better to incorporate
-// support for it into MGL (a stack of global cursors?)
-static wxCursor gs_savedCursor;
-static wxCursor g_globalCursor;
+static wxCursor gs_savedCursor = wxNullCursor;
static int gs_busyCount = 0;
const wxCursor &wxBusyCursor::GetStoredCursor()
const wxCursor wxBusyCursor::GetBusyCursor()
{
- return wxCursor(wxCURSOR_WAIT);
+ return gs_globalCursor;
}
void wxEndBusyCursor()
wxSetCursor(gs_savedCursor);
gs_savedCursor = wxNullCursor;
- //wxYield(); FIXME_MGL - needed?
}
-void wxBeginBusyCursor(wxCursor *WXUNUSED(cursor))
+void wxBeginBusyCursor(const wxCursor *cursor)
{
if ( gs_busyCount++ > 0 ) return;
wxASSERT_MSG( !gs_savedCursor.Ok(),
wxT("forgot to call wxEndBusyCursor, will leak memory") );
- gs_savedCursor = g_globalCursor;
- wxSetCursor(wxCursor(wxCURSOR_WAIT));
- //wxYield(); FIXME_MGL - needed?
+ gs_savedCursor = gs_globalCursor;
+ if ( cursor->Ok() )
+ wxSetCursor(*cursor);
+ else
+ wxSetCursor(wxCursor(wxCURSOR_WAIT));
}
bool wxIsBusy()
return (gs_busyCount > 0);
}
+
+
+//-----------------------------------------------------------------------------
+// module - clean up code
+//-----------------------------------------------------------------------------
+
+class wxCursorModule : public wxModule
+{
+public:
+ virtual bool OnInit() { return true; }
+
+ virtual void OnExit()
+ {
+ wxDELETE(gs_cursorsHash);
+ }
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxCursorModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxCursorModule, wxModule)
projects / wxWidgets.git / blobdiff