cinelerra-5.1/cinelerra/shuttle.C

   1 #ifdef HAVE_SHUTTLE
   2 // Copyright 2013 Eric Messick (FixedImagePhoto.com/Contact)
   3 // reworked 2019 for cinelerra-gg by William Morrow
   4
   5 #include "arraylist.h"
   6 #include "cstrdup.h"
   7 #include "file.h"
   8 #include "guicast.h"
   9 #include "keys.h"
  10 #include "linklist.h"
  11 #include "loadfile.h"
  12 #include "mainmenu.h"
  13 #include "shuttle.h"
  14 #include "thread.h"
  15
  16 #include "mwindow.h"
  17 #include "mwindowgui.h"
  18 #include "awindow.h"
  19 #include "awindowgui.h"
  20 #include "cwindow.h"
  21 #include "cwindowgui.h"
  22 #include "vwindow.h"
  23 #include "vwindowgui.h"
  24
  25 #include <stdio.h>
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <string.h>
  31 #include <sys/time.h>
  32 #include <sys/stat.h>
  33
  34 #include <X11/Xlib.h>
  35 #include <X11/keysym.h>
  36
  37 static Time milliTimeClock()
  38 {
  39         struct timeval tv;
  40         gettimeofday(&tv, 0);
  41         return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
  42 }
  43
  44 KeySymMapping KeySymMapping::key_sym_mapping[] = {
  45 // button keycodes
  46         { "XK_Button_1", XK_Button_1 },
  47         { "XK_Button_2", XK_Button_2 },
  48         { "XK_Button_3", XK_Button_3 },
  49         { "XK_Scroll_Up", XK_Scroll_Up },
  50         { "XK_Scroll_Down", XK_Scroll_Down },
  51 #include "shuttle_keys.h"
  52         { NULL, 0 }
  53 };
  54
  55 int KeySymMapping::get_mask(const char *&str)
  56 {
  57         int mask = 0;
  58         while( *str ) {
  59                 if( !strncmp("Shift-",str,6) ) {
  60                         mask |= ShiftMask;
  61                         str += 6;  continue;
  62                 }
  63                 if( !strncmp("Ctrl-",str,5) ) {
  64                         mask |= ControlMask;
  65                         str += 5;  continue;
  66                 }
  67                 else if( !strncmp("Alt-",str,4) ) {
  68                         mask |= Mod1Mask;
  69                         str += 4;  continue;
  70                 }
  71                 break;
  72         }
  73         return mask;
  74 }
  75
  76 SKeySym KeySymMapping::to_keysym(const char *str)
  77 {
  78         if( !strncmp("FWD_",str, 4) ) {
  79                 float speed = atof(str+4) / SHUTTLE_MAX_SPEED;
  80                 if( speed > SHUTTLE_MAX_SPEED ) return 0;
  81                 int key_code = (SKEY_MAX+SKEY_MIN)/2. +
  82                         (SKEY_MAX-SKEY_MIN)/2. * speed;
  83                 if( key_code > SKEY_MAX ) key_code = SKEY_MAX;
  84                 return key_code;
  85         }
  86         if( !strncmp("REV_",str, 4) ) {
  87                 float speed = atof(str+4) / SHUTTLE_MAX_SPEED;
  88                 if( speed > SHUTTLE_MAX_SPEED ) return 0;
  89                 int key_code = (SKEY_MAX+SKEY_MIN)/2. -
  90                         (SKEY_MAX-SKEY_MIN)/2. * speed;
  91                 if( key_code < SKEY_MIN ) key_code = SKEY_MIN;
  92                 return key_code;
  93         }
  94         int mask = get_mask(str);
  95         for( KeySymMapping *ksp = &key_sym_mapping[0]; ksp->str; ++ksp )
  96                 if( !strcmp(str, ksp->str) )
  97                         return SKeySym(ksp->sym, mask);
  98         return 0;
  99 }
 100
 101 const char *KeySymMapping::to_string(SKeySym ks)
 102 {
 103         for( KeySymMapping *ksp = &key_sym_mapping[0]; ksp->sym.key; ++ksp ) {
 104                 if( ksp->sym.key == ks.key ) {
 105                         static char string[BCSTRLEN];
 106                         char *sp = string, *ep = sp+sizeof(string);
 107                         if( ks.msk & Mod1Mask ) sp += snprintf(sp, ep-sp, "Alt-");
 108                         if( ks.msk & ControlMask ) sp += snprintf(sp, ep-sp, "Ctrl-");
 109                         if( ks.msk & ShiftMask ) sp += snprintf(sp, ep-sp, "Shift-");
 110                         snprintf(sp, ep-sp, "%s", ksp->str);
 111                         return string;
 112                 }
 113         }
 114         if( ks >= SKEY_MIN && ks <= SKEY_MAX ) {
 115                 double speed = SHUTTLE_MAX_SPEED *
 116                         (ks-(SKEY_MAX+SKEY_MIN)/2.) / ((SKEY_MAX-SKEY_MIN)/2.);
 117                 static char text[BCSTRLEN];
 118                 sprintf(text, "%s_%0.3f", speed>=0 ? "FWD" : "REV", fabs(speed));
 119                 char *bp = strchr(text,'.');
 120                 if( bp ) {
 121                         char *cp = bp+strlen(bp);
 122                         while( --cp>bp && *cp=='0' ) *cp=0;
 123                         if( cp == bp ) *cp = 0;
 124                 }
 125                 return text;
 126         }
 127         return 0;
 128 }
 129
 130 TransName::TransName(int cin, const char *nm, const char *re)
 131 {
 132         this->cin = cin;
 133         this->name = cstrdup(nm);
 134 }
 135 TransName::~TransName()
 136 {
 137         delete [] name;
 138 }
 139
 140 void Translation::init(int def)
 141 {
 142         is_default = def;
 143         is_key = 0;
 144         first_release_stroke = 0;
 145         pressed = 0;
 146         released = 0;
 147         keysym_down = 0;
 148 }
 149
 150 Translation::Translation(Shuttle *shuttle)
 151  : modifiers(this)
 152 { // initial default translation
 153         init(1);
 154         this->shuttle = shuttle;
 155         this->name = cstrdup("Default");
 156         names.append(new TransName(FOCUS_DEFAULT, name, ""));
 157         key_down[K6].add_stroke(XK_Button_1, 1);
 158         key_up[K6].add_stroke(XK_Button_1, 0);
 159         key_down[K7].add_stroke(XK_Button_2, 1);
 160         key_up[K7].add_stroke(XK_Button_2, 0);
 161         key_down[K8].add_stroke(XK_Button_3, 1);
 162         key_up[K8].add_stroke(XK_Button_3, 0);
 163         jog[JL].add_stroke(XK_Scroll_Up, 1);
 164         jog[JL].add_stroke(XK_Scroll_Up, 0);
 165         jog[JR].add_stroke(XK_Scroll_Down, 0);
 166         jog[JR].add_stroke(XK_Scroll_Down, 1);
 167 }
 168
 169 Translation::Translation(Shuttle *shuttle, const char *name)
 170  : modifiers(this)
 171 {
 172         init(0);
 173         this->shuttle = shuttle;
 174         this->name = cstrdup(name);
 175 }
 176
 177 Translation::~Translation()
 178 {
 179         delete [] name;
 180 }
 181
 182 void Translation::clear()
 183 {
 184         names.remove_all_objects();
 185         init(0);
 186         for( int i=0; i<NUM_KEYS; ++i ) key_down[i].clear();
 187         for( int i=0; i<NUM_KEYS; ++i ) key_up[i].clear();
 188         for( int i=0; i<NUM_SHUTTLES; ++i ) shuttles[i].clear();
 189         for( int i=0; i<NUM_JOGS; ++i ) jog[i].clear();
 190 }
 191
 192 void Translation::append_stroke(SKeySym sym, int press)
 193 {
 194         Stroke *s = pressed_strokes->append();
 195         s->keysym = sym;
 196         s->press = press;
 197 }
 198
 199 void Translation::add_keysym(SKeySym sym, int press_release)
 200 {
 201 //printf("add_keysym(0x%x, %d)\n", (int)sym, press_release);
 202         switch( press_release ) {
 203         case PRESS:
 204                 append_stroke(sym, 1);
 205                 modifiers.mark_as_down(sym, 0);
 206                 break;
 207         case RELEASE:
 208                 append_stroke(sym, 0);
 209                 modifiers.mark_as_up(sym);
 210                 break;
 211         case HOLD:
 212                 append_stroke(sym, 1);
 213                 modifiers.mark_as_down(sym, 1);
 214                 break;
 215         case PRESS_RELEASE:
 216         default:
 217                 if( first_release_stroke ) {
 218                         modifiers.re_press();
 219                         first_release_stroke = 0;
 220                 }
 221                 if( keysym_down ) {
 222                         append_stroke(keysym_down, 0);
 223                 }
 224                 append_stroke(sym, 1);
 225                 keysym_down = sym;
 226                 break;
 227         }
 228 }
 229
 230 void Translation::add_release(int all_keys)
 231 {
 232 //printf("add_release(%d)\n", all_keys);
 233         modifiers.release(all_keys);
 234         if( !all_keys )
 235                 pressed_strokes = released_strokes;
 236         if( keysym_down ) {
 237                 append_stroke(keysym_down, 0);
 238                 keysym_down = 0;
 239         }
 240         first_release_stroke = 1;
 241 }
 242
 243 void Translation::add_keystroke(const char *keySymName, int press_release)
 244 {
 245         SKeySym sym;
 246
 247         if( is_key && !strncmp(keySymName, "RELEASE", 8) ) {
 248                 add_release(0);
 249                 return;
 250         }
 251         sym = KeySymMapping::to_keysym(keySymName);
 252         if( sym != 0 ) {
 253                 add_keysym(sym, press_release);
 254         }
 255         else
 256                 fprintf(stderr, "unrecognized KeySym: %s\n", keySymName);
 257 }
 258
 259 void Translation::add_string(char *&str)
 260 {
 261         int delim = *str++;
 262         if( !delim ) return;
 263         while( str && *str && *str!=delim ) {
 264                 if( *str < ' ' || *str > '~' ) continue;
 265                 int mask = KeySymMapping::get_mask((const char *&)str);
 266                 if( str[0] == '\\' && str[1] ) ++str;
 267                 add_keysym(SKeySym(*str++, mask), PRESS_RELEASE);
 268                 mask = 0;
 269         }
 270         if( *str == delim ) ++str;
 271 }
 272
 273 int Translation::start_line(const char *key)
 274 {
 275         pressed_strokes = 0;
 276         released_strokes = 0;
 277         pressed = released = 0;
 278         is_key = 0;
 279         if( !strcasecmp("JL", key) ) {
 280                 pressed = &jog[0];
 281         }
 282         else if( !strcasecmp("JR", key) ) {
 283                 pressed = &jog[1];
 284         }
 285         else {
 286                 char c = 0;  int k = -1, n = 0;
 287                 if( sscanf(key, "%c%d%n", &c, &k, &n) != 2 ) return 1;
 288                 switch( c ) {
 289                 case 'K': case 'k':
 290                         --k;
 291                         if( k >= K1 && k <= K15 ) {
 292                                 pressed = &key_down[k];
 293                                 released = &key_up[k];
 294                                 is_key = 1;
 295                         }
 296                         break;
 297                 case 'S': case 's':
 298                         if( k >= S_7 && k <= S7 ) {
 299                                 pressed = &shuttles[k-S_7];
 300                         }
 301                         break;
 302                 }
 303                 if( !pressed ) {
 304                         fprintf(stderr, "bad key name: [%s]%s\n", name, key);
 305                         return 1;
 306                 }
 307                 if( pressed->first ) {
 308                         fprintf(stderr, "dupl key name: [%s]%s\n", name, key);
 309                         return 1;
 310                 }
 311         }
 312         pressed_strokes = pressed;
 313         released_strokes = released;
 314         return 0;
 315 }
 316
 317 void Translation::print_stroke(Stroke *s)
 318 {
 319         if( !s ) return;
 320         const char *cp = KeySymMapping::to_string(s->keysym);
 321         if( !cp ) { printf("0x%x", (int)s->keysym); cp = "???"; }
 322         printf("%s/%c ", cp, s->press ? 'D' : 'U');
 323 }
 324
 325 void Translation::print_strokes(const char *name, const char *up_dn, Strokes *strokes)
 326 {
 327         printf("%s[%s]: ", name, up_dn);
 328         for( Stroke *s=strokes->first; s; s=s->next )
 329                 print_stroke(s);
 330         printf("\n");
 331 }
 332
 333 void Translation::finish_line()
 334 {
 335 //printf("finish_line()\n");
 336         if( is_key ) {
 337                 add_release(0);
 338         }
 339         add_release(1);
 340 }
 341
 342 void Translation::print_line(const char *key)
 343 {
 344         if( is_key ) {
 345                 print_strokes(key, "D", pressed);
 346                 print_strokes(key, "U", released);
 347         }
 348         else {
 349                 print_strokes(key, "", pressed);
 350         }
 351         printf("\n");
 352 }
 353
 354 // press values in Modifiers:
 355 // PRESS -> down
 356 // HOLD -> held
 357 // PRESS_RELEASE -> released, but to be re-pressed if necessary
 358 // RELEASE -> up
 359
 360 void Modifiers::mark_as_down(SKeySym sym, int hold)
 361 {
 362         Modifiers &modifiers = *this;
 363         for( int i=0; i<size(); ++i ) {
 364                 Stroke &s = modifiers[i];
 365                 if( s.keysym == sym ) {
 366                         s.press = hold ? HOLD : PRESS;
 367                         return;
 368                 }
 369         }
 370         Stroke &s = append();
 371         s.keysym = sym;
 372         s.press = hold ? HOLD : PRESS;
 373 }
 374
 375 void Modifiers::mark_as_up(SKeySym sym)
 376 {
 377         Modifiers &modifiers = *this;
 378         for( int i=0; i<size(); ++i ) {
 379                 Stroke &s = modifiers[i];
 380                 if( s.keysym == sym ) {
 381                         s.press = RELEASE;
 382                         return;
 383                 }
 384         }
 385 }
 386
 387 void Modifiers::release(int allkeys)
 388 {
 389         Modifiers &modifiers = *this;
 390         for( int i=0; i<size(); ++i ) {
 391                 Stroke &s = modifiers[i];
 392                 if( s.press == PRESS ) {
 393                         trans->append_stroke(s.keysym, 0);
 394                         s.press = PRESS_RELEASE;
 395                 }
 396                 else if( allkeys && s.press == HOLD ) {
 397                         trans->append_stroke(s.keysym, 0);
 398                         s.press = RELEASE;
 399                 }
 400         }
 401 }
 402
 403 void Modifiers::re_press()
 404 {
 405         Modifiers &modifiers = *this;
 406         for( int i=0; i<size(); ++i ) {
 407                 Stroke &s = modifiers[i];
 408                 if( s.press == PRESS_RELEASE ) {
 409                         trans->append_stroke(s.keysym, 1);
 410                         s.press = PRESS;
 411                 }
 412         }
 413 }
 414
 415
 416 Shuttle::Shuttle(MWindow *mwindow)
 417  : Thread(1, 0, 0)
 418 {
 419         this->mwindow = mwindow;
 420
 421         fd = -1;
 422         wdw = 0;
 423         win = 0;
 424         msk = 0;
 425         rx = ry = 0;
 426         wx = wy = 0;
 427         jogvalue = 0xffff;
 428         shuttlevalue = 0xffff;
 429         dev_index = -1;
 430
 431         done = -1;
 432         failed = 0;
 433         first_time = 1;
 434         tr = 0;
 435         debug = 0;
 436         usb_direct = 0;
 437
 438         last_translation = 0;
 439         last_focused = 0;
 440
 441 #ifdef HAVE_SHUTTLE_USB
 442         devsh = 0;
 443         claimed = -1;
 444         last_jog = 0;
 445         last_shuttle = 0;
 446         last_btns = 0;
 447 #endif
 448
 449         default_translation = new Translation(this);
 450         config_path = 0;
 451         config_mtime = 0;
 452         ev.type = ~0;
 453 }
 454
 455 Shuttle::~Shuttle()
 456 {
 457         stop();
 458         delete default_translation;
 459         delete [] config_path;
 460 }
 461
 462 int Shuttle::send_button(unsigned int button, int press)
 463 {
 464         if( debug )
 465                 printf("btn: %u %d\n", button, press);
 466         XButtonEvent *b = new XButtonEvent();
 467         memset(b, 0, sizeof(*b));
 468         b->type = press ? ButtonPress : ButtonRelease;
 469         b->time = milliTimeClock();
 470         b->send_event = 1;
 471         b->display = wdw->top_level->display;
 472         b->root = wdw->top_level->rootwin;
 473         b->window = win;
 474         b->x_root = rx;
 475         b->y_root = ry;
 476         b->x = wx;
 477         b->y = wy;
 478         b->state = msk;
 479         b->button = button;
 480         b->same_screen = 1;
 481         wdw->top_level->put_event((XEvent *) b);
 482         return 0;
 483 }
 484 int Shuttle::send_keycode(unsigned key, unsigned msk, int press, int send)
 485 {
 486         if( debug ) {
 487                 const char *cp = !send ? 0 :
 488                         KeySymMapping::to_string(SKeySym(key, msk));
 489                 if( cp )
 490                         printf("key: %s %d\n", cp, press);
 491                 else
 492                         printf("key: %04x/%04x %d\n", key, msk, press);
 493         }
 494         XKeyEvent *k = new XKeyEvent();
 495         memset(k, 0, sizeof(*k));
 496         k->type = press ? KeyPress : KeyRelease;
 497         k->time = milliTimeClock();
 498         k->send_event = send;
 499         k->display = wdw->top_level->display;
 500         k->root = wdw->top_level->rootwin;
 501         k->window = win;
 502         k->x_root = rx;
 503         k->y_root = ry;
 504         k->x = wx;
 505         k->y = wy;
 506         k->state = msk;
 507         k->keycode = key;
 508         k->same_screen = 1;
 509         wdw->top_level->put_event((XEvent *) k);
 510         return 0;
 511 }
 512
 513 int Shuttle::send_keysym(SKeySym keysym, int press)
 514 {
 515         return keysym >= XK_Button_1 && keysym <= XK_Scroll_Down ?
 516                 send_button((unsigned int)keysym - XK_Button_0, press) :
 517                 send_keycode(keysym.key, keysym.msk, press, 1);
 518 //      unsigned int keycode = XKeysymToKeycode(wdw->top_level->display, keysym);
 519 //      return send_keycode(keycode, press, 0);
 520 }
 521
 522
 523 static Stroke *fetch_stroke(Translation *translation, int kjs, int index)
 524 {
 525         Stroke *ret = 0;
 526         if( translation ) {
 527                 switch( kjs ) {
 528                 default:
 529                 case KJS_KEY_DOWN:  ret = translation->key_down[index].first;     break;
 530                 case KJS_KEY_UP:    ret = translation->key_up[index].first;       break;
 531                 case KJS_JOG:       ret = translation->jog[index].first;          break;
 532                 case KJS_SHUTTLE:   ret = translation->shuttles[index-S_7].first; break;
 533                 }
 534         }
 535         return ret;
 536 }
 537
 538 void Shuttle::send_stroke_sequence(int kjs, int index)
 539 {
 540         if( !wdw ) return;
 541         Stroke *s = fetch_stroke(tr, kjs, index);
 542         if( !s ) s = fetch_stroke(default_translation, kjs, index);
 543         while( s ) {
 544                 send_keysym(s->keysym, s->press);
 545                 s = s->next;
 546         }
 547 }
 548
 549 void Shuttle::key(unsigned short code, unsigned int value)
 550 {
 551         code -= EVENT_CODE_KEY1;
 552         if( code >= NUM_KEYS ) {
 553                 fprintf(stderr, "key(%d, %d) out of range\n", code + EVENT_CODE_KEY1, value);
 554                 return;
 555         }
 556 // Show help if both Alt's pressed on keyboard together with a shuttle button
 557         if( wdw && wdw->alt_down() ) {
 558                 if( value ) wdw->context_help_show("Shuttle key default arrangement");
 559                 return;
 560         }
 561         send_stroke_sequence(value ? KJS_KEY_DOWN : KJS_KEY_UP, code);
 562 }
 563
 564
 565 void Shuttle::shuttle(int value)
 566 {
 567         if( value < S_7 || value > S7 ) {
 568                 fprintf(stderr, "shuttle(%d) out of range\n", value);
 569                 return;
 570         }
 571         if( value != (int)shuttlevalue ) {
 572                 shuttlevalue = value;
 573                 send_stroke_sequence(KJS_SHUTTLE, value);
 574         }
 575 }
 576
 577 // Due to a bug (?) in the way Linux HID handles the ShuttlePro, the
 578 // center position is not reported for the shuttle wheel.       Instead,
 579 // a jog event is generated immediately when it returns.        We check to
 580 // see if the time since the last shuttle was more than a few ms ago
 581 // and generate a shuttle of 0 if so.
 582 //
 583 // Note, this fails if jogvalue happens to be 0, as we don't see that
 584 // event either!
 585 void Shuttle::jog(unsigned int value)
 586 {
 587         if( jogvalue != 0xffff ) {
 588                 value = value & 0xff;
 589                 int direction = ((value - jogvalue) & 0x80) ? -1 : 1;
 590                 int index = direction > 0 ? 1 : 0;
 591                 while( jogvalue != value ) {
 592                         // driver fails to send an event when jogvalue == 0
 593                         if( jogvalue != 0 ) {
 594                                 send_stroke_sequence(KJS_JOG, index);
 595                         }
 596                         jogvalue = (jogvalue + direction) & 0xff;
 597                 }
 598         }
 599         jogvalue = value;
 600 }
 601
 602 void Shuttle::jogshuttle(unsigned short code, unsigned int value)
 603 {
 604         switch( code ) {
 605         case EVENT_CODE_JOG:
 606                 jog(value);
 607                 break;
 608         case EVENT_CODE_SHUTTLE:
 609                 shuttle(value);
 610                 break;
 611         case EVENT_CODE_HI_JOG:  // redundant report of JOG value*120
 612                 break;
 613         default:
 614                 fprintf(stderr, "jogshuttle(%d, %d) invalid code\n", code, value);
 615                 break;
 616         }
 617 }
 618
 619 static const struct shuttle_dev {
 620         const char *path;
 621         unsigned vendor, product;
 622 } shuttle_devs[] = {
 623         { "/dev/input/by-id/usb-Contour_Design_ShuttleXpress-event-if00",
 624                 0x0b33, 0x0020 },
 625         { "/dev/input/by-id/usb-Contour_Design_ShuttlePRO_v2-event-if00",
 626                 0x0b33, 0x0030 },
 627         { "/dev/input/by-id/usb-Contour_Design_ShuttlePro-event-if00",
 628                 0x0b33, 0x0030 },
 629         { "/dev/input/by-id/usb-Contour_Design_ShuttlePRO_v2-event-joystick",
 630                 0x0b33, 0x0030 },
 631 };
 632
 633 #ifdef HAVE_SHUTTLE_USB
 634 void Shuttle::usb_probe(int idx)
 635 {
 636         int ret = libusb_init(0);
 637         if( ret < 0 ) return;
 638         claimed = 0;
 639         const struct shuttle_dev *s = &shuttle_devs[idx];
 640         devsh = libusb_open_device_with_vid_pid(0, s->vendor, s->product);
 641         if( devsh ) {
 642                 int sh_iface = SHUTTLE_INTERFACE;
 643                 libusb_detach_kernel_driver(devsh, sh_iface);
 644                 ret = libusb_claim_interface(devsh, sh_iface);
 645                 if( ret >= 0 ) claimed = 1;
 646         }
 647         if( !claimed )
 648                 usb_done();
 649 }
 650
 651 void Shuttle::usb_done()
 652 {
 653         if( devsh ) {
 654                 if( claimed > 0 ) {
 655                         int sh_iface = SHUTTLE_INTERFACE;
 656                         libusb_release_interface(devsh, sh_iface);
 657                         libusb_attach_kernel_driver(devsh, sh_iface);
 658                         claimed = 0;
 659                 }
 660                 libusb_close(devsh);
 661                 devsh = 0;
 662         }
 663         if( claimed >= 0 ) {
 664                 libusb_exit(0);
 665                 claimed = -1;
 666         }
 667 }
 668 #endif
 669
 670 int Shuttle::probe()
 671 {
 672         struct stat st;
 673         int ret = sizeof(shuttle_devs) / sizeof(shuttle_devs[0]);
 674         while( --ret >= 0 && stat(shuttle_devs[ret].path , &st) );
 675         return ret;
 676 }
 677
 678 void Shuttle::start(int idx)
 679 {
 680         this->dev_index = idx;
 681         first_time = 1;
 682         done = 0;
 683         Thread::start();
 684 }
 685
 686 void Shuttle::stop()
 687 {
 688         if( running() && !done ) {
 689                 done = 1;
 690                 cancel();
 691                 join();
 692         }
 693 }
 694
 695 BC_WindowBase *Shuttle::owns(BC_WindowBase *wdw, Window win)
 696 {
 697         if( wdw->win == win ) return wdw;
 698         if( (wdw=wdw->top_level)->win == win ) return wdw;
 699         for( int i=wdw->popups.size(); --i>=0; )
 700                 if( wdw->popups[i]->win == win ) return wdw;
 701         return 0;
 702 }
 703
 704 int Shuttle::get_focused_window_translation()
 705 {
 706         MWindowGUI *gui = mwindow->gui;
 707         Display *dpy = gui->display;
 708         Window focus = 0;
 709         int ret = 0, revert = 0;
 710         char win_title[BCTEXTLEN];  win_title[0] = 0;
 711         gui->lock_window("Shuttle::get_focused_window_translation");
 712         XGetInputFocus(dpy, &focus, &revert);
 713         if( last_focused != focus ) {
 714                 last_focused = focus;
 715                 Atom prop = XInternAtom(dpy, "WM_NAME", False);
 716                 Atom type;  int form;
 717                 unsigned long remain, len;
 718                 unsigned char *list;
 719                 if( XGetWindowProperty(dpy, focus, prop, 0, sizeof(win_title)-1, False,
 720                         AnyPropertyType, &type, &form, &len, &remain, &list) == Success ) {
 721                         len = len*(form/8) - remain;
 722                         memcpy(win_title, list, len);
 723                         win_title[len] = 0;
 724                         XFree(list);
 725                         if( debug )
 726                                 printf("new focus: %08x %s\n", (unsigned)focus, win_title);
 727                 }
 728                 else {
 729                         last_focused = 0;
 730                         fprintf(stderr, "XGetWindowProperty failed for window 0x%x\n",
 731                                         (int)focus);
 732                         ret = 1;
 733                 }
 734         }
 735         gui->unlock_window();
 736         if( ret ) return -1;
 737
 738         this->wdw = 0;  this->win = 0;
 739         this->wx = 0;   this->wy = 0;
 740         this->rx = 0;   this->ry = 0;
 741         this->msk = 0;
 742         BC_WindowBase *wdw = 0;
 743         int cin = -1;
 744         if( (wdw=owns(mwindow->gui, focus)) != 0 )
 745                 cin = FOCUS_MWINDOW;
 746         else if( (wdw=owns(mwindow->awindow->gui, focus)) != 0 )
 747                 cin = FOCUS_AWINDOW;
 748         else if( (wdw=owns(mwindow->cwindow->gui, focus)) != 0 ) {
 749                 if( mwindow->cwindow->gui->canvas->get_fullscreen() )
 750                         wdw = mwindow->cwindow->gui->canvas->get_canvas();
 751                 cin = FOCUS_CWINDOW;
 752         }
 753         else if( mwindow->gui->mainmenu->load_file->thread->running() &&
 754                  (wdw=mwindow->gui->mainmenu->load_file->thread->window) != 0 &&
 755                  wdw->win == focus )
 756                 cin = FOCUS_LOAD;
 757         else {
 758                 int i = mwindow->vwindows.size();
 759                 while( --i >= 0 ) {
 760                         VWindow *vwdw =  mwindow->vwindows[i];
 761                         if( !vwdw->is_running() ) continue;
 762                         if( (wdw=owns(vwdw->gui, focus)) != 0 ) {
 763                                 if( vwdw->gui->canvas->get_fullscreen() )
 764                                         wdw = vwdw->gui->canvas->get_canvas();
 765                                 cin = FOCUS_VIEWER;  break;
 766                         }
 767                 }
 768         }
 769         if( cin < 0 ) return -1;
 770         Window root = 0, child = 0;
 771         int root_x = 0, root_y = 0, win_x = 0, win_y = 0, x = 0, y = 0;
 772         unsigned int mask = 0, width = 0, height = 0, border_width = 0, depth = 0;
 773         wdw->lock_window("Shuttle::get_focused_window_translation 1");
 774         if( XQueryPointer(wdw->top_level->display, focus, &root, &child,
 775                         &root_x, &root_y, &win_x, &win_y, &mask) ) {
 776                 if( !child ) {
 777                         if( wdw->active_menubar )
 778                                 child = wdw->active_menubar->win;
 779                         else if( wdw->active_popup_menu )
 780                                 child = wdw->active_popup_menu->win;
 781                         else if( wdw->active_subwindow )
 782                                 child = wdw->active_subwindow->win;
 783                         else
 784                                 child = wdw->win;
 785                 }
 786                 else
 787                         XGetGeometry(wdw->top_level->display, child, &root, &x, &y,
 788                                 &width, &height, &border_width, &depth);
 789         }
 790         wdw->unlock_window();
 791         if( !child || !wdw->match_window(child) ) return -1;
 792 // success
 793         this->wdw = wdw;
 794         this->win = child;
 795         this->msk = mask;
 796         this->rx = root_x;
 797         this->ry = root_y;
 798         this->wx = win_x - x;
 799         this->wy = win_y - y;
 800         for( tr=translations.first; tr; tr=tr->next ) {
 801                 if( tr->is_default ) return 1;
 802                 for( int i=0; i<tr->names.size(); ++i ) {
 803                         TransName *name = tr->names[i];
 804                         if( name->cin == cin ) return 1;
 805                 }
 806         }
 807         tr = default_translation;
 808         return 0;
 809 }
 810
 811 int Shuttle::load_translation()
 812 {
 813         if( read_config_file() > 0 )
 814                 return done = 1;
 815         if( get_focused_window_translation() < 0 )
 816                 return 0;
 817         if( last_translation != tr ) {
 818                 last_translation = tr;
 819                 if( debug )
 820                         printf("new translation: %s\n", tr->name);
 821         }
 822         return 0;
 823 }
 824
 825 void Shuttle::handle_event()
 826 {
 827         if( load_translation() ) return;
 828 //      if( debug )
 829 //              printf("event: (%d, %d, 0x%x)\n", ev.type, ev.code, ev.value);
 830         switch( ev.type ) {
 831         case EVENT_TYPE_DONE:
 832         case EVENT_TYPE_ACTIVE_KEY:
 833                 break;
 834         case EVENT_TYPE_KEY:
 835                 key(ev.code, ev.value);
 836                 break;
 837         case EVENT_TYPE_JOGSHUTTLE:
 838                 jogshuttle(ev.code, ev.value);
 839                 break;
 840         default:
 841                 fprintf(stderr, "handle_event() invalid type code\n");
 842                 break;
 843         }
 844 }
 845
 846 void Shuttle::run()
 847 {
 848         if( dev_index < 0 ) return;
 849         const char *dev_name = shuttle_devs[dev_index].path;
 850
 851 #ifdef HAVE_SHUTTLE_USB
 852         if( usb_direct )
 853                 usb_probe(dev_index);
 854
 855         disable_cancel();
 856         while( devsh && !done ) {
 857                 int len = 0;
 858                 static const int IN_ENDPOINT = 0x81;
 859                 unsigned char dat[5];
 860                 int ret = libusb_interrupt_transfer(devsh,
 861                                 IN_ENDPOINT, dat, sizeof(dat), &len, 100);
 862                 if( ret != 0 ) {
 863                         if( ret == LIBUSB_ERROR_TIMEOUT ) continue;
 864                         printf("shuttle: %s\n  %s\n",
 865                                 dev_name, libusb_strerror((libusb_error)ret));
 866                         sleep(1);  continue;
 867                 }
 868                 if( load_translation() ) break;
 869                 if( debug ) {
 870                         printf("shuttle: ");
 871                         for( int i=0; i<len; ++i ) printf(" %02x", dat[i]);
 872                         printf("\n");
 873                 }
 874                 if( last_shuttle != dat[0] )
 875                         shuttle((char)(last_shuttle = dat[0]));
 876
 877                 if( last_jog != dat[1] )
 878                         jog(last_jog = dat[1]);
 879
 880                 unsigned btns = (dat[4]<<8) | dat[3];
 881                 unsigned dif = last_btns ^ btns;
 882                 if( dif ) {
 883                         last_btns = btns;
 884                         for( int i=0; i<15; ++i ) {
 885                                 unsigned msk = 1 << i;
 886                                 if( !(dif & msk) ) continue;
 887                                 key(i+EVENT_CODE_KEY1, btns & msk ? 1 : 0);
 888                         }
 889                 }
 890         }
 891         usb_done();
 892 #endif
 893         usb_direct = 0;
 894         enable_cancel();
 895
 896         for( ; !done; sleep(1) ) {
 897                 fd = open(dev_name, O_RDONLY);
 898                 if( fd < 0 ) {
 899                         perror(dev_name);
 900                         if( first_time ) break;
 901                         continue;
 902                 }
 903                 if( 1 || !ioctl(fd, EVIOCGRAB, 1) ) { // exclusive access
 904                         first_time = 0;
 905                         while( !done ) {
 906                                 int ret = read(fd, &ev, sizeof(ev));
 907                                 if( done ) break;
 908                                 if( ret != sizeof(ev) ) {
 909                                         if( ret < 0 ) { perror("read event"); break; }
 910                                         fprintf(stderr, "bad read: %d\n", ret);
 911                                         break;
 912                                 }
 913                                 handle_event();
 914                         }
 915                 }
 916                 else
 917                         perror( "evgrab ioctl" );
 918                 close(fd);
 919         }
 920         done = 2;
 921 }
 922
 923 int Shuttle::read_config_file()
 924 {
 925         if( !config_path ) {
 926                 const char *env;
 927                 config_path = (env=getenv("SHUTTLE_CONFIG_FILE")) != 0 ? cstrdup(env) :
 928                         (env=getenv("HOME")) != 0 ? cstrcat(2, env, "/.shuttlerc") : 0;
 929                 if( !config_path ) { fprintf(stderr, "no config file\n");  return 1; }
 930         }
 931         struct stat st;
 932         if( stat(config_path, &st) ) {
 933                 perror(config_path);
 934                 char shuttlerc[BCTEXTLEN];
 935                 snprintf(shuttlerc, sizeof(shuttlerc), "%s/shuttlerc",
 936                                 File::get_cindat_path());
 937                 if( stat(shuttlerc, &st) ) {
 938                         perror(shuttlerc);
 939                         return 1;
 940                 }
 941                 delete [] config_path;
 942                 config_path = cstrdup(shuttlerc);
 943         }
 944         if( config_mtime > 0 &&
 945             config_mtime == st.st_mtime ) return 0;
 946         FILE *fp = fopen(config_path, "r");
 947         if( !fp ) {
 948                 perror(config_path);
 949                 return 1;
 950         }
 951
 952         config_mtime = st.st_mtime;
 953         translations.clear();
 954         debug = 0;
 955         usb_direct = 0;
 956 #define ws(ch) (ch==' ' || ch=='\t')
 957         char line[BCTEXTLEN], *cp;
 958         Translation *trans = 0;
 959         int no = 0;
 960         int ret = fgets(cp=line,sizeof(line),fp) ? 0 : -1;
 961         if( !ret ) ++no;
 962 // lines
 963         while( !ret ) {
 964 // translation names
 965                 while( !ret && *cp == '[' ) {
 966                         char *name = ++cp;
 967                         while( *cp && *cp != ']' ) ++cp;
 968                         *cp++ = 0;
 969                         if( !name || !*name ) { ret = 1;  break; }
 970                         int cin = -1;
 971                         if( !strcasecmp("default", name) )
 972                                 cin = FOCUS_DEFAULT;
 973                         else if( !strcasecmp("cinelerra", name) )
 974                                 cin = FOCUS_MWINDOW;
 975                         else if( !strcasecmp("resources", name) )
 976                                 cin = FOCUS_AWINDOW;
 977                         else if( !strcasecmp("composer", name) )
 978                                 cin = FOCUS_CWINDOW;
 979                         else if( !strcasecmp("viewer", name) )
 980                                 cin = FOCUS_VIEWER;
 981                         else if( !strcasecmp("load", name) )
 982                                 cin = FOCUS_LOAD;
 983                         else {
 984                                 fprintf(stderr, "unknown focus target window: %s\n",
 985                                          name);
 986                                 ret = 1;  break;
 987                         }
 988                         if( !trans ) {
 989                                 if( cin == FOCUS_DEFAULT ) {
 990                                         trans = default_translation;
 991                                         trans->clear();
 992                                 }
 993                                 else {
 994                                         trans = new Translation(this, name);
 995                                 }
 996                         }
 997                         while( ws(*cp) ) ++cp;
 998                         trans->names.append(new TransName(cin, name, cp));
 999                         ret = fgets(cp=line,sizeof(line),fp) ? 0 : 1;
1000                         if( ret ) {
1001                                 fprintf(stderr, "hit eof, no translation def for: %s\n",
1002                                         trans->names.last()->name);
1003                                 ret = 1;  break;
1004                         }
1005                         ++no;
1006                 }
1007                 if( ret ) break;
1008                 if( debug && trans ) {
1009                         printf("------------------------\n");
1010                         TransNames &names = trans->names;
1011                         for( int i=0; i<names.size(); ++i ) {
1012                                 TransName *tp = names[i];
1013                                 printf("[%s] # %d\n\n", tp->name, tp->cin);
1014                         }
1015                 }
1016 // rules lines: "tok <stroke list>\n"
1017                 while( !ret && *cp != '[' ) {
1018                         const char *key = 0, *tok = 0;
1019                         while( ws(*cp) ) ++cp;
1020                         if( !*cp || *cp == '\n' || *cp == '#' ) goto skip;
1021                         tok = cp;
1022                         while( *cp && !ws(*cp) && *cp != '\n' ) ++cp;
1023                         *cp++ = 0;
1024                         if( !strcmp(tok, "DEBUG") ) {
1025                                 debug = 1;  goto skip;
1026                         }
1027                         if( !strcmp(tok, "USB_DIRECT") ) {
1028                                 usb_direct = 1;  goto skip;
1029                         }
1030                         key = tok;
1031                         if( !trans ) {
1032                                 fprintf(stderr, "no translation section defining key: %s\n", key);
1033                                 ret = 1;  break;
1034                         }
1035
1036                         ret = trans->start_line(key);
1037                         while( !ret && *cp && *cp != '\n' ) {
1038                                 while( ws(*cp) ) ++cp;
1039                                 if( !*cp || *cp == '#' || *cp == '\n' ) break;
1040                                 if( *cp == '"' ) {
1041                                         while( *cp ) {
1042                                                 if( *cp == '"' )
1043                                                         trans->add_string(cp);
1044                                                 while( ws(*cp) ) ++cp;
1045                                                 if( !*cp || *cp == '#' || *cp == '\n' ) break;
1046                                                 tok = cp;
1047                                                 while( *cp && !ws(*cp) && *cp != '\n' ) ++cp;
1048                                                 *cp = 0;
1049                                                 SKeySym sym = KeySymMapping::to_keysym(tok);
1050                                                 if( !sym ) {
1051                                                         fprintf(stderr, "unknown keysym: %s\n", tok);
1052                                                         ret = 1;  break;
1053                                                 }
1054                                                 trans->add_keysym(sym, PRESS_RELEASE);
1055                                         }
1056                                         continue;
1057                                 }
1058                                 tok = cp;
1059                                 while( *cp && !ws(*cp) && *cp!='/' && *cp != '\n' ) ++cp;
1060                                 int dhu = PRESS_RELEASE;
1061                                 if( *cp == '/' ) {
1062                                         *cp++ = 0;
1063                                         switch( *cp ) {
1064                                         case 'D':  dhu = PRESS;    break;
1065                                         case 'H':  dhu = HOLD;     break;
1066                                         case 'U':  dhu = RELEASE;  break;
1067                                         default:
1068                                                 fprintf(stderr, "invalid up/down modifier [%s]%s: '%c'\n",
1069                                                         trans->name, tok, *cp);
1070                                                 ret = 1;  break;
1071                                         }
1072                                         ++cp;
1073                                 }
1074                                 else
1075                                         *cp++ = 0;
1076                                 trans->add_keystroke(tok, dhu);
1077                         }
1078                         if( ret ) break;
1079                         trans->finish_line();
1080                         if( debug )
1081                                 trans->print_line(key);
1082                 skip:   ret = fgets(cp=line,sizeof(line),fp) ? 0 : -1;
1083                         if( !ret ) ++no;
1084                 }
1085                 if( trans ) {
1086                         if( trans != default_translation )
1087                                 translations.append(trans);
1088                         trans = 0;
1089                 }
1090         }
1091         if( ret > 0 )
1092                 fprintf(stderr, "shuttle config err file: %s, line:%d\n",
1093                         config_path, no);
1094
1095         fclose(fp);
1096         return ret;
1097 }
1098 #endif