src/mgl/cursor.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mgl/cursor.cpp
   3 // Purpose:
   4 // Author:      Vaclav Slavik
   5 // Id:          $Id$
   6 // Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #include "wx/cursor.h"
  18 #include "wx/module.h"
  19 #include "wx/utils.h"
  20 #include "wx/log.h"
  21 #include "wx/intl.h"
  22 #include "wx/hashmap.h"
  23
  24 #include "wx/mgl/private.h"
  25
  26
  27 //-----------------------------------------------------------------------------
  28 // wxCursor
  29 //-----------------------------------------------------------------------------
  30
  31 class wxCursorRefData: public wxObjectRefData
  32 {
  33   public:
  34
  35     wxCursorRefData();
  36     ~wxCursorRefData();
  37
  38     MGLCursor *m_cursor;
  39 };
  40
  41 wxCursorRefData::wxCursorRefData()
  42 {
  43     m_cursor = (MGLCursor*) NULL;
  44 }
  45
  46 wxCursorRefData::~wxCursorRefData()
  47 {
  48     delete m_cursor;
  49 }
  50
  51 #define M_CURSORDATA ((wxCursorRefData *)m_refData)
  52
  53 //-----------------------------------------------------------------------------
  54
  55 WX_DECLARE_HASH_MAP(int, wxCursor, wxIntegerHash, wxIntegerEqual, wxCursorsHash);
  56
  57 static wxCursorsHash *gs_cursorsHash = NULL;
  58
  59 IMPLEMENT_DYNAMIC_CLASS(wxCursor,wxObject)
  60
  61 wxCursor::wxCursor()
  62 {
  63 }
  64
  65 wxCursor::wxCursor(int cursorId)
  66 {
  67     if ( !gs_cursorsHash )
  68         gs_cursorsHash = new wxCursorsHash;
  69
  70     if ( gs_cursorsHash->find(cursorId) != gs_cursorsHash->end() )
  71     {
  72         wxLogTrace(_T("mglcursor"), _T("cursor id %i fetched from cache"), cursorId);
  73         *this = (*gs_cursorsHash)[cursorId];
  74         return;
  75     }
  76
  77     const char *cursorname = NULL;
  78     m_refData = new wxCursorRefData();
  79
  80     switch (cursorId)
  81     {
  82         case wxCURSOR_ARROW:           cursorname = "arrow.cur"; break;
  83         case wxCURSOR_RIGHT_ARROW:     cursorname = "rightarr.cur"; break;
  84         case wxCURSOR_BULLSEYE:        cursorname = "bullseye.cur"; break;
  85         case wxCURSOR_CHAR:            cursorname = "char.cur"; break;
  86         case wxCURSOR_CROSS:           cursorname = "cross.cur"; break;
  87         case wxCURSOR_HAND:            cursorname = "hand.cur"; break;
  88         case wxCURSOR_IBEAM:           cursorname = "ibeam.cur"; break;
  89         case wxCURSOR_LEFT_BUTTON:     cursorname = "leftbtn.cur"; break;
  90         case wxCURSOR_MAGNIFIER:       cursorname = "magnif1.cur"; break;
  91         case wxCURSOR_MIDDLE_BUTTON:   cursorname = "midbtn.cur"; break;
  92         case wxCURSOR_NO_ENTRY:        cursorname = "noentry.cur"; break;
  93         case wxCURSOR_PAINT_BRUSH:     cursorname = "pbrush.cur"; break;
  94         case wxCURSOR_PENCIL:          cursorname = "pencil.cur"; break;
  95         case wxCURSOR_POINT_LEFT:      cursorname = "pntleft.cur"; break;
  96         case wxCURSOR_POINT_RIGHT:     cursorname = "pntright.cur"; break;
  97         case wxCURSOR_QUESTION_ARROW:  cursorname = "query.cur"; break;
  98         case wxCURSOR_RIGHT_BUTTON:    cursorname = "rightbtn.cur"; break;
  99         case wxCURSOR_SIZENESW:        cursorname = "sizenesw.cur"; break;
 100         case wxCURSOR_SIZENS:          cursorname = "sizens.cur"; break;
 101         case wxCURSOR_SIZENWSE:        cursorname = "sizenwse.cur"; break;
 102         case wxCURSOR_SIZEWE:          cursorname = "sizewe.cur"; break;
 103         case wxCURSOR_SIZING:          cursorname = "size.cur"; break;
 104         case wxCURSOR_SPRAYCAN:        cursorname = "spraycan.cur"; break;
 105         case wxCURSOR_WAIT:            cursorname = "wait.cur"; break;
 106         case wxCURSOR_WATCH:           cursorname = "clock.cur"; break;
 107         case wxCURSOR_BLANK:           cursorname = "blank.cur"; break;
 108
 109         case wxCURSOR_NONE:
 110             *this = wxNullCursor;
 111             return;
 112
 113         default:
 114             wxFAIL_MSG(wxT("unsupported cursor type"));
 115             break;
 116     }
 117
 118     M_CURSORDATA->m_cursor = new MGLCursor(cursorname);
 119
 120     // if we cannot load arrow cursor, use MGL's default arrow cursor:
 121     if ( !M_CURSORDATA->m_cursor->valid() && cursorId == wxCURSOR_ARROW )
 122     {
 123         delete M_CURSORDATA->m_cursor;
 124         M_CURSORDATA->m_cursor = new MGLCursor(MGL_DEF_CURSOR);
 125     }
 126
 127     if ( !M_CURSORDATA->m_cursor->valid() )
 128     {
 129         wxLogError(_("Couldn't create cursor."));
 130         UnRef();
 131     }
 132     else
 133     {
 134         (*gs_cursorsHash)[cursorId] = *this;
 135         wxLogTrace(_T("mglcursor"), _T("cursor id %i added to cache (%s)"),
 136                    cursorId, cursorname);
 137     }
 138 }
 139
 140 wxCursor::wxCursor(const char WXUNUSED(bits)[],
 141                    int WXUNUSED(width),
 142                    int WXUNUSED(height),
 143                    int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY),
 144                    const char WXUNUSED(maskBits)[],
 145                    wxColour * WXUNUSED(fg), wxColour * WXUNUSED(bg) )
 146 {
 147     //FIXME_MGL
 148 }
 149
 150 wxCursor::wxCursor(const wxString& cursor_file,
 151                    long flags,
 152                    int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY))
 153 {
 154     if ( flags == wxBITMAP_TYPE_CUR || flags == wxBITMAP_TYPE_CUR_RESOURCE )
 155     {
 156         m_refData = new wxCursorRefData();
 157         M_CURSORDATA->m_cursor = new MGLCursor(cursor_file.mb_str());
 158         if ( !M_CURSORDATA->m_cursor->valid() )
 159         {
 160             wxLogError(_("Couldn't create cursor."));
 161             UnRef();
 162         }
 163     }
 164     else
 165     {
 166         wxLogError(wxT("Cannot load cursor resource of this type."));
 167     }
 168 }
 169
 170 wxCursor::wxCursor(const wxCursor &cursor)
 171 {
 172     Ref(cursor);
 173 }
 174
 175 wxCursor::~wxCursor()
 176 {
 177     // wxObject unrefs data
 178 }
 179
 180 wxCursor& wxCursor::operator = (const wxCursor& cursor)
 181 {
 182     if ( *this == cursor )
 183         return (*this);
 184     Ref(cursor);
 185     return *this;
 186 }
 187
 188 bool wxCursor::operator == (const wxCursor& cursor) const
 189 {
 190     return (m_refData == cursor.m_refData);
 191 }
 192
 193 bool wxCursor::operator != (const wxCursor& cursor) const
 194 {
 195     return (m_refData != cursor.m_refData);
 196 }
 197
 198 bool wxCursor::Ok() const
 199 {
 200     return (m_refData != NULL);
 201 }
 202
 203 MGLCursor *wxCursor::GetMGLCursor() const
 204 {
 205     return M_CURSORDATA->m_cursor;
 206 }
 207
 208
 209
 210 // ----------------------------------------------------------------------------
 211 // Global cursor setting
 212 // ----------------------------------------------------------------------------
 213
 214 static wxCursor  gs_globalCursor = wxNullCursor;
 215
 216 void wxSetCursor(const wxCursor& cursor)
 217 {
 218     if ( cursor.Ok() )
 219     {
 220         if ( g_winMng )
 221             MGL_wmSetGlobalCursor(g_winMng, *cursor.GetMGLCursor());
 222         gs_globalCursor = cursor;
 223     }
 224     else
 225     {
 226         if ( g_winMng )
 227             MGL_wmSetGlobalCursor(g_winMng, NULL);
 228         gs_globalCursor = wxNullCursor;
 229     }
 230 }
 231
 232
 233
 234 //-----------------------------------------------------------------------------
 235 // busy cursor routines
 236 //-----------------------------------------------------------------------------
 237
 238 static wxCursor  gs_savedCursor = wxNullCursor;
 239 static int       gs_busyCount = 0;
 240
 241 const wxCursor &wxBusyCursor::GetStoredCursor()
 242 {
 243     return gs_savedCursor;
 244 }
 245
 246 const wxCursor wxBusyCursor::GetBusyCursor()
 247 {
 248     return gs_globalCursor;
 249 }
 250
 251 void wxEndBusyCursor()
 252 {
 253     if ( --gs_busyCount > 0 ) return;
 254
 255     wxSetCursor(gs_savedCursor);
 256     gs_savedCursor = wxNullCursor;
 257 }
 258
 259 void wxBeginBusyCursor(wxCursor *cursor)
 260 {
 261     if ( gs_busyCount++ > 0 ) return;
 262
 263     wxASSERT_MSG( !gs_savedCursor.Ok(),
 264                   wxT("forgot to call wxEndBusyCursor, will leak memory") );
 265
 266     gs_savedCursor = gs_globalCursor;
 267     if ( cursor->Ok() )
 268         wxSetCursor(*cursor);
 269     else
 270         wxSetCursor(wxCursor(wxCURSOR_WAIT));
 271 }
 272
 273 bool wxIsBusy()
 274 {
 275     return (gs_busyCount > 0);
 276 }
 277
 278
 279
 280 //-----------------------------------------------------------------------------
 281 // module - clean up code
 282 //-----------------------------------------------------------------------------
 283
 284 class wxCursorModule : public wxModule
 285 {
 286 public:
 287     virtual bool OnInit() { return true; }
 288
 289     virtual void OnExit()
 290     {
 291         wxDELETE(gs_cursorsHash);
 292     }
 293
 294 private:
 295     DECLARE_DYNAMIC_CLASS(wxCursorModule)
 296 };
 297
 298 IMPLEMENT_DYNAMIC_CLASS(wxCursorModule, wxModule)