lang/LangPrimSource/SC_LID.cpp

   1 /*
   2         Linux Input Device support.
   3         Copyright (c) 2004 stefan kersten.
   4         modifications by Marije Baalman 2006-9
   5
   6         ====================================================================
   7
   8         SuperCollider real time audio synthesis system
   9     Copyright (c) 2002 James McCartney. All rights reserved.
  10         http://www.audiosynth.com
  11
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; either version 2 of the License, or
  15     (at your option) any later version.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20     GNU General Public License for more details.
  21
  22     You should have received a copy of the GNU General Public License
  23     along with this program; if not, write to the Free Software
  24     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  25
  26         Linux Input Device interface, 2004 <sk>
  27 */
  28
  29 #include "SCBase.h"
  30 #include "VMGlobals.h"
  31 #include "PyrSymbolTable.h"
  32 #include "PyrInterpreter.h"
  33 #include "PyrKernel.h"
  34
  35 #include "PyrPrimitive.h"
  36 #include "PyrObjectProto.h"
  37 #include "PyrPrimitiveProto.h"
  38 #include "PyrKernelProto.h"
  39 #include "SC_InlineUnaryOp.h"
  40 #include "SC_InlineBinaryOp.h"
  41 #include "PyrSched.h"
  42 #include "GC.h"
  43
  44 #if HAVE_LID
  45 #include <errno.h>
  46 #include <fcntl.h>
  47 #include <linux/input.h>
  48 #include <stdio.h>
  49 #include <string.h>
  50 #include <sys/select.h>
  51 #include <sys/types.h>
  52 #include <unistd.h>
  53
  54 #define BITS_PER_LONG                   (sizeof(long) * 8)
  55 #define NBITS(x)                                ((((x) - 1) / BITS_PER_LONG) + 1)
  56 #define OFF(x)                                  ((x) % BITS_PER_LONG)
  57 #define BIT(x)                                  (1UL << OFF(x))
  58 #define LONG(x)                                 ((x) / BITS_PER_LONG)
  59 #define TEST_BIT(array, bit)    (((array)[LONG(bit)] >> OFF(bit)) & 1)
  60
  61 extern bool compiledOK;
  62
  63 static PyrSymbol* s_inputDeviceClass = 0;
  64 static PyrSymbol* s_inputDeviceInfoClass = 0;
  65 static PyrSymbol* s_absInfoClass = 0;
  66 static PyrSymbol* s_handleEvent = 0;
  67 static PyrSymbol* s_readError = 0;
  68
  69 // =====================================================================
  70 // SC_LID
  71
  72 struct SC_LID
  73 {
  74         SC_LID(PyrObject *obj);
  75         ~SC_LID();
  76
  77         int open(const char *path);
  78         int close();
  79
  80         bool isEventTypeSupported(int evtType);
  81         bool isEventCodeSupported(int evtType, int evtCode);
  82
  83         int getName(char* buf, size_t size);
  84         int getInfo(struct input_id *info, char *bufPhys, size_t sizePhys, char *bufUniq, size_t sizeUniq);
  85         int getKeyState(int evtCode);
  86         int getAbsInfo(int evtCode, struct input_absinfo *info);
  87
  88         int setLedState( int evtCode, int evtValue, int evtType );
  89
  90         int grab(int flag);
  91         void handleEvent(struct input_event& evt);
  92         void readError();
  93
  94         static PyrObject* getObject(PyrSlot* slot)
  95         {
  96                 return isKindOfSlot(slot, s_inputDeviceClass->u.classobj) ? slotRawObject(slot) : 0;
  97         }
  98
  99         static SC_LID* getDevice(PyrObject* obj)
 100         {
 101                 return (SC_LID*)slotRawPtr(&obj->slots[0]);
 102         }
 103
 104         SC_LID*                 m_next;
 105         PyrObject*              m_obj;
 106         int                     m_fd;
 107         int                     m_lastEventType;
 108         unsigned long           m_eventTypeCaps[NBITS(EV_MAX)];
 109         unsigned long           m_eventCodeCaps[NBITS(KEY_MAX)];
 110         unsigned long           m_keyState[NBITS(KEY_MAX)];
 111 };
 112
 113 // =====================================================================
 114 // SC_LIDManager
 115
 116 struct SC_LIDManager
 117 {
 118 public:
 119         static SC_LIDManager& instance();
 120
 121         int start();
 122         int stop();
 123
 124         int add(SC_LID *dev);
 125         int remove(SC_LID *dev);
 126
 127 private:
 128         SC_LIDManager();
 129         ~SC_LIDManager();
 130
 131         enum
 132         {
 133                 kStop,
 134                 kAdd,
 135                 kRemove
 136         };
 137
 138         struct Command
 139         {
 140                 int     id;
 141                 union
 142                 {
 143                         SC_LID* dev;
 144                 }       arg;
 145         };
 146
 147         int sendCommand(const Command& cmd);
 148         void devicesChanged();
 149         bool asyncAddDevice(SC_LID *dev);
 150         bool asyncRemoveDevice(SC_LID *dev);
 151         void loop();
 152
 153         static void* threadFunc(void*);
 154
 155         pthread_t               m_thread;
 156         pthread_mutex_t         m_mutex;
 157         bool                    m_running;
 158         int                     m_cmdFifo[2];
 159         int                     m_nfds;
 160         fd_set                  m_fds;
 161         SC_LID*                 m_devices;
 162 };
 163
 164 // =====================================================================
 165 // SC_LID
 166
 167 SC_LID::SC_LID(PyrObject* obj)
 168         : m_next(0),
 169           m_obj(obj),
 170           m_fd(-1),
 171           m_lastEventType(-1)
 172 {
 173         SetPtr(obj->slots+0, this);
 174 }
 175
 176 SC_LID::~SC_LID()
 177 {
 178         if (m_fd != -1) ::close(m_fd);
 179 }
 180
 181 int SC_LID::open(const char* path)
 182 {
 183         m_fd = ::open(path, O_RDWR);
 184
 185         if (m_fd == -1) {
 186                 error("LID (1): %s\n", strerror(errno));
 187                 return errFailed;
 188         }
 189
 190         memset(m_eventTypeCaps, 0, sizeof(m_eventTypeCaps));
 191         if (ioctl(m_fd, EVIOCGBIT(0, EV_MAX), m_eventTypeCaps) == -1) {
 192                 error("LID (2): %s\n", strerror(errno));
 193                 return errFailed;
 194         }
 195
 196         memset(m_keyState, 0, sizeof(m_keyState));
 197         if (ioctl(m_fd, EVIOCGKEY(sizeof(m_keyState)), m_keyState) == -1) {
 198                 error("LID (3): %s\n", strerror(errno));
 199                 return errFailed;
 200         }
 201
 202         return SC_LIDManager::instance().add(this);
 203 }
 204
 205 int SC_LID::close()
 206 {
 207         SetNil(m_obj->slots+0);
 208         return SC_LIDManager::instance().remove(this);
 209 }
 210
 211 bool SC_LID::isEventTypeSupported(int evtType)
 212 {
 213         return TEST_BIT(m_eventTypeCaps, evtType);
 214 }
 215
 216 bool SC_LID::isEventCodeSupported(int evtType, int evtCode)
 217 {
 218         if (evtType != m_lastEventType) {
 219                 m_lastEventType = evtType;
 220                 memset(m_eventCodeCaps, 0, sizeof(m_eventCodeCaps));
 221                 if (ioctl(m_fd, EVIOCGBIT(evtType, KEY_MAX), m_eventCodeCaps) == -1) {
 222                         post("LID failed to check event code (error %s)\n", strerror(errno));
 223                         return false;
 224                 }
 225         }
 226         return TEST_BIT(m_eventCodeCaps, evtCode);
 227 }
 228
 229 int SC_LID::getName(char* buf, size_t size)
 230 {
 231         if (ioctl(m_fd, EVIOCGNAME(size), buf) == -1) {
 232                 error("LID (5): %s\n", strerror(errno));
 233                 return errFailed;
 234         }
 235         return errNone;
 236 }
 237
 238 int SC_LID::getInfo(struct input_id *info, char *bufPhys, size_t sizePhys, char *bufUniq, size_t sizeUniq)
 239 {
 240         if (ioctl(m_fd, EVIOCGID, info) == -1) {
 241                 error("LID (6): %s\n", strerror(errno));
 242                 return errFailed;
 243         }
 244         if (ioctl(m_fd, EVIOCGPHYS(sizePhys), bufPhys) == -1) {
 245 //              strcpy( sizePhys, strerror(errno));
 246                 post("LID could not retrieve physical location (error: %s)\n", strerror(errno));
 247 //              return errFailed;
 248         }
 249         if (ioctl(m_fd, EVIOCGUNIQ(sizeUniq), bufUniq) == -1) {
 250 //              strcpy( strerror(errno), sizeof( strerror(errno)), sizeUniq );
 251                 post("LID could not get unique identifier (error: %s)\n", strerror(errno));
 252 //              return errFailed;
 253         }
 254
 255         return errNone;
 256 }
 257
 258 int SC_LID::getKeyState(int evtCode)
 259 {
 260         return TEST_BIT(m_keyState, evtCode);
 261 }
 262
 263 int SC_LID::getAbsInfo(int evtCode, struct input_absinfo* info)
 264 {
 265         if (ioctl(m_fd, EVIOCGABS(evtCode), info) == -1) {
 266                 error("LID (9): %s\n", strerror(errno));
 267                 return errFailed;
 268         }
 269         return errNone;
 270 }
 271
 272 int SC_LID::setLedState( int evtCode, int evtValue, int evtType )
 273 { // added by marije baalman
 274         struct input_event ev;
 275 //      post( "set led state called, putting event" );
 276         ev.code = evtCode;
 277         ev.value = evtValue;
 278         ev.type = evtType;
 279 //      post( "m_fd %i", m_fd );
 280 //      post( "code %i, value %i ", evtCode, evtValue );
 281         if ( write(m_fd, &ev, sizeof(struct input_event)) == -1 )
 282                 {
 283 //              post( "error writing event" );
 284                 return errFailed;
 285                 }
 286         return errNone;
 287 }
 288
 289 int SC_LID::grab(int flag)
 290 {
 291         if (ioctl(m_fd, EVIOCGRAB, flag) == -1) {
 292                 error("LID (10): %s\n", strerror(errno));
 293                 return errFailed;
 294         }
 295         return errNone;
 296 }
 297
 298 void SC_LID::handleEvent(struct input_event& evt)
 299 {
 300         if (evt.type != EV_SYN) {
 301                 pthread_mutex_lock(&gLangMutex);
 302                 if (compiledOK) {
 303                         VMGlobals* g = gMainVMGlobals;
 304                         g->canCallOS = false;
 305                         ++g->sp; SetObject(g->sp, m_obj);
 306                         ++g->sp; SetInt(g->sp, evt.type);
 307                         ++g->sp; SetInt(g->sp, evt.code);
 308                         ++g->sp; SetInt(g->sp, evt.value);
 309                         runInterpreter(g, s_handleEvent, 4);
 310                         g->canCallOS = false;
 311                 }
 312                 pthread_mutex_unlock(&gLangMutex);
 313         }
 314 }
 315
 316 void SC_LID::readError()
 317 {
 318         pthread_mutex_lock(&gLangMutex);
 319         if (compiledOK) {
 320                 VMGlobals* g = gMainVMGlobals;
 321                 g->canCallOS = false;
 322                 ++g->sp; SetObject(g->sp, m_obj);
 323                 runInterpreter(g, s_readError, 1);
 324                 g->canCallOS = false;
 325         }
 326         pthread_mutex_unlock(&gLangMutex);
 327 }
 328
 329 // =====================================================================
 330 // SC_LIDManager
 331
 332 SC_LIDManager& SC_LIDManager::instance()
 333 {
 334         static SC_LIDManager instance;
 335         return instance;
 336 }
 337
 338 SC_LIDManager::SC_LIDManager()
 339         : m_running(false),
 340           m_devices(0)
 341 {
 342         if (pipe(m_cmdFifo) == -1) {
 343                 m_cmdFifo[0] = m_cmdFifo[1] = -1;
 344         }
 345         devicesChanged();
 346 }
 347
 348 SC_LIDManager::~SC_LIDManager()
 349 {
 350         close(m_cmdFifo[0]);
 351         close(m_cmdFifo[1]);
 352 }
 353
 354 int SC_LIDManager::start()
 355 {
 356         int err;
 357         err = pthread_create(&m_thread, 0, &threadFunc, this);
 358         if (err != 0) return errFailed;
 359         return errNone;
 360 }
 361
 362 int SC_LIDManager::stop()
 363 {
 364         if (m_running == false)
 365                 return errNone;
 366
 367         Command cmd;
 368
 369         cmd.id = kStop;
 370         int err = sendCommand(cmd);
 371         if (err) return err;
 372
 373         err = pthread_join(m_thread, 0);
 374         if (err != 0) return errFailed;
 375
 376         return errNone;
 377 }
 378
 379 int SC_LIDManager::add(SC_LID* dev)
 380 {
 381         Command cmd;
 382         cmd.id = kAdd;
 383         cmd.arg.dev = dev;
 384         return sendCommand(cmd);
 385 }
 386
 387 int SC_LIDManager::remove(SC_LID* dev)
 388 {
 389         Command cmd;
 390         cmd.id = kRemove;
 391         cmd.arg.dev = dev;
 392         return sendCommand(cmd);
 393 }
 394
 395 int SC_LIDManager::sendCommand(const Command& cmd)
 396 {
 397         return write(m_cmdFifo[1], &cmd, sizeof(cmd)) == sizeof(cmd) ? errNone : errFailed;
 398 }
 399
 400 void SC_LIDManager::devicesChanged()
 401 {
 402         int fdMax = m_cmdFifo[0];
 403
 404         FD_ZERO(&m_fds);
 405         FD_SET(fdMax, &m_fds);
 406
 407         SC_LID *dev = m_devices;
 408         while (dev) {
 409                 int fd = dev->m_fd;
 410                 if (fd != -1) {
 411                         FD_SET(fd, &m_fds);
 412                         if (fd > fdMax) fdMax = fd;
 413                 }
 414                 dev = dev->m_next;
 415         }
 416
 417         m_nfds = fdMax + 1;
 418 }
 419
 420 bool SC_LIDManager::asyncAddDevice(SC_LID* dev)
 421 {
 422         if (dev->m_next) return false;
 423         dev->m_next = m_devices;
 424         m_devices = dev;
 425         devicesChanged();
 426         return true;
 427 }
 428
 429 bool SC_LIDManager::asyncRemoveDevice(SC_LID* dev)
 430 {
 431         SC_LID *prev = 0, *cur = m_devices;
 432
 433         while (cur) {
 434                 if (cur == dev) {
 435                         if (prev) prev->m_next = dev->m_next;
 436                         else m_devices = dev->m_next;
 437                         dev->m_next = 0;
 438                         delete dev;
 439                         devicesChanged();
 440                         return true;
 441                 }
 442                 prev = cur;
 443                 cur = cur->m_next;
 444         }
 445
 446         return false;
 447 }
 448
 449 void* SC_LIDManager::threadFunc(void* arg)
 450 {
 451         ((SC_LIDManager*)arg)->loop();
 452         return 0;
 453 }
 454
 455 void SC_LIDManager::loop()
 456 {
 457         m_running = true;
 458         post("LID: event loop started\n");
 459
 460         while (true) {
 461                 fd_set fds;
 462                 memcpy(&fds, &m_fds, sizeof(fd_set));
 463                 int n = select(m_nfds, &fds, 0, 0, 0);
 464                 if (n == -1) {
 465                         if( errno == EINTR ) continue;
 466                         post("LID: error in input handler: %s\n", strerror(errno));
 467                         goto quit;
 468                 } else if (n > 0) {
 469                         if (FD_ISSET(m_cmdFifo[0], &fds)) {
 470                                 Command cmd;
 471                                 --n;
 472                                 int err = read(m_cmdFifo[0], &cmd, sizeof(cmd));
 473                                 if (err == -1) {
 474                                         if( errno != EINTR ) {
 475                                                 post("LID: error in input handler: %s\n", strerror(errno));
 476                                                 goto quit;
 477                                         }
 478                                 }
 479                                 else {
 480                                         switch (cmd.id) {
 481                                                 case kStop:
 482                                                         goto quit;
 483                                                 case kAdd:
 484                                                         if (asyncAddDevice(cmd.arg.dev)) {
 485                                                                 post("LID: added device %p\n", cmd.arg);
 486                                                         } else {
 487                                                                 post("LID: cannot add device\n");
 488                                                         }
 489                                                         break;
 490                                                 case kRemove:
 491                                                         if (asyncRemoveDevice(cmd.arg.dev)) {
 492                                                                 post("LID: removed device %p\n", cmd.arg);
 493                                                         } else {
 494                                                                 post("LID: couldn't remove device\n");
 495                                                         }
 496                                                         break;
 497                                                 default:
 498                                                         post("LID: unknown command in input handler\n");
 499                                         }
 500                                 }
 501                         }
 502                         if (n > 0) {
 503                                 SC_LID *dev = m_devices;
 504                                 while (dev) {
 505                                         int fd = dev->m_fd;
 506                                         if (FD_ISSET(fd, &fds)) {
 507                                                 struct input_event evt;
 508                                                 if (read(fd, &evt, sizeof(evt)) == sizeof(evt)) {
 509                                                         dev->handleEvent(evt);
 510                                                 }
 511                                                 else {
 512                                                         dev->readError();
 513                                                 }
 514                                         }
 515                                         dev = dev->m_next;
 516                                 }
 517                         }
 518                 }
 519         }
 520
 521  quit:
 522         m_running = false;
 523         post("LID: event loop stopped\n");
 524 }
 525
 526 // =====================================================================
 527 // Primitive Interface
 528
 529 int prLID_Open(VMGlobals *g, int numArgsPushed)
 530 {
 531         PyrSlot* args = g->sp - 1;
 532         int err;
 533
 534         PyrObject* obj = SC_LID::getObject(args+0);
 535         if (!obj) return errWrongType;
 536
 537         char path[PATH_MAX];
 538         err = slotStrVal(args+1, path, sizeof(path));
 539         if (err) return err;
 540
 541         SC_LID* dev = new SC_LID(obj);
 542         err = dev->open(path);
 543         if (err) {
 544                 delete dev;
 545                 return err;
 546         }
 547
 548         return errNone;
 549 }
 550
 551 int prLID_Close(VMGlobals *g, int numArgsPushed)
 552 {
 553         PyrSlot* args = g->sp;
 554
 555         PyrObject* obj = SC_LID::getObject(args+0);
 556         if (!obj) return errWrongType;
 557
 558         SC_LID* dev = SC_LID::getDevice(obj);
 559         if (!dev) return errFailed;
 560
 561         return dev->close();
 562 }
 563
 564 int prLID_EventTypeSupported(VMGlobals *g, int numArgsPushed)
 565 {
 566         PyrSlot* args = g->sp - 1;
 567         int evtType;
 568         int err;
 569
 570         if (!g->canCallOS) return errCantCallOS;
 571
 572         PyrObject* obj = SC_LID::getObject(args+0);
 573         if (!obj) return errWrongType;
 574
 575         err = slotIntVal(args+1, &evtType);
 576         if (err) return err;
 577
 578         SC_LID* dev = SC_LID::getDevice(obj);
 579         if (!dev) return errFailed;
 580
 581         SetBool(args, dev->isEventTypeSupported(evtType));
 582
 583         return errNone;
 584 }
 585
 586 int prLID_EventCodeSupported(VMGlobals *g, int numArgsPushed)
 587 {
 588         PyrSlot* args = g->sp - 2;
 589         int evtType, evtCode;
 590         int err;
 591
 592         if (!g->canCallOS) return errCantCallOS;
 593
 594         PyrObject* obj = SC_LID::getObject(args+0);
 595         if (!obj) return errWrongType;
 596
 597         err = slotIntVal(args+1, &evtType);
 598         if (err) return err;
 599
 600         err = slotIntVal(args+2, &evtCode);
 601         if (err) return err;
 602
 603         SC_LID* dev = SC_LID::getDevice(obj);
 604         if (!dev) return errFailed;
 605
 606         SetBool(args, dev->isEventCodeSupported(evtType, evtCode));
 607
 608         return errNone;
 609 }
 610
 611 int prLID_GetInfo(VMGlobals* g, int numArgsPushed)
 612 {
 613         PyrSlot* args = g->sp - 1;
 614         int err;
 615
 616         PyrObject* obj = SC_LID::getObject(args+0);
 617         if (!obj) return errWrongType;
 618
 619         if (!isKindOfSlot(args+1, s_inputDeviceInfoClass->u.classobj))
 620                 return errWrongType;
 621         PyrObject* infoObj = slotRawObject(&args[1]);
 622
 623         SC_LID* dev = SC_LID::getDevice(obj);
 624         if (!dev) return errFailed;
 625
 626         char name[128];
 627         err = dev->getName(name, sizeof(name));
 628         if (err) return err;
 629
 630         struct input_id info;
 631         char namePhys[128];
 632         char nameUniq[128];
 633         err = dev->getInfo(&info, namePhys, sizeof( namePhys ), nameUniq, sizeof( nameUniq ) );
 634         if (err) return err;
 635
 636         SetSymbol(infoObj->slots+0, getsym(name));
 637         SetInt(infoObj->slots+1, info.bustype);
 638         SetInt(infoObj->slots+2, info.vendor);
 639         SetInt(infoObj->slots+3, info.product);
 640         SetInt(infoObj->slots+4, info.version);
 641         SetSymbol(infoObj->slots+5, getsym(namePhys));
 642         SetSymbol(infoObj->slots+6, getsym(nameUniq));
 643
 644         slotCopy(&args[0], &args[1]);
 645
 646         return errNone;
 647 }
 648
 649 int prLID_GetKeyState(VMGlobals *g, int numArgsPushed)
 650 {
 651         PyrSlot* args = g->sp - 1;
 652         int evtCode;
 653         int err;
 654
 655         PyrObject* obj = SC_LID::getObject(args+0);
 656         if (!obj) return errWrongType;
 657
 658         err = slotIntVal(args+1, &evtCode);
 659         if (err) return err;
 660
 661         SC_LID* dev = SC_LID::getDevice(obj);
 662         if (!dev) return errFailed;
 663
 664         SetInt(args, dev->getKeyState(evtCode));
 665
 666         return errNone;
 667 }
 668
 669 int prLID_GetAbsInfo(VMGlobals *g, int numArgsPushed)
 670 {
 671         PyrSlot* args = g->sp - 2;
 672         int evtCode;
 673         int err;
 674
 675         PyrObject* obj = SC_LID::getObject(args+0);
 676         if (!obj) return errWrongType;
 677
 678         err = slotIntVal(args+1, &evtCode);
 679         if (err) return err;
 680
 681         if (!isKindOfSlot(args+2, s_absInfoClass->u.classobj))
 682                 return errWrongType;
 683         PyrObject* infoObj = slotRawObject(&args[2]);
 684
 685         SC_LID* dev = SC_LID::getDevice(obj);
 686         if (!dev) return errFailed;
 687
 688         struct input_absinfo info;
 689         err = dev->getAbsInfo(evtCode, &info);
 690         if (err) return err;
 691
 692         SetInt(infoObj->slots+0, info.value);
 693         SetInt(infoObj->slots+1, info.minimum);
 694         SetInt(infoObj->slots+2, info.maximum);
 695         SetInt(infoObj->slots+3, info.fuzz);
 696         SetInt(infoObj->slots+4, info.flat);
 697
 698         slotCopy(&args[0], &args[2]);
 699
 700         return errNone;
 701 }
 702
 703 int prLID_Grab(VMGlobals *g, int numArgsPushed)
 704 {
 705         PyrSlot* args = g->sp - 1;
 706
 707         PyrObject* obj = SC_LID::getObject(args+0);
 708         if (!obj) return errWrongType;
 709
 710         SC_LID* dev = SC_LID::getDevice(obj);
 711         if (!dev) return errFailed;
 712
 713         return dev->grab(IsTrue(args+1));
 714 }
 715
 716 int prLID_Start(VMGlobals* g, int numArgsPushed)
 717 {
 718 //      if (!g->canCallOS) return errCantCallOS;
 719         return SC_LIDManager::instance().start();
 720 }
 721
 722 int prLID_Stop(VMGlobals* g, int numArgsPushed)
 723 {
 724 //      if (!g->canCallOS) return errCantCallOS;
 725         return SC_LIDManager::instance().stop();
 726 }
 727
 728 int prLID_SetLedState(VMGlobals *g, int numArgsPushed)
 729 {
 730 //      post( "set led state primitive called" );
 731         PyrSlot* args = g->sp - 2;
 732         int evtCode, evtValue;
 733         int err;
 734
 735         PyrObject* obj = SC_LID::getObject(args+0);
 736         if (!obj) return errWrongType;
 737
 738         err = slotIntVal(args+1, &evtCode);
 739         if (err) return err;
 740
 741         err = slotIntVal(args+2, &evtValue);
 742         if (err) return err;
 743
 744         SC_LID* dev = SC_LID::getDevice(obj);
 745         if (!dev) return errFailed;
 746
 747         SetInt(args, dev->setLedState(evtCode,evtValue, EV_LED));
 748         return errNone;
 749 }
 750
 751 int prLID_SetMscState(VMGlobals *g, int numArgsPushed)
 752 {
 753 //      post( "set msc state primitive called\n" );
 754         PyrSlot* args = g->sp - 2;
 755         int evtCode, evtValue;
 756         int err;
 757
 758         PyrObject* obj = SC_LID::getObject(args+0);
 759         if (!obj) return errWrongType;
 760
 761         err = slotIntVal(args+1, &evtCode);
 762         if (err) return err;
 763
 764         err = slotIntVal(args+2, &evtValue);
 765         if (err) return err;
 766
 767         SC_LID* dev = SC_LID::getDevice(obj);
 768         if (!dev) return errFailed;
 769
 770         SetInt(args, dev->setLedState(evtCode,evtValue, EV_MSC));
 771         return errNone;
 772 }
 773
 774 void SC_LIDInit()
 775 {
 776         int base, index;
 777
 778         s_inputDeviceClass = getsym("LID");
 779         s_inputDeviceInfoClass = getsym("LIDInfo");
 780         s_absInfoClass = getsym("LIDAbsInfo");
 781         s_handleEvent = getsym("prHandleEvent");
 782         s_readError = getsym("prReadError");
 783
 784         base = nextPrimitiveIndex();
 785         index = 0;
 786
 787         definePrimitive(base, index++, "_LID_Open", prLID_Open, 2, 0);
 788         definePrimitive(base, index++, "_LID_Close", prLID_Close, 1, 0);
 789         definePrimitive(base, index++, "_LID_EventTypeSupported", prLID_EventTypeSupported, 2, 0);
 790         definePrimitive(base, index++, "_LID_EventCodeSupported", prLID_EventCodeSupported, 3, 0);
 791         definePrimitive(base, index++, "_LID_GetInfo", prLID_GetInfo, 2, 0);
 792         definePrimitive(base, index++, "_LID_GetKeyState", prLID_GetKeyState, 2, 0);
 793         definePrimitive(base, index++, "_LID_GetAbsInfo", prLID_GetAbsInfo, 3, 0);
 794         definePrimitive(base, index++, "_LID_Grab", prLID_Grab, 2, 0);
 795         definePrimitive(base, index++, "_LID_Start", prLID_Start, 1, 0);
 796         definePrimitive(base, index++, "_LID_Stop", prLID_Stop, 1, 0);
 797         definePrimitive(base, index++, "_LID_SetLedState", prLID_SetLedState, 3, 0); // added by Marije Baalman
 798         definePrimitive(base, index++, "_LID_SetMscState", prLID_SetMscState, 3, 0);
 799 }
 800 #else // !HAVE_LID
 801 int prLID_Start(VMGlobals* g, int numArgsPushed)
 802 {
 803         return errNone;
 804 }
 805
 806 int prLID_Stop(VMGlobals* g, int numArgsPushed)
 807 {
 808         return errNone;
 809 }
 810
 811 void SC_LIDInit()
 812 {
 813         int base, index;
 814
 815         base = nextPrimitiveIndex();
 816         index = 0;
 817
 818         definePrimitive(base, index++, "_LID_Start", prLID_Start, 1, 0);
 819         definePrimitive(base, index++, "_LID_Stop", prLID_Stop, 1, 0);
 820 }
 821 #endif // HAVE_LID
 822
 823 void initHIDPrimitives()
 824 {
 825         SC_LIDInit();
 826 }
 827
 828 // EOF