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:     wxWindows 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     {
  97         if (TestDestroy())
  98             break;
  99
 100         // We use select when either polling or 'blocking' as even in the
 101         // blocking case we need to check TestDestroy periodically
 102         if (m_polling)
 103             time_out.tv_usec = m_polling * 1000;
 104         else
 105             time_out.tv_usec = 10 * 1000; // check at least every 10 msec in blocking case
 106
 107         FD_SET(m_device, &read_fds);
 108         select(m_device+1, &read_fds, NULL, NULL, &time_out);
 109         if (FD_ISSET(m_device, &read_fds))
 110         {
 111             memset(&j_evt, 0, sizeof(j_evt));
 112             read(m_device, &j_evt, sizeof(j_evt));
 113
 114             //printf("time: %d\t value: %d\t type: %d\t number: %d\n",
 115             //       j_evt.time, j_evt.value, j_evt.type, j_evt.number);
 116
 117             wxJoystickEvent jwx_event;
 118
 119             if (j_evt.type & JS_EVENT_AXIS)
 120             {
 121                 m_axe[j_evt.number] = j_evt.value;
 122
 123                 switch (j_evt.number)
 124                 {
 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)
 145             {
 146                 if (j_evt.value)
 147                 {
 148                     m_buttons |= (1 << j_evt.number);
 149                     jwx_event.SetEventType(wxEVT_JOY_BUTTON_DOWN);
 150                 }
 151                 else
 152                 {
 153                     m_buttons &= ~(1 << j_evt.number);
 154                     jwx_event.SetEventType(wxEVT_JOY_BUTTON_UP);
 155                 }
 156
 157                 jwx_event.SetButtonChange(j_evt.number);
 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                 if (m_catchwin)
 167                     m_catchwin->AddPendingEvent(jwx_event);
 168             }
 169         }
 170     }
 171
 172     close(m_device);
 173     return NULL;
 174 }
 175
 176
 177 ////////////////////////////////////////////////////////////////////////////
 178
 179 wxJoystick::wxJoystick(int joystick)
 180     : m_device(-1),
 181       m_joystick(joystick),
 182       m_thread(NULL)
 183 {
 184     wxString dev_name;
 185
 186      // old /dev structure
 187     dev_name.Printf( wxT("/dev/js%d"), joystick);
 188     m_device = open(dev_name.fn_str(), O_RDONLY);
 189
 190     // new /dev structure with "input" subdirectory
 191     if (m_device == -1)
 192     {
 193         dev_name.Printf( wxT("/dev/input/js%d"), joystick);
 194         m_device = open(dev_name.fn_str(), O_RDONLY);
 195     }
 196
 197     if (m_device != -1)
 198     {
 199         m_thread = new wxJoystickThread(m_device, m_joystick);
 200         m_thread->Create();
 201         m_thread->Run();
 202     }
 203 }
 204
 205
 206 wxJoystick::~wxJoystick()
 207 {
 208     ReleaseCapture();
 209     if (m_thread)
 210         m_thread->Delete();  // It's detached so it will delete itself
 211     m_device = -1;
 212 }
 213
 214
 215 ////////////////////////////////////////////////////////////////////////////
 216 // State
 217 ////////////////////////////////////////////////////////////////////////////
 218
 219 wxPoint wxJoystick::GetPosition() const
 220 {
 221     wxPoint pos(wxDefaultPosition);
 222     if (m_thread) pos = m_thread->m_lastposition;
 223     return pos;
 224 }
 225
 226 int wxJoystick::GetZPosition() const
 227 {
 228     if (m_thread)
 229         return m_thread->m_axe[wxJS_AXIS_Z];
 230     return 0;
 231 }
 232
 233 int wxJoystick::GetButtonState() const
 234 {
 235     if (m_thread)
 236         return m_thread->m_buttons;
 237     return 0;
 238 }
 239
 240 int wxJoystick::GetPOVPosition() const
 241 {
 242     return -1;
 243 }
 244
 245 int wxJoystick::GetPOVCTSPosition() const
 246 {
 247     return -1;
 248 }
 249
 250 int wxJoystick::GetRudderPosition() const
 251 {
 252     if (m_thread)
 253         return m_thread->m_axe[wxJS_AXIS_RUDDER];
 254     return 0;
 255 }
 256
 257 int wxJoystick::GetUPosition() const
 258 {
 259     if (m_thread)
 260         return m_thread->m_axe[wxJS_AXIS_U];
 261     return 0;
 262 }
 263
 264 int wxJoystick::GetVPosition() const
 265 {
 266     if (m_thread)
 267         return m_thread->m_axe[wxJS_AXIS_V];
 268     return 0;
 269 }
 270
 271 int wxJoystick::GetMovementThreshold() const
 272 {
 273     return 0;
 274 }
 275
 276 void wxJoystick::SetMovementThreshold(int threshold)
 277 {
 278 }
 279
 280 ////////////////////////////////////////////////////////////////////////////
 281 // Capabilities
 282 ////////////////////////////////////////////////////////////////////////////
 283
 284 bool wxJoystick::IsOk() const
 285 {
 286     return (m_device != -1);
 287 }
 288
 289 int wxJoystick::GetNumberJoysticks() const
 290 {
 291     wxString dev_name;
 292     int fd, j;
 293
 294     for (j=0; j<4; j++) {
 295         dev_name.Printf(wxT("/dev/js%d"), j);
 296         fd = open(dev_name.fn_str(), O_RDONLY);
 297         if (fd == -1)
 298             break;
 299         close(fd);
 300     }
 301
 302     if (j == 0) {
 303         for (j=0; j<4; j++) {
 304             dev_name.Printf(wxT("/dev/input/js%d"), j);
 305             fd = open(dev_name.fn_str(), O_RDONLY);
 306             if (fd == -1)
 307                 return j;
 308             close(fd);
 309         }
 310     }
 311
 312     return j;
 313 }
 314
 315 int wxJoystick::GetManufacturerId() const
 316 {
 317     return 0;
 318 }
 319
 320 int wxJoystick::GetProductId() const
 321 {
 322     return 0;
 323 }
 324
 325 wxString wxJoystick::GetProductName() const
 326 {
 327     char name[128];
 328
 329     if (ioctl(m_device, JSIOCGNAME(sizeof(name)), name) < 0)
 330         strcpy(name, "Unknown");
 331     return wxString(name, wxConvLibc);
 332 }
 333
 334 int wxJoystick::GetXMin() const
 335 {
 336     return wxJS_AXIS_MIN;
 337 }
 338
 339 int wxJoystick::GetYMin() const
 340 {
 341     return wxJS_AXIS_MIN;
 342 }
 343
 344 int wxJoystick::GetZMin() const
 345 {
 346     return wxJS_AXIS_MIN;
 347 }
 348
 349 int wxJoystick::GetXMax() const
 350 {
 351     return wxJS_AXIS_MAX;
 352 }
 353
 354 int wxJoystick::GetYMax() const
 355 {
 356     return wxJS_AXIS_MAX;
 357 }
 358
 359 int wxJoystick::GetZMax() const
 360 {
 361     return wxJS_AXIS_MAX;
 362 }
 363
 364 int wxJoystick::GetNumberButtons() const
 365 {
 366     char nb=0;
 367
 368     if (m_device != -1)
 369         ioctl(m_device, JSIOCGBUTTONS, &nb);
 370
 371     return nb;
 372 }
 373
 374 int wxJoystick::GetNumberAxes() const
 375 {
 376     char nb=0;
 377
 378     if (m_device != -1)
 379         ioctl(m_device, JSIOCGAXES, &nb);
 380
 381     return nb;
 382 }
 383
 384 int wxJoystick::GetMaxButtons() const
 385 {
 386     return 15; // internal
 387 }
 388
 389 int wxJoystick::GetMaxAxes() const
 390 {
 391     return 15; // internal
 392 }
 393
 394 int wxJoystick::GetPollingMin() const
 395 {
 396     return 10;
 397 }
 398
 399 int wxJoystick::GetPollingMax() const
 400 {
 401     return 1000;
 402 }
 403
 404 int wxJoystick::GetRudderMin() const
 405 {
 406     return wxJS_AXIS_MIN;
 407 }
 408
 409 int wxJoystick::GetRudderMax() const
 410 {
 411     return wxJS_AXIS_MAX;
 412 }
 413
 414 int wxJoystick::GetUMin() const
 415 {
 416     return wxJS_AXIS_MIN;
 417 }
 418
 419 int wxJoystick::GetUMax() const
 420 {
 421     return wxJS_AXIS_MAX;
 422 }
 423
 424 int wxJoystick::GetVMin() const
 425 {
 426     return wxJS_AXIS_MIN;
 427 }
 428
 429 int wxJoystick::GetVMax() const
 430 {
 431     return wxJS_AXIS_MAX;
 432 }
 433
 434 bool wxJoystick::HasRudder() const
 435 {
 436     return GetNumberAxes() >= wxJS_AXIS_RUDDER;
 437 }
 438
 439 bool wxJoystick::HasZ() const
 440 {
 441     return GetNumberAxes() >= wxJS_AXIS_Z;
 442 }
 443
 444 bool wxJoystick::HasU() const
 445 {
 446     return GetNumberAxes() >= wxJS_AXIS_U;
 447 }
 448
 449 bool wxJoystick::HasV() const
 450 {
 451     return GetNumberAxes() >= wxJS_AXIS_V;
 452 }
 453
 454 bool wxJoystick::HasPOV() const
 455 {
 456     return false;
 457 }
 458
 459 bool wxJoystick::HasPOV4Dir() const
 460 {
 461     return false;
 462 }
 463
 464 bool wxJoystick::HasPOVCTS() const
 465 {
 466     return false;
 467 }
 468
 469 ////////////////////////////////////////////////////////////////////////////
 470 // Operations
 471 ////////////////////////////////////////////////////////////////////////////
 472
 473 bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
 474 {
 475     if (m_thread)
 476     {
 477         m_thread->m_catchwin = win;
 478         m_thread->m_polling = pollingFreq;
 479         return true;
 480     }
 481     return false;
 482 }
 483
 484 bool wxJoystick::ReleaseCapture()
 485 {
 486     if (m_thread)
 487     {
 488         m_thread->m_catchwin = NULL;
 489         m_thread->m_polling = 0;
 490         return true;
 491     }
 492     return false;
 493 }
 494 #endif  // wxUSE_JOYSTICK
 495