src/unix/joystick.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        joystick.cpp
   3 // Purpose:     wxJoystick class
   4 // Author:      Ported to Linux by Guilhem Lavaux
   5 // Modified by:
   6 // Created:     05/23/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Guilhem Lavaux
   9 // Licence:     wxWidgets licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 #pragma implementation "joystick.h"
  14 #endif
  15
  16 // for compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #include "wx/defs.h"
  20
  21 #if wxUSE_JOYSTICK
  22
  23 #include "wx/joystick.h"
  24
  25 #include <linux/joystick.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <sys/time.h>
  29 #include <sys/ioctl.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32
  33 #include "wx/event.h"
  34 #include "wx/window.h"
  35
  36 enum {
  37     wxJS_AXIS_X = 0,
  38     wxJS_AXIS_Y,
  39     wxJS_AXIS_Z,
  40     wxJS_AXIS_RUDDER,
  41     wxJS_AXIS_U,
  42     wxJS_AXIS_V,
  43
  44     wxJS_AXIS_MAX = 32767,
  45     wxJS_AXIS_MIN = -32767
  46 };
  47
  48
  49 IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)
  50
  51
  52 ////////////////////////////////////////////////////////////////////////////
  53 // Background thread for reading the joystick device
  54 ////////////////////////////////////////////////////////////////////////////
  55
  56 class wxJoystickThread : public wxThread
  57 {
  58 public:
  59     wxJoystickThread(int device, int joystick);
  60     void* Entry();
  61
  62 private:
  63     int       m_device;
  64     int       m_joystick;
  65     wxPoint   m_lastposition;
  66     int       m_axe[15];
  67     int       m_buttons;
  68     wxWindow* m_catchwin;
  69     int       m_polling;
  70
  71     friend class wxJoystick;
  72 };
  73
  74
  75 wxJoystickThread::wxJoystickThread(int device, int joystick)
  76     : m_device(device),
  77       m_joystick(joystick),
  78       m_lastposition(wxDefaultPosition),
  79       m_buttons(0),
  80       m_catchwin(NULL),
  81       m_polling(0)
  82 {
  83     for (int i=0; i<15; i++)
  84         m_axe[i] = 0;
  85 }
  86
  87
  88 void* wxJoystickThread::Entry()
  89 {
  90     struct js_event j_evt;
  91     fd_set read_fds;
  92     struct timeval time_out = {0, 0};
  93
  94     FD_ZERO(&read_fds);
  95     while (true) {
  96         if (TestDestroy())
  97             break;
  98
  99         // We use select when either polling or 'blocking' as even in the
 100         // blocking case we need to check TestDestroy periodically
 101         if (m_polling)
 102             time_out.tv_usec = m_polling * 1000;
 103         else
 104             time_out.tv_usec = 10 * 1000; // check at least every 10 msec in blocking case
 105
 106         FD_SET(m_device, &read_fds);
 107         select(m_device+1, &read_fds, NULL, NULL, &time_out);
 108         if (FD_ISSET(m_device, &read_fds))
 109         {
 110             memset(&j_evt, 0, sizeof(j_evt));
 111             read(m_device, &j_evt, sizeof(j_evt));
 112
 113             //printf("time: %d\t value: %d\t type: %d\t number: %d\n",
 114             //       j_evt.time, j_evt.value, j_evt.type, j_evt.number);
 115
 116             if (m_catchwin)
 117             {
 118                 wxJoystickEvent jwx_event;
 119
 120                 if ((j_evt.type & JS_EVENT_AXIS) == JS_EVENT_AXIS) {
 121
 122                     m_axe[j_evt.number] = j_evt.value;
 123
 124                     switch (j_evt.number) {
 125                     case wxJS_AXIS_X:
 126                         m_lastposition.x = j_evt.value;
 127                         jwx_event.SetEventType(wxEVT_JOY_MOVE);
 128                         break;
 129                     case wxJS_AXIS_Y:
 130                         m_lastposition.y = j_evt.value;
 131                         jwx_event.SetEventType(wxEVT_JOY_MOVE);
 132                         break;
 133                     case wxJS_AXIS_Z:
 134                         jwx_event.SetEventType(wxEVT_JOY_ZMOVE);
 135                         break;
 136                     default:
 137                         jwx_event.SetEventType(wxEVT_JOY_MOVE);
 138                         // TODO: There should be a way to indicate that the event
 139                         //       is for some other axes.
 140                         break;
 141                     }
 142                 }
 143
 144                 if ((j_evt.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON) {
 145                     if (j_evt.value)
 146                     {
 147                         m_buttons |= (1 << j_evt.number);
 148                         jwx_event.SetEventType(wxEVT_JOY_BUTTON_DOWN);
 149                     }
 150                     else
 151                     {
 152                         m_buttons &= ~(1 << j_evt.number);
 153                         jwx_event.SetEventType(wxEVT_JOY_BUTTON_UP);
 154                     }
 155
 156                     jwx_event.SetButtonChange(j_evt.number);
 157                 }
 158
 159                 jwx_event.SetTimestamp(j_evt.time);
 160                 jwx_event.SetJoystick(m_joystick);
 161                 jwx_event.SetButtonState(m_buttons);
 162                 jwx_event.SetPosition(m_lastposition);
 163                 jwx_event.SetZPosition(m_axe[3]);
 164                 jwx_event.SetEventObject(m_catchwin);
 165
 166
 167                 m_catchwin->AddPendingEvent(jwx_event);
 168             }
 169
 170 //         if (m_polling)
 171 //             wxThread::Sleep(m_polling);
 172         }
 173     }
 174
 175     close(m_device);
 176     return NULL;
 177 }
 178
 179
 180 ////////////////////////////////////////////////////////////////////////////
 181
 182 wxJoystick::wxJoystick(int joystick)
 183     : m_device(-1),
 184       m_joystick(joystick),
 185       m_thread(NULL)
 186 {
 187     wxString dev_name;
 188
 189     // Assume it's the same device name on all Linux systems ...
 190     dev_name.Printf( wxT("/dev/js%d"), (joystick == wxJOYSTICK1) ? 0 : 1);
 191     m_device = open(dev_name.fn_str(), O_RDONLY);
 192
 193     if (m_device != -1)
 194     {
 195         m_thread = new wxJoystickThread(m_device, m_joystick);
 196         m_thread->Create();
 197         m_thread->Run();
 198     }
 199 }
 200
 201
 202 wxJoystick::~wxJoystick()
 203 {
 204     ReleaseCapture();
 205     if (m_thread)
 206         m_thread->Delete();  // It's detached so it will delete itself
 207     m_device = -1;
 208 }
 209
 210
 211 ////////////////////////////////////////////////////////////////////////////
 212 // State
 213 ////////////////////////////////////////////////////////////////////////////
 214
 215 wxPoint wxJoystick::GetPosition() const
 216 {
 217     wxPoint pos(wxDefaultPosition);
 218     if (m_thread) pos = m_thread->m_lastposition;
 219     return pos;
 220 }
 221
 222 int wxJoystick::GetZPosition() const
 223 {
 224     if (m_thread)
 225         return m_thread->m_axe[wxJS_AXIS_Z];
 226     return 0;
 227 }
 228
 229 int wxJoystick::GetButtonState() const
 230 {
 231     if (m_thread)
 232         return m_thread->m_buttons;
 233     return 0;
 234 }
 235
 236 int wxJoystick::GetPOVPosition() const
 237 {
 238     return -1;
 239 }
 240
 241 int wxJoystick::GetPOVCTSPosition() const
 242 {
 243     return -1;
 244 }
 245
 246 int wxJoystick::GetRudderPosition() const
 247 {
 248     if (m_thread)
 249         return m_thread->m_axe[wxJS_AXIS_RUDDER];
 250     return 0;
 251 }
 252
 253 int wxJoystick::GetUPosition() const
 254 {
 255     if (m_thread)
 256         return m_thread->m_axe[wxJS_AXIS_U];
 257     return 0;
 258 }
 259
 260 int wxJoystick::GetVPosition() const
 261 {
 262     if (m_thread)
 263         return m_thread->m_axe[wxJS_AXIS_V];
 264     return 0;
 265 }
 266
 267 int wxJoystick::GetMovementThreshold() const
 268 {
 269     return 0;
 270 }
 271
 272 void wxJoystick::SetMovementThreshold(int threshold)
 273 {
 274 }
 275
 276 ////////////////////////////////////////////////////////////////////////////
 277 // Capabilities
 278 ////////////////////////////////////////////////////////////////////////////
 279
 280 bool wxJoystick::IsOk() const
 281 {
 282     return (m_device != -1);
 283 }
 284
 285 int wxJoystick::GetNumberJoysticks() const
 286 {
 287     wxString dev_name;
 288     int fd, j;
 289
 290     for (j=0; j<4; j++) {
 291         dev_name.Printf(wxT("/dev/js%d"), j);
 292         fd = open(dev_name.fn_str(), O_RDONLY);
 293         if (fd == -1)
 294             return j;
 295         close(fd);
 296     }
 297     return j;
 298 }
 299
 300 int wxJoystick::GetManufacturerId() const
 301 {
 302     return 0;
 303 }
 304
 305 int wxJoystick::GetProductId() const
 306 {
 307     return 0;
 308 }
 309
 310 wxString wxJoystick::GetProductName() const
 311 {
 312     char name[128];
 313
 314     if (ioctl(m_device, JSIOCGNAME(sizeof(name)), name) < 0)
 315         strcpy(name, "Unknown");
 316     return wxString(name, wxConvLibc);
 317 }
 318
 319 int wxJoystick::GetXMin() const
 320 {
 321     return wxJS_AXIS_MIN;
 322 }
 323
 324 int wxJoystick::GetYMin() const
 325 {
 326     return wxJS_AXIS_MIN;
 327 }
 328
 329 int wxJoystick::GetZMin() const
 330 {
 331     return wxJS_AXIS_MIN;
 332 }
 333
 334 int wxJoystick::GetXMax() const
 335 {
 336     return wxJS_AXIS_MAX;
 337 }
 338
 339 int wxJoystick::GetYMax() const
 340 {
 341     return wxJS_AXIS_MAX;
 342 }
 343
 344 int wxJoystick::GetZMax() const
 345 {
 346     return wxJS_AXIS_MAX;
 347 }
 348
 349 int wxJoystick::GetNumberButtons() const
 350 {
 351     char nb=0;
 352
 353     if (m_device != -1)
 354         ioctl(m_device, JSIOCGBUTTONS, &nb);
 355
 356     return nb;
 357 }
 358
 359 int wxJoystick::GetNumberAxes() const
 360 {
 361     char nb=0;
 362
 363     if (m_device != -1)
 364         ioctl(m_device, JSIOCGAXES, &nb);
 365
 366     return nb;
 367 }
 368
 369 int wxJoystick::GetMaxButtons() const
 370 {
 371     return 15; // internal
 372 }
 373
 374 int wxJoystick::GetMaxAxes() const
 375 {
 376     return 15; // internal
 377 }
 378
 379 int wxJoystick::GetPollingMin() const
 380 {
 381     return 10;
 382 }
 383
 384 int wxJoystick::GetPollingMax() const
 385 {
 386     return 1000;
 387 }
 388
 389 int wxJoystick::GetRudderMin() const
 390 {
 391     return wxJS_AXIS_MIN;
 392 }
 393
 394 int wxJoystick::GetRudderMax() const
 395 {
 396     return wxJS_AXIS_MAX;
 397 }
 398
 399 int wxJoystick::GetUMin() const
 400 {
 401     return wxJS_AXIS_MIN;
 402 }
 403
 404 int wxJoystick::GetUMax() const
 405 {
 406     return wxJS_AXIS_MAX;
 407 }
 408
 409 int wxJoystick::GetVMin() const
 410 {
 411     return wxJS_AXIS_MIN;
 412 }
 413
 414 int wxJoystick::GetVMax() const
 415 {
 416     return wxJS_AXIS_MAX;
 417 }
 418
 419 bool wxJoystick::HasRudder() const
 420 {
 421     return GetNumberAxes() >= wxJS_AXIS_RUDDER;
 422 }
 423
 424 bool wxJoystick::HasZ() const
 425 {
 426     return GetNumberAxes() >= wxJS_AXIS_Z;
 427 }
 428
 429 bool wxJoystick::HasU() const
 430 {
 431     return GetNumberAxes() >= wxJS_AXIS_U;
 432 }
 433
 434 bool wxJoystick::HasV() const
 435 {
 436     return GetNumberAxes() >= wxJS_AXIS_V;
 437 }
 438
 439 bool wxJoystick::HasPOV() const
 440 {
 441     return false;
 442 }
 443
 444 bool wxJoystick::HasPOV4Dir() const
 445 {
 446     return false;
 447 }
 448
 449 bool wxJoystick::HasPOVCTS() const
 450 {
 451     return false;
 452 }
 453
 454 ////////////////////////////////////////////////////////////////////////////
 455 // Operations
 456 ////////////////////////////////////////////////////////////////////////////
 457
 458 bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
 459 {
 460     if (m_thread)
 461     {
 462         m_thread->m_catchwin = win;
 463         m_thread->m_polling = pollingFreq;
 464         return true;
 465     }
 466     return false;
 467 }
 468
 469 bool wxJoystick::ReleaseCapture()
 470 {
 471     if (m_thread)
 472     {
 473         m_thread->m_catchwin = NULL;
 474         m_thread->m_polling = 0;
 475         return true;
 476     }
 477     return false;
 478 }
 479 #endif  // wxUSE_JOYSTICK
 480