test/accessx-gui.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <gtk/gtk.h>
  28 #include <gdk/gdkx.h>
  29 #include <X11/XKBlib.h> /* AccessX control defs */
  30 #include "spi.h"
  31
  32 #define N_CONTROLS 8
  33
  34 static XkbDescPtr xkb;
  35
  36 typedef struct {
  37         unsigned long  mask;
  38         short int     *val;
  39         char          *label;
  40         char          *val_label;
  41 } AccessXControlStruct;
  42
  43 static void
  44 gui_exit(GtkButton *notused, void *alsonotused)
  45 {
  46   gtk_exit(0);
  47 }
  48
  49 static void
  50 toggle_xkb_control (GtkButton *toggle_button, AccessXControlStruct *control_struct)
  51 {
  52   gboolean is_active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle_button));
  53   XkbChangeEnabledControls (GDK_DISPLAY(), XkbUseCoreKbd, control_struct->mask,
  54                             is_active ? control_struct->mask : 0);
  55 }
  56
  57 static void
  58 toggle_xkb_notify_control (GtkButton *toggle_button, AccessXControlStruct *control_struct)
  59 {
  60   gboolean is_active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle_button));
  61   unsigned short mask, always_off_mask;
  62   XkbChangeEnabledControls (GDK_DISPLAY(), XkbUseCoreKbd, XkbAccessXFeedbackMask | XkbAudibleBellMask,
  63                             XkbAccessXFeedbackMask | XkbAudibleBellMask);
  64
  65   mask = XkbAX_TwoKeysMask | XkbAX_LatchToLockMask | XkbAX_DumbBellFBMask;
  66   always_off_mask = XkbAX_SKPressFBMask | XkbAX_SKReleaseFBMask;
  67
  68   if (is_active)
  69           xkb->ctrls->ax_options |= (control_struct->mask  |  mask);
  70   else
  71           xkb->ctrls->ax_options &= (~control_struct->mask);
  72
  73   xkb->ctrls->ax_options &= ~always_off_mask;
  74
  75   XkbSetControls (GDK_DISPLAY(), XkbAccessXFeedbackMask, xkb);
  76 }
  77
  78 static void
  79 toggle_accessx (GtkButton *toggle_button, void *unused)
  80 {
  81   gboolean is_active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle_button));
  82   XkbChangeEnabledControls (GDK_DISPLAY(), XkbUseCoreKbd, XkbAllBooleanCtrlsMask,
  83     (is_active) ? xkb->ctrls->enabled_ctrls : 0);
  84 /*if (is_active/) XkbSetControls (GDK_DISPLAY(), XkbAllBooleanCtrlsMask, xkb);*/
  85 }
  86
  87 static void
  88 set_accessx_control_value (GtkRange *range_control, AccessXControlStruct *control_struct)
  89 {
  90   *(control_struct->val) = (short int) gtk_range_get_value (range_control);
  91   XkbSetControls (GDK_DISPLAY(), control_struct->mask, xkb);
  92 }
  93
  94 static gboolean
  95 init_xkb ()
  96 {
  97   int opcode, xkb_event_code, error, result, major, minor;
  98   Status status;
  99   result = XkbQueryExtension (GDK_DISPLAY(), &opcode, &xkb_event_code, &error, &major, &minor);
 100   if (result != True) return False;
 101
 102   xkb = XkbGetMap(GDK_DISPLAY(), 0, XkbUseCoreKbd);
 103   if ((int)xkb == BadAlloc || xkb == NULL)
 104   {
 105       return False;
 106   }
 107   else
 108   {
 109       status = XkbGetControls(GDK_DISPLAY(), XkbAllControlsMask, xkb);
 110       if (status != Success)
 111       {
 112          XkbFreeKeyboard(xkb, XkbAllControlsMask, True);
 113          return False;
 114       }
 115       else
 116       {
 117         if (!xkb->ctrls)
 118         {
 119           XkbFreeKeyboard(xkb, XkbAllControlsMask, True);
 120           return False;
 121         }
 122       }
 123   }
 124
 125   return True;
 126 }
 127
 128 static AccessXControlStruct *
 129 control_struct_new (unsigned int mask,
 130                     short int *val_ptr,
 131                     char *label,
 132                     char *val_label)
 133 {
 134   AccessXControlStruct *control = g_new0 (AccessXControlStruct, 1);
 135   control->mask = mask;
 136   control->val = val_ptr;
 137   control->label = label;
 138   control->val_label = val_label;
 139   return control;
 140 }
 141
 142 static GtkWidget*
 143 basic_toggles_box ()
 144 {
 145   GtkWidget *hbox, *outer_vbox, *vbox, *label, *button, *range, *frame;
 146   GtkAdjustment *adjustment;
 147   AccessXControlStruct *control;
 148
 149   outer_vbox = gtk_widget_new (GTK_TYPE_VBOX,
 150                          "GtkWidget::visible", TRUE,
 151                          NULL);
 152
 153   hbox = gtk_widget_new (GTK_TYPE_HBOX,
 154                          "GtkWidget::parent", outer_vbox,
 155                          "GtkWidget::visible", TRUE,
 156                          NULL);
 157
 158   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 159                                              "GtkButton::label", "Enable AccessX",
 160                                              "GtkWidget::parent", hbox,
 161                                              "GtkWidget::visible", TRUE,
 162                                              NULL),
 163                              "signal::clicked",
 164                              toggle_accessx, NULL,
 165                              NULL);
 166
 167 /* FeatureFBMask seems not to work :-(
 168
 169   control = control_struct_new (XkbAX_FeatureFBMask, &xkb->ctrls->ax_options, NULL, NULL);
 170
 171   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 172                                              "GtkButton::label", "Notify Changes",
 173                                              "GtkWidget::parent", hbox,
 174                                              "GtkWidget::visible", TRUE,
 175                                              NULL),
 176                              "signal::clicked",
 177                              toggle_xkb_notify_control, control,
 178                              NULL);
 179 */
 180
 181   gtk_widget_new (GTK_TYPE_HSEPARATOR,
 182                   "GtkWidget::parent", outer_vbox,
 183                   "GtkWidget::visible", TRUE,
 184                   NULL);
 185
 186   hbox = gtk_widget_new (GTK_TYPE_HBOX,
 187                          "GtkWidget::parent", outer_vbox,
 188                          "GtkWidget::visible", TRUE,
 189                          NULL);
 190
 191   control = control_struct_new (XkbStickyKeysMask, &xkb->ctrls->enabled_ctrls, NULL, NULL);
 192
 193   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 194                                              "GtkButton::label", "Sticky Keys",
 195                                              "GtkWidget::parent", hbox,
 196                                              "GtkWidget::visible", TRUE,
 197                                              NULL),
 198                              "signal::clicked",
 199                              toggle_xkb_control, control,
 200                              NULL);
 201
 202   control = control_struct_new (XkbAX_StickyKeysFBMask, &xkb->ctrls->ax_options, NULL, NULL);
 203
 204   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 205                                              "GtkButton::label", "Beep when Latched",
 206                                              "GtkWidget::parent", hbox,
 207                                              "GtkWidget::visible", TRUE,
 208                                              NULL),
 209                              "signal::clicked",
 210                              toggle_xkb_notify_control, control,
 211                              NULL);
 212
 213   frame = gtk_widget_new (gtk_frame_get_type(),
 214                           "GtkFrame::label", "Slow Keys",
 215                           "GtkWidget::parent", outer_vbox,
 216                           "GtkWidget::visible", TRUE,
 217                           NULL);
 218
 219   vbox = gtk_widget_new (GTK_TYPE_VBOX,
 220                          "GtkWidget::parent", frame,
 221                          "GtkWidget::visible", TRUE,
 222                          NULL);
 223
 224   hbox = gtk_widget_new (GTK_TYPE_HBOX,
 225                          "GtkWidget::parent", vbox,
 226                          "GtkWidget::visible", TRUE,
 227                          NULL);
 228
 229   control = control_struct_new (XkbSlowKeysMask, &xkb->ctrls->slow_keys_delay, NULL, NULL);
 230
 231   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 232                                              "GtkButton::label", "Enable Slow Keys",
 233                                              "GtkWidget::parent", hbox,
 234                                              "GtkWidget::visible", TRUE,
 235                                              NULL),
 236                              "signal::clicked",
 237                              toggle_xkb_control, control,
 238                              NULL);
 239
 240   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (1.0, 1.0, 2000.0, 1.0, 10.0, 1.0 ));
 241
 242   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 243                                             "GtkWidget::parent", hbox,
 244                                             "GtkWidget::visible", TRUE,
 245                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 246                                             "GtkScale::digits", 0,
 247                                             "GtkScale::adjustment", adjustment,
 248                                             NULL),
 249                             "signal::value_changed",
 250                             set_accessx_control_value, control,
 251                             NULL);
 252
 253   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 254
 255   label = gtk_widget_new (GTK_TYPE_LABEL,
 256                           "GtkLabel::label", "Delay (mS)",
 257                           "GtkWidget::parent", hbox,
 258                           "GtkWidget::visible", TRUE,
 259                           NULL);
 260
 261   hbox = gtk_widget_new (GTK_TYPE_HBOX,
 262                          "GtkWidget::parent", vbox,
 263                          "GtkWidget::visible", TRUE,
 264                          NULL);
 265
 266   control = control_struct_new (XkbAX_SKAcceptFBMask, &xkb->ctrls->ax_options, NULL, NULL);
 267
 268   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 269                                              "GtkButton::label", "Beep on Accept",
 270                                              "GtkWidget::parent", hbox,
 271                                              "GtkWidget::visible", TRUE,
 272                                              NULL),
 273                              "signal::clicked",
 274                              toggle_xkb_notify_control, control,
 275                              NULL);
 276
 277   control = control_struct_new (XkbAX_SKRejectFBMask, &xkb->ctrls->ax_options, NULL, NULL);
 278
 279   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 280                                              "GtkButton::label", "Beep on Reject",
 281                                              "GtkWidget::parent", hbox,
 282                                              "GtkWidget::visible", TRUE,
 283                                              NULL),
 284                              "signal::clicked",
 285                              toggle_xkb_notify_control, control,
 286                              NULL);
 287
 288   frame = gtk_widget_new (gtk_frame_get_type(),
 289                           "GtkFrame::label", "Bounce Keys",
 290                           "GtkWidget::parent", outer_vbox,
 291                           "GtkWidget::visible", TRUE,
 292                           NULL);
 293
 294   vbox = gtk_widget_new (GTK_TYPE_VBOX,
 295                          "GtkWidget::parent", frame,
 296                          "GtkWidget::visible", TRUE,
 297                          NULL);
 298
 299   hbox = gtk_widget_new (GTK_TYPE_HBOX,
 300                          "GtkWidget::parent", vbox,
 301                          "GtkWidget::visible", TRUE,
 302                          NULL);
 303
 304   control = control_struct_new (XkbBounceKeysMask, &xkb->ctrls->debounce_delay, NULL, NULL);
 305
 306   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 307                                              "GtkButton::label", "Enable Key Debounce",
 308                                              "GtkWidget::parent", hbox,
 309                                              "GtkWidget::visible", TRUE,
 310                                              NULL),
 311                              "signal::clicked",
 312                              toggle_xkb_control, control,
 313                              NULL);
 314
 315   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (1.0, 1.0, 2000.0, 1.0, 10.0, 1.0 ));
 316
 317   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 318                                             "GtkWidget::parent", hbox,
 319                                             "GtkWidget::visible", TRUE,
 320                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 321                                             "GtkScale::digits", 0,
 322                                             "GtkScale::adjustment", adjustment,
 323                                             NULL),
 324                             "signal::value_changed",
 325                             set_accessx_control_value, control,
 326                             NULL);
 327
 328   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 329
 330   label = gtk_widget_new (GTK_TYPE_LABEL,
 331                           "GtkLabel::label", "Delay (mS)",
 332                           "GtkWidget::parent", hbox,
 333                           "GtkWidget::visible", TRUE,
 334                           NULL);
 335
 336   hbox = gtk_widget_new (GTK_TYPE_HBOX,
 337                          "GtkWidget::parent", vbox,
 338                          "GtkWidget::visible", TRUE,
 339                          NULL);
 340
 341   control = control_struct_new (XkbAX_BKRejectFBMask, &xkb->ctrls->ax_options, NULL, NULL);
 342
 343   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 344                                              "GtkButton::label", "Beep on Reject",
 345                                              "GtkWidget::parent", hbox,
 346                                              "GtkWidget::visible", TRUE,
 347                                              NULL),
 348                              "signal::clicked",
 349                              toggle_xkb_notify_control, control,
 350                              NULL);
 351
 352   return outer_vbox;
 353 }
 354
 355 static GtkWidget*
 356 repeat_keys_box ()
 357 {
 358   GtkWidget *outer_hbox, *vbox, *label, *button, *range, *frame;
 359   GtkAdjustment *adjustment;
 360   AccessXControlStruct *control =
 361           control_struct_new (XkbRepeatKeysMask, &xkb->ctrls->repeat_delay, NULL, NULL);
 362
 363   frame = gtk_widget_new (gtk_frame_get_type(),
 364                           "GtkFrame::label","Repeat Keys",
 365                           "GtkWidget::visible", TRUE,
 366                           NULL);
 367
 368   outer_hbox = gtk_widget_new (GTK_TYPE_HBOX,
 369                          "GtkWidget::visible", TRUE,
 370                           "GtkWidget::parent", frame,
 371                          NULL);
 372
 373   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 374                                              "GtkButton::label", "Enable RepeatKeys",
 375                                              "GtkWidget::parent", outer_hbox,
 376                                              "GtkWidget::visible", TRUE,
 377                                              NULL),
 378                              "signal::clicked",
 379                              toggle_xkb_control, control,
 380                              NULL);
 381
 382   gtk_box_set_child_packing (GTK_BOX (outer_hbox), button, FALSE, FALSE, 0, GTK_PACK_START);
 383
 384
 385   vbox = gtk_widget_new (GTK_TYPE_VBOX,
 386                          "GtkWidget::visible", TRUE,
 387                          "GtkWidget::parent", outer_hbox,
 388                          NULL);
 389
 390   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (200.0, 200.0, 4000.0, 10.0, 100.0, 10.0 ));
 391
 392   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 393                                             "GtkWidget::parent", vbox,
 394                                             "GtkWidget::visible", TRUE,
 395                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 396                                             "GtkScale::digits", 0,
 397                                             "GtkScale::adjustment", adjustment,
 398                                             NULL),
 399                             "signal::value_changed",
 400                             set_accessx_control_value, control,
 401                             NULL);
 402
 403   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 404
 405   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (200.0, 40.0, 4000.0, 1.0, 10.0, 1.0 ));
 406
 407   control = control_struct_new (XkbRepeatKeysMask, &xkb->ctrls->repeat_interval, NULL, NULL);
 408
 409   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 410                                             "GtkWidget::parent", vbox,
 411                                             "GtkWidget::visible", TRUE,
 412                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 413                                             "GtkScale::digits", 0,
 414                                             "GtkScale::adjustment", adjustment,
 415                                             NULL),
 416                             "signal::value_changed",
 417                             set_accessx_control_value, control,
 418                             NULL);
 419
 420   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 421
 422   vbox = gtk_widget_new (GTK_TYPE_VBOX,
 423                          "GtkWidget::visible", TRUE,
 424                          "GtkWidget::parent", outer_hbox,
 425                          NULL);
 426
 427   label = gtk_widget_new (GTK_TYPE_LABEL,
 428                           "GtkLabel::label", "Delay (mS)",
 429                           "GtkWidget::parent", vbox,
 430                           "GtkWidget::visible", TRUE,
 431                           NULL);
 432
 433   label = gtk_widget_new (GTK_TYPE_LABEL,
 434                           "GtkLabel::label", "Interval (mS)",
 435                           "GtkWidget::parent", vbox,
 436                           "GtkWidget::visible", TRUE,
 437                           NULL);
 438
 439   return frame;
 440 }
 441
 442 static GtkWidget*
 443 mouse_keys_box ()
 444 {
 445   GtkWidget *outer_hbox, *vbox, *label, *button, *range, *frame;
 446   GtkAdjustment *adjustment;
 447   AccessXControlStruct *control =
 448           control_struct_new (XkbMouseKeysMask, &xkb->ctrls->mk_delay, NULL, NULL);
 449
 450   frame = gtk_widget_new (gtk_frame_get_type(),
 451                           "GtkFrame::label","Mouse Keys",
 452                           "GtkWidget::visible", TRUE,
 453                           NULL);
 454
 455   outer_hbox = gtk_widget_new (GTK_TYPE_HBOX,
 456                          "GtkWidget::visible", TRUE,
 457                           "GtkWidget::parent", frame,
 458                          NULL);
 459
 460   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 461                                              "GtkButton::label", "Enable MouseKeys",
 462                                              "GtkWidget::parent", outer_hbox,
 463                                              "GtkWidget::visible", TRUE,
 464                                              NULL),
 465                              "signal::clicked",
 466                              toggle_xkb_control, control,
 467                              NULL);
 468
 469   gtk_box_set_child_packing (GTK_BOX (outer_hbox), button, FALSE, FALSE, 0, GTK_PACK_START);
 470
 471   vbox = gtk_widget_new (GTK_TYPE_VBOX,
 472                          "GtkWidget::visible", TRUE,
 473                          "GtkWidget::parent", outer_hbox,
 474                          NULL);
 475
 476   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (200.0, 20.0, 4000.0, 10.0, 100.0, 10.0 ));
 477
 478   control = control_struct_new (XkbRepeatKeysMask, &xkb->ctrls->mk_interval, NULL, NULL);
 479
 480   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 481                                             "GtkWidget::parent", vbox,
 482                                             "GtkWidget::visible", TRUE,
 483                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 484                                             "GtkScale::digits", 0,
 485                                             "GtkScale::adjustment", adjustment,
 486                                             NULL),
 487                             "signal::value_changed",
 488                             set_accessx_control_value, control,
 489                             NULL);
 490
 491   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 492
 493   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (800.0, 200.0, 4000.0, 1.0, 10.0, 1.0 ));
 494
 495   control = control_struct_new (XkbRepeatKeysMask, &xkb->ctrls->mk_time_to_max, NULL, NULL);
 496
 497   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 498                                             "GtkWidget::parent", vbox,
 499                                             "GtkWidget::visible", TRUE,
 500                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 501                                             "GtkScale::digits", 0,
 502                                             "GtkScale::adjustment", adjustment,
 503                                             NULL),
 504                             "signal::value_changed",
 505                             set_accessx_control_value, control,
 506                             NULL);
 507
 508   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 509
 510   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (800.0, 200.0, 4000.0, 1.0, 10.0, 1.0 ));
 511
 512   control = control_struct_new (XkbMouseKeysMask, &xkb->ctrls->mk_max_speed, NULL, NULL);
 513
 514   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 515                                             "GtkWidget::parent", vbox,
 516                                             "GtkWidget::visible", TRUE,
 517                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 518                                             "GtkScale::digits", 0,
 519                                             "GtkScale::adjustment", adjustment,
 520                                             NULL),
 521                             "signal::value_changed",
 522                             set_accessx_control_value, control,
 523                             NULL);
 524
 525   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 526
 527   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (800.0, 200.0, 4000.0, 1.0, 10.0, 1.0 ));
 528
 529   control = control_struct_new (XkbMouseKeysMask, &xkb->ctrls->mk_curve, NULL, NULL);
 530
 531   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 532                                             "GtkWidget::parent", vbox,
 533                                             "GtkWidget::visible", TRUE,
 534                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 535                                             "GtkScale::digits", 0,
 536                                             "GtkScale::adjustment", adjustment,
 537                                             NULL),
 538                             "signal::value_changed",
 539                             set_accessx_control_value, control,
 540                             NULL);
 541
 542   vbox = gtk_widget_new (gtk_vbox_get_type(),
 543                          "GtkWidget::name", "MouseKeys",
 544                          "GtkWidget::parent", outer_hbox,
 545                          "GtkWidget::visible", TRUE,
 546                          "GtkContainer::border_width", 5,
 547                          NULL);
 548   label = gtk_widget_new (GTK_TYPE_LABEL,
 549                           "GtkLabel::label", "Delay (mS)",
 550                           "GtkWidget::parent", vbox,
 551                           "GtkWidget::visible", TRUE,
 552                           NULL);
 553
 554   label = gtk_widget_new (GTK_TYPE_LABEL,
 555                           "GtkLabel::label", "Accel. time (mS)",
 556                           "GtkWidget::parent", vbox,
 557                           "GtkWidget::visible", TRUE,
 558                           NULL);
 559
 560   label = gtk_widget_new (GTK_TYPE_LABEL,
 561                           "GtkLabel::label", "Interval (mS)",
 562                           "GtkWidget::parent", vbox,
 563                           "GtkWidget::visible", TRUE,
 564                           NULL);
 565
 566   label = gtk_widget_new (GTK_TYPE_LABEL,
 567                           "GtkLabel::label", "Max. Speed",
 568                           "GtkWidget::parent", vbox,
 569                           "GtkWidget::visible", TRUE,
 570                           NULL);
 571
 572   label = gtk_widget_new (GTK_TYPE_LABEL,
 573                           "GtkLabel::label", "Curve",
 574                           "GtkWidget::parent", vbox,
 575                           "GtkWidget::visible", TRUE,
 576                           NULL);
 577   return frame;
 578 }
 579
 580 static GtkWidget*
 581 timeout_box ()
 582 {
 583   GtkWidget *hbox, *label, *button, *range;
 584   GtkAdjustment *adjustment;
 585   AccessXControlStruct *control =
 586           control_struct_new (XkbAccessXTimeoutMask, &xkb->ctrls->ax_timeout, NULL, NULL);
 587
 588   hbox = gtk_widget_new (gtk_hbox_get_type(),
 589                           "GtkWidget::visible", TRUE,
 590                           NULL);
 591
 592   button = g_object_connect (gtk_widget_new (GTK_TYPE_CHECK_BUTTON,
 593                                              "GtkButton::label", "AccessX Timeout",
 594                                              "GtkWidget::parent", hbox,
 595                                              "GtkWidget::visible", TRUE,
 596                                              NULL),
 597                              "signal::clicked",
 598                              toggle_xkb_control, control,
 599                              NULL);
 600
 601   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (1.0, 1.0, 200.0, 1.0, 10.0, 1.0 ));
 602
 603   range = g_object_connect (gtk_widget_new (GTK_TYPE_HSCALE,
 604                                             "GtkWidget::parent", hbox,
 605                                             "GtkWidget::visible", TRUE,
 606                                             "GtkRange::update_policy", GTK_UPDATE_DELAYED,
 607                                             "GtkScale::digits", 0,
 608                                             "GtkScale::adjustment", adjustment,
 609                                             NULL),
 610                             "signal::value_changed",
 611                             set_accessx_control_value, control,
 612                             NULL);
 613
 614   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 615
 616   label = gtk_widget_new (GTK_TYPE_LABEL,
 617                           "GtkLabel::label", "AccessX Timeout (Min.)",
 618                           "GtkWidget::parent", hbox,
 619                           "GtkWidget::visible", TRUE,
 620                           NULL);
 621
 622   return hbox;
 623 }
 624
 625 static void
 626 create_gui (void)
 627 {
 628   GtkWidget *window, *button, *container, *hbox;
 629
 630   window = g_object_connect (gtk_widget_new (gtk_window_get_type (),
 631                                              "user_data", NULL,
 632                                              "can_focus", FALSE,
 633                                              "type", GTK_WINDOW_TOPLEVEL,
 634                                              "window-position", GTK_WIN_POS_CENTER,
 635                                              "title", "AccessX",
 636                                              "allow_grow", TRUE,
 637                                              "allow_shrink", TRUE,
 638                                              "border_width", 10,
 639                                              NULL),
 640                              "signal::destroy", gui_exit, NULL,
 641                              NULL);
 642
 643   container = gtk_widget_new (GTK_TYPE_VBOX,
 644                               "GtkWidget::parent", window,
 645                               "GtkWidget::visible", TRUE,
 646                               NULL);
 647
 648   /* create and add containers for: AccessX on/off,
 649      basic toggles,
 650      MouseKeys support, and timeout */
 651
 652   gtk_container_add (GTK_CONTAINER (container), basic_toggles_box ());
 653   gtk_container_add (GTK_CONTAINER (container), repeat_keys_box ());
 654 /*  gtk_container_add (GTK_CONTAINER (container), mouse_keys_box ());
 655   gtk_container_add (GTK_CONTAINER (container), timeout_box ());*/
 656
 657   hbox = gtk_widget_new (gtk_hbox_get_type(),
 658                          "GtkWidget::parent", container,
 659                          "GtkWidget::visible", TRUE,
 660                          "GtkContainer::border_width", 5,
 661                          NULL);
 662
 663   button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
 664                                              "GtkButton::label", "Quit",
 665                                              "GtkWidget::parent", hbox,
 666                                              "GtkWidget::visible", TRUE,
 667                                              NULL),
 668                              "signal::clicked",
 669                              gui_exit, NULL,
 670                              NULL);
 671
 672   gtk_widget_show (window);
 673 }
 674
 675 static void
 676 create_gui_x (void)
 677 {
 678   GtkWidget *window, *button, *container, *hbox, *range;
 679   GtkAdjustment *adjustment;
 680   int i;
 681   static AccessXControlStruct* controls[N_CONTROLS];
 682   controls[0] = control_struct_new (XkbSlowKeysMask,   &xkb->ctrls->slow_keys_delay, "Slow Keys", "Delay, mS");
 683   controls[1] = control_struct_new (XkbStickyKeysMask, &xkb->ctrls->ax_options, "Sticky Keys", NULL);
 684   controls[2] = control_struct_new (XkbBounceKeysMask, &xkb->ctrls->debounce_delay, "Key Debounce", "Delay, mS");
 685   controls[3] = control_struct_new (XkbRepeatKeysMask, &xkb->ctrls->repeat_delay, "Repeat Keys", "Delay, mS");
 686   controls[4] = control_struct_new (XkbRepeatKeysMask, &xkb->ctrls->repeat_interval, NULL, "Interval, mS");
 687   controls[5] = control_struct_new (XkbMouseKeysMask,  &xkb->ctrls->mk_delay, "MouseKeys", "Delay, mS");
 688   controls[6] = control_struct_new (XkbMouseKeysAccelMask, &xkb->ctrls->mk_time_to_max, NULL, "Accel");
 689   controls[7] = control_struct_new (XkbAccessXTimeoutMask, &xkb->ctrls->ax_timeout, "AccessX timeout", "Sec");
 690
 691   hbox = gtk_widget_new (gtk_hbox_get_type(),
 692                          "GtkWidget::parent", container,
 693                          "GtkWidget::visible", TRUE,
 694                          NULL);
 695
 696   i = 0; /* FIXME: this looks bogus */
 697   button = g_object_connect (gtk_widget_new (gtk_check_button_get_type (),
 698                                              "GtkButton::label", "Access X Timeout",
 699                                              "GtkWidget::parent", hbox,
 700                                              "GtkWidget::visible", TRUE,
 701                                              NULL),
 702                              "signal::clicked",
 703                              toggle_xkb_control, controls[i],
 704                              NULL);
 705
 706   adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (1.0, 1.0, 200.0, 1.0, 10.0, 1.0 ));
 707
 708   range = g_object_connect (gtk_widget_new (gtk_hscale_get_type (),
 709                                             "GtkWidget::parent", hbox,
 710                                             "GtkWidget::visible", TRUE,
 711                                             "GtkScale::adjustment", adjustment,
 712                                             NULL),
 713                             "signal::value_changed",
 714                             set_accessx_control_value, controls[i],
 715                             NULL);
 716
 717   gtk_widget_set_usize (GTK_WIDGET (range), 150, -1);
 718   gtk_widget_new (gtk_label_get_type(),
 719                   "GtkWidget::parent", hbox,
 720                   "GtkLabel::label", controls[i]->val_label,
 721                   "GtkWidget::visible", TRUE,
 722                   NULL);
 723
 724   hbox = gtk_widget_new (gtk_hbox_get_type(),
 725                          "GtkWidget::parent", container,
 726                          "GtkWidget::visible", TRUE,
 727                          "GtkContainer::border_width", 5,
 728                          NULL);
 729
 730   button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
 731                                              "GtkButton::label", "Quit",
 732                                              "GtkWidget::parent", hbox,
 733                                              "GtkWidget::visible", TRUE,
 734                                              NULL),
 735                              "signal::clicked",
 736                              gui_exit, NULL,
 737                              NULL);
 738
 739   gtk_widget_show (window);
 740 }
 741
 742 int
 743 main(int argc, char **argv)
 744 {
 745
 746   if ((argc > 1) && (!strncmp(argv[1],"-h",2)))
 747   {
 748     printf ("Usage: keysynth-demo\n");
 749     exit(0);
 750   }
 751
 752   gtk_init (&argc, &argv); /* must call, because this program uses GTK+ */
 753
 754   if (!init_xkb ())
 755   {
 756      g_error ("Xkb extension not present, can't initialize accessX\n");
 757   }
 758
 759   create_gui ();
 760
 761   gtk_main ();
 762
 763   return 0;
 764 }