Grcov report - deviceeventcontroller.c

1

/* AT-SPI - Assistive Technology Service Provider Interface

2

3

 * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)

4

5

 * Copyright 2001, 2003 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 Lesser General Public

10

 * License as published by the Free Software Foundation; either

11

 * version 2.1 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

 * Lesser General Public License for more details.

17

18

 * You should have received a copy of the GNU Lesser General Public

19

 * License along with this library; if not, write to the

20

 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

21

 * Boston, MA 02110-1301, USA.

22

*/

23

24

/* deviceeventcontroller.c: implement the DeviceEventController interface */

25

26

#include "config.h"

27

28

#undef SPI_XKB_DEBUG

29

#undef SPI_DEBUG

30

#undef SPI_KEYEVENT_DEBUG

31

32

#include <ctype.h>

33

#include <stdio.h>

34

#include <string.h>

35

#include <sys/time.h>

36

37

#include <glib.h>

38

39

#include <dbus/dbus.h>

40

41

#include "de-types.h"

42

#include "keymasks.h"

43

#include "marshal-dbus.h"

44

#include "paths.h"

45

46

#include "deviceeventcontroller.h"

47

#include "introspection.h"

48

#include "reentrant-list.h"

49

50

#ifdef HAVE_X11

51

#include "deviceeventcontroller-x11.h"

52

#endif

53

54

/* Our parent Gtk object type */

55

#define PARENT_TYPE G_TYPE_OBJECT

56

57

#ifndef HAVE_X11

58

/* If we are using X11, SpiDEControllerPrivate is defined in deviceeventcontroller-x11.h.

59

 * Otherwise, there is no private data and so we use a dummy struct.

60

 * This is so that G_ADD_PRIVATE() will have a type to work with.

61

*/

62

typedef struct

63

64

  int _dummy;

65

} SpiDEControllerPrivate;

66

#endif

67

68

typedef struct

69

70

  gint x;

71

  gint y;

72

} SpiPoint;

73

74

static unsigned int key_modifier_mask =

75

    SPI_KEYMASK_MOD1 | SPI_KEYMASK_MOD2 | SPI_KEYMASK_MOD3 | SPI_KEYMASK_MOD4 |

76

    SPI_KEYMASK_MOD5 | SPI_KEYMASK_SHIFT | SPI_KEYMASK_SHIFTLOCK |

77

    SPI_KEYMASK_CONTROL | SPI_KEYMASK_NUMLOCK;

78

unsigned int _numlock_physical_mask = SPI_KEYMASK_MOD2; /* a guess, will be reset */

79

80

typedef struct

81

82

  guint ref_count : 30;

83

  guint pending_add : 1;

84

  guint pending_remove : 1;

85

86

  Accessibility_ControllerEventMask mod_mask;

87

  dbus_uint32_t key_val; /* KeyCode */

88

} DEControllerGrabMask;

89

90

gboolean spi_controller_update_key_grabs (SpiDEController *controller,

91

                                          Accessibility_DeviceEvent *recv);

92

93

static gboolean eventtype_seq_contains_event (dbus_uint32_t types,

94

                                              const Accessibility_DeviceEvent *event);

95

static gboolean spi_dec_poll_mouse_moving (gpointer data);

96

static gboolean spi_dec_poll_mouse_idle (gpointer data);

97

98

28

G_DEFINE_TYPE_WITH_CODE (SpiDEController, spi_device_event_controller, G_TYPE_OBJECT, G_ADD_PRIVATE (SpiDEController))

99

100

static gint

101

spi_dec_plat_get_keycode (SpiDEController *controller,

102

                          gint keysym,

103

                          gchar *key_str,

104

                          gboolean fix,

105

                          guint *modmask)

106

107

  SpiDEControllerClass *klass;

108

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

109

  if (klass->plat.get_keycode)

110

    return klass->plat.get_keycode (controller, keysym, key_str, fix, modmask);

111

  else

112

113

      if (modmask)

114

115

          *modmask = 0;

116

117

      return keysym;

118

119

120

121

static guint

122

spi_dec_plat_mouse_check (SpiDEController *controller,

123

                          int *x,

124

                          int *y,

125

                          gboolean *moved)

126

127

  SpiDEControllerClass *klass;

128

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

129

  if (klass->plat.mouse_check)

130

    return klass->plat.mouse_check (controller, x, y, moved);

131

  else

132

133

      if (moved)

134

135

          *moved = FALSE;

136

137

      return 0;

138

139

140

141

static gboolean

142

spi_dec_plat_grab_key (SpiDEController *controller, guint key_val, Accessibility_ControllerEventMask mod_mask)

143

144

  SpiDEControllerClass *klass;

145

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

146

  if (klass->plat.grab_key)

147

    return klass->plat.grab_key (controller, key_val, mod_mask);

148

  else

149

    return FALSE;

150

151

152

static void

153

spi_dec_plat_ungrab_key (SpiDEController *controller, guint key_val, Accessibility_ControllerEventMask mod_mask)

154

155

  SpiDEControllerClass *klass;

156

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

157

  if (klass->plat.ungrab_key)

158

    klass->plat.ungrab_key (controller, key_val, mod_mask);

159

160

161

static gboolean

162

spi_dec_plat_synth_keycode_press (SpiDEController *controller,

163

                                  unsigned int keycode)

164

165

  SpiDEControllerClass *klass;

166

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

167

  if (klass->plat.synth_keycode_press)

168

    return klass->plat.synth_keycode_press (controller, keycode);

169

  else

170

    return FALSE;

171

172

173

static gboolean

174

spi_dec_plat_synth_keycode_release (SpiDEController *controller,

175

                                    unsigned int keycode)

176

177

  SpiDEControllerClass *klass;

178

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

179

  if (klass->plat.synth_keycode_release)

180

    return klass->plat.synth_keycode_release (controller, keycode);

181

  else

182

    return FALSE;

183

184

185

static gboolean

186

spi_dec_plat_lock_modifiers (SpiDEController *controller, unsigned modifiers)

187

188

  SpiDEControllerClass *klass;

189

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

190

  if (klass->plat.lock_modifiers)

191

    return klass->plat.lock_modifiers (controller, modifiers);

192

  else

193

    return FALSE;

194

195

196

static gboolean

197

spi_dec_plat_unlock_modifiers (SpiDEController *controller, unsigned modifiers)

198

199

  SpiDEControllerClass *klass;

200

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

201

  if (klass->plat.unlock_modifiers)

202

    return klass->plat.unlock_modifiers (controller, modifiers);

203

  else

204

    return FALSE;

205

206

207

static gboolean

208

spi_dec_plat_synth_keystring (SpiDEController *controller, guint synth_type, gint keycode, const char *keystring)

209

210

  SpiDEControllerClass *klass;

211

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

212

  if (klass->plat.synth_keystring)

213

    return klass->plat.synth_keystring (controller, synth_type, keycode, keystring);

214

  else

215

    return FALSE;

216

217

218

static void

219

spi_dec_plat_emit_modifier_event (SpiDEController *controller, guint prev_mask, guint current_mask)

220

221

  SpiDEControllerClass *klass;

222

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

223

  if (klass->plat.emit_modifier_event)

224

    klass->plat.emit_modifier_event (controller, prev_mask, current_mask);

225

226

227

static void

228

spi_dec_plat_generate_mouse_event (SpiDEController *controller,

229

                                   gint x,

230

                                   gint y,

231

                                   const char *eventName)

232

233

  SpiDEControllerClass *klass;

234

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

235

  if (klass->plat.generate_mouse_event)

236

    klass->plat.generate_mouse_event (controller, x, y, eventName);

237

238

239

static DBusMessage *

240

invalid_arguments_error (DBusMessage *message)

241

242

  DBusMessage *reply;

243

  gchar *errmsg;

244

245

  errmsg = g_strdup_printf (

246

      "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n",

247

      dbus_message_get_member (message),

248

      dbus_message_get_signature (message),

249

      dbus_message_get_interface (message));

250

  reply = dbus_message_new_error (message,

251

                                  DBUS_ERROR_INVALID_ARGS,

252

                                  errmsg);

253

  g_free (errmsg);

254

  return reply;

255

256

257

/* Private methods */

258

static dbus_bool_t

259

spi_dbus_add_disconnect_match (DBusConnection *bus, const char *name)

260

261

  char *match = g_strdup_printf ("interface=%s,member=NameOwnerChanged,arg0=%s", DBUS_INTERFACE_DBUS, name);

262

  DBusError error;

263

  dbus_error_init (&error);

264

  dbus_bus_add_match (bus, match, &error);

265

  g_free (match);

266

  if (dbus_error_is_set (&error))

267

268

      dbus_error_free (&error);

269

      return FALSE;

270

271

  else

272

273

      return TRUE;

274

275

276

277

static dbus_bool_t

278

spi_dbus_remove_disconnect_match (DBusConnection *bus, const char *name)

279

280

  char *match = g_strdup_printf ("interface=%s,member=NameOwnerChanged,arg0=%s", DBUS_INTERFACE_DBUS, name);

281

  if (match)

282

283

      DBusError error;

284

      dbus_error_init (&error);

285

      dbus_bus_remove_match (bus, match, &error);

286

      g_free (match);

287

      if (dbus_error_is_set (&error))

288

289

          dbus_error_free (&error);

290

          return FALSE;

291

292

      else

293

294

          return TRUE;

295

296

297

  else

298

    return FALSE;

299

300

301

static DEControllerGrabMask *

302

spi_grab_mask_clone (DEControllerGrabMask *grab_mask)

303

304

  DEControllerGrabMask *clone = g_new (DEControllerGrabMask, 1);

305

306

  memcpy (clone, grab_mask, sizeof (DEControllerGrabMask));

307

308

  clone->ref_count = 1;

309

  clone->pending_add = TRUE;

310

  clone->pending_remove = FALSE;

311

312

  return clone;

313

314

315

static void

316

spi_grab_mask_free (DEControllerGrabMask *grab_mask)

317

318

  g_free (grab_mask);

319

320

321

static gint

322

spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2)

323

324

  DEControllerGrabMask *l1 = (DEControllerGrabMask *) p1;

325

  DEControllerGrabMask *l2 = (DEControllerGrabMask *) p2;

326

327

  if (p1 == p2)

328

329

      return 0;

330

331

  else

332

333

      return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val));

334

335

336

337

void

338

spi_dec_dbus_emit (SpiDEController *controller, const char *interface, const char *name, const char *minor, int a1, int a2)

339

340

  DBusMessage *signal = NULL;

341

  DBusMessageIter iter, iter_dict, iter_variant;

342

  int nil = 0;

343

  const char *path = SPI_DBUS_PATH_ROOT;

344

345

  signal = dbus_message_new_signal (path, interface, name);

346

347

  dbus_message_iter_init_append (signal, &iter);

348

349

  dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &minor);

350

  dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &a1);

351

  dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &a2);

352

  dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "i", &iter_variant);

353

  dbus_message_iter_append_basic (&iter_variant, DBUS_TYPE_INT32, &nil);

354

  dbus_message_iter_close_container (&iter, &iter_variant);

355

356

  dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sv}", &iter_dict);

357

  dbus_message_iter_close_container (&iter, &iter_dict);

358

359

  dbus_connection_send (controller->bus, signal, NULL);

360

  dbus_message_unref (signal);

361

362

363

static gboolean

364

spi_dec_poll_mouse_moved (gpointer data)

365

366

  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data);

367

  int x, y;

368

  gboolean moved;

369

  guint mask_return;

370

371

  mask_return = spi_dec_plat_mouse_check (controller, &x, &y, &moved);

372

373

  if ((mask_return & key_modifier_mask) !=

374

      (controller->mouse_mask_state & key_modifier_mask))

375

376

      spi_dec_plat_emit_modifier_event (controller, controller->mouse_mask_state, mask_return);

377

      controller->mouse_mask_state = mask_return;

378

379

380

  return moved;

381

382

383

static gboolean

384

spi_dec_poll_mouse_idle (gpointer data)

385

386

  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data);

387

388

  if (!controller->have_mouse_event_listener)

389

    return FALSE;

390

  else if (!spi_dec_poll_mouse_moved (controller))

391

    return TRUE;

392

  else

393

394

      guint id;

395

      id = g_timeout_add (20, spi_dec_poll_mouse_moving, controller);

396

      g_source_set_name_by_id (id, "[at-spi2-core] spi_dec_poll_mouse_moving");

397

      return FALSE;

398

399

400

401

static gboolean

402

spi_dec_poll_mouse_moving (gpointer data)

403

404

  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data);

405

406

  if (!controller->have_mouse_event_listener)

407

    return FALSE;

408

  else if (spi_dec_poll_mouse_moved (controller))

409

    return TRUE;

410

  else

411

412

      guint id;

413

      id = g_timeout_add (100, spi_dec_poll_mouse_idle, controller);

414

      g_source_set_name_by_id (id, "[at-spi2-core] check_release");

415

      return FALSE;

416

417

418

419

/**

420

 * Eventually we can use this to make the marshalling of mask types

421

 * more sane, but for now we just use this to detect

422

 * the use of 'virtual' masks such as numlock and convert them to

423

 * system-specific mask values (i.e. ModMask).

424

425

**/

426

static Accessibility_ControllerEventMask

427

spi_dec_translate_mask (Accessibility_ControllerEventMask mask)

428

429

  Accessibility_ControllerEventMask tmp_mask;

430

  gboolean has_numlock;

431

432

  has_numlock = (mask & SPI_KEYMASK_NUMLOCK);

433

  tmp_mask = mask;

434

  if (has_numlock)

435

436

      tmp_mask = mask ^ SPI_KEYMASK_NUMLOCK;

437

      tmp_mask |= _numlock_physical_mask;

438

439

440

  return tmp_mask;

441

442

443

static DEControllerKeyListener *

444

spi_dec_key_listener_new (const char *bus_name,

445

                          const char *path,

446

                          GSList *keys,

447

                          const Accessibility_ControllerEventMask mask,

448

                          const dbus_uint32_t types,

449

                          const Accessibility_EventListenerMode *mode)

450

451

  DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);

452

  key_listener->listener.bus_name = g_strdup (bus_name);

453

  key_listener->listener.path = g_strdup (path);

454

  key_listener->listener.type = SPI_DEVICE_TYPE_KBD;

455

  key_listener->keys = keys;

456

  key_listener->mask = spi_dec_translate_mask (mask);

457

  key_listener->listener.types = types;

458

  if (mode)

459

460

      key_listener->mode = (Accessibility_EventListenerMode *) g_malloc (sizeof (Accessibility_EventListenerMode));

461

      memcpy (key_listener->mode, mode, sizeof (*mode));

462

463

  else

464

    key_listener->mode = NULL;

465

466

#ifdef SPI_DEBUG

467

  g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n",

468

           (unsigned int) key_listener->mask,

469

           (int) (mode ? mode->global : 0),

470

           (void *) key_listener->keys,

471

           (int) (key_listener->keys ? g_slist_length (key_listener->keys) : 0));

472

#endif

473

474

  return key_listener;

475

476

477

static GSList *

478

keylist_clone (GSList *s)

479

480

  GSList *d = NULL;

481

  GSList *l;

482

483

  for (l = s; l; l = g_slist_next (l))

484

485

      Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) g_malloc (sizeof (Accessibility_KeyDefinition));

486

      if (kd)

487

488

          Accessibility_KeyDefinition *kds = (Accessibility_KeyDefinition *) l->data;

489

          kd->keycode = kds->keycode;

490

          kd->keysym = kds->keysym;

491

          kd->keystring = g_strdup (kds->keystring);

492

          d = g_slist_append (d, kd);

493

494

495

  return d;

496

497

498

static DEControllerKeyListener *

499

spi_key_listener_clone (DEControllerKeyListener *key_listener)

500

501

  DEControllerKeyListener *clone = g_new0 (DEControllerKeyListener, 1);

502

  clone->listener.bus_name = g_strdup (key_listener->listener.bus_name);

503

  clone->listener.path = g_strdup (key_listener->listener.path);

504

  clone->listener.type = SPI_DEVICE_TYPE_KBD;

505

  clone->keys = keylist_clone (key_listener->keys);

506

  clone->mask = key_listener->mask;

507

  clone->listener.types = key_listener->listener.types;

508

  if (key_listener->mode)

509

510

      clone->mode = (Accessibility_EventListenerMode *) g_malloc (sizeof (Accessibility_EventListenerMode));

511

      if (clone->mode)

512

        memcpy (clone->mode, key_listener->mode, sizeof (Accessibility_EventListenerMode));

513

514

  else

515

    clone->mode = NULL;

516

  return clone;

517

518

519

static void

520

keylist_free (GSList *keys)

521

522

  GSList *l;

523

524

  for (l = keys; l; l = g_slist_next (l))

525

526

      Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) l->data;

527

      g_free (kd->keystring);

528

      g_free (kd);

529

530

  g_slist_free (keys);

531

532

533

static void

534

spi_key_listener_data_free (DEControllerKeyListener *key_listener)

535

536

  keylist_free (key_listener->keys);

537

  if (key_listener->mode)

538

    g_free (key_listener->mode);

539

  g_free (key_listener->listener.bus_name);

540

  g_free (key_listener->listener.path);

541

  g_free (key_listener);

542

543

544

static void

545

spi_key_listener_clone_free (DEControllerKeyListener *clone)

546

547

  spi_key_listener_data_free (clone);

548

549

550

static void

551

spi_dec_listener_free (DEControllerListener *listener)

552

553

  if (listener->type == SPI_DEVICE_TYPE_KBD)

554

    spi_key_listener_data_free ((DEControllerKeyListener *) listener);

555

  else

556

557

      g_free (listener->bus_name);

558

      g_free (listener->path);

559

560

561

562

static void

563

_register_keygrab (SpiDEController *controller,

564

                   DEControllerGrabMask *grab_mask)

565

566

  GList *l;

567

568

  l = g_list_find_custom (controller->keygrabs_list, grab_mask,

569

                          spi_grab_mask_compare_values);

570

  if (l)

571

572

      DEControllerGrabMask *cur_mask = l->data;

573

574

      cur_mask->ref_count++;

575

      if (cur_mask->pending_remove)

576

577

          cur_mask->pending_remove = FALSE;

578

579

580

  else

581

582

      controller->keygrabs_list =

583

          g_list_prepend (controller->keygrabs_list,

584

                          spi_grab_mask_clone (grab_mask));

585

586

587

588

static void

589

_deregister_keygrab (SpiDEController *controller,

590

                     DEControllerGrabMask *grab_mask)

591

592

  GList *l;

593

594

  l = g_list_find_custom (controller->keygrabs_list, grab_mask,

595

                          spi_grab_mask_compare_values);

596

597

  if (l)

598

599

      DEControllerGrabMask *cur_mask = l->data;

600

601

      cur_mask->ref_count--;

602

      if (cur_mask->ref_count <= 0)

603

604

          cur_mask->pending_remove = TRUE;

605

606

607

608

609

static void

610

handle_keygrab (SpiDEController *controller,

611

                DEControllerKeyListener *key_listener,

612

                void (*process_cb) (SpiDEController *controller,

613

                                    DEControllerGrabMask *grab_mask))

614

615

  DEControllerGrabMask grab_mask = { 0 };

616

617

  grab_mask.mod_mask = key_listener->mask;

618

  if (g_slist_length (key_listener->keys) == 0) /* special case means AnyKey/AllKeys */

619

620

      grab_mask.key_val = 0L; /* AnyKey */

621

#ifdef SPI_DEBUG

622

      fprintf (stderr, "AnyKey grab!");

623

#endif

624

      process_cb (controller, &grab_mask);

625

626

  else

627

628

      GSList *l;

629

630

      for (l = key_listener->keys; l; l = g_slist_next (l))

631

632

          Accessibility_KeyDefinition *keydef = l->data;

633

          long key_val;

634

          key_val = spi_dec_plat_get_keycode (controller, keydef->keysym, keydef->keystring, FALSE, NULL);

635

          if (!key_val)

636

            key_val = keydef->keycode;

637

          grab_mask.key_val = key_val;

638

          process_cb (controller, &grab_mask);

639

640

641

642

643

static gboolean

644

spi_controller_register_global_keygrabs (SpiDEController *controller,

645

                                         DEControllerKeyListener *key_listener)

646

647

  handle_keygrab (controller, key_listener, _register_keygrab);

648

  return spi_controller_update_key_grabs (controller, NULL);

649

650

651

static void

652

spi_controller_deregister_global_keygrabs (SpiDEController *controller,

653

                                           DEControllerKeyListener *key_listener)

654

655

  handle_keygrab (controller, key_listener, _deregister_keygrab);

656

  spi_controller_update_key_grabs (controller, NULL);

657

658

659

static void

660

append_keystroke_listener (DBusMessageIter *iter, DEControllerKeyListener *listener)

661

662

  dbus_uint32_t d_uint;

663

  DBusMessageIter iter_struct, iter_subarray, iter_substruct;

664

  GSList *kl;

665

666

  if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL,

667

                                         &iter_struct))

668

    return;

669

670

  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING,

671

                                  &listener->listener.bus_name);

672

  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH,

673

                                  &listener->listener.path);

674

  d_uint = listener->listener.type;

675

  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);

676

  d_uint = listener->listener.types;

677

  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);

678

  if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY,

679

                                         "(iisi)", &iter_subarray))

680

681

      dbus_message_iter_close_container (iter, &iter_struct);

682

      return;

683

684

  for (kl = listener->keys; kl; kl = kl->next)

685

686

      Accessibility_KeyDefinition *kd = kl->data;

687

      if (!dbus_message_iter_open_container (&iter_subarray, DBUS_TYPE_STRUCT,

688

                                             NULL, &iter_substruct))

689

        break;

690

      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keycode);

691

      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keysym);

692

      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_STRING, &kd->keystring);

693

      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->unused);

694

      dbus_message_iter_close_container (&iter_subarray, &iter_substruct);

695

696

  dbus_message_iter_close_container (&iter_struct, &iter_subarray);

697

  d_uint = listener->mask;

698

  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);

699

  if (dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_STRUCT,

700

                                        NULL, &iter_substruct))

701

702

      if (listener->mode)

703

704

          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,

705

                                          &listener->mode->synchronous);

706

          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,

707

                                          &listener->mode->preemptive);

708

          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,

709

                                          &listener->mode->global);

710

711

      else

712

713

          dbus_bool_t dummy_val = FALSE;

714

          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,

715

                                          &dummy_val);

716

          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,

717

                                          &dummy_val);

718

          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,

719

                                          &dummy_val);

720

721

      dbus_message_iter_close_container (&iter_struct, &iter_substruct);

722

723

  dbus_message_iter_close_container (iter, &iter_struct);

724

725

726

static void

727

notify_keystroke_listener (SpiDEController *controller,

728

                           DEControllerKeyListener *listener,

729

                           gboolean enable)

730

731

  const char *path = SPI_DBUS_PATH_DEC;

732

  const char *interface = SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER;

733

  const char *name = (enable

734

                          ? "KeystrokeListenerRegistered"

735

                          : "KeystrokeListenerDeregistered");

736

  DBusMessage *signal;

737

  DBusMessageIter iter;

738

739

  signal = dbus_message_new_signal (path, interface, name);

740

  if (!signal)

741

    return;

742

  dbus_message_iter_init_append (signal, &iter);

743

  append_keystroke_listener (&iter, listener);

744

  dbus_connection_send (controller->bus, signal, NULL);

745

  dbus_message_unref (signal);

746

747

748

static gboolean

749

spi_controller_register_device_listener (SpiDEController *controller,

750

                                         DEControllerListener *listener)

751

752

  DEControllerKeyListener *key_listener;

753

  gboolean retval;

754

755

  switch (listener->type)

756

757

    case SPI_DEVICE_TYPE_KBD:

758

      key_listener = (DEControllerKeyListener *) listener;

759

760

      controller->key_listeners = g_list_prepend (controller->key_listeners,

761

                                                  key_listener);

762

      spi_dbus_add_disconnect_match (controller->bus, key_listener->listener.bus_name);

763

      if (key_listener->mode->global)

764

765

          retval = spi_controller_register_global_keygrabs (controller, key_listener);

766

767

      else

768

        retval = TRUE;

769

      if (retval)

770

        notify_keystroke_listener (controller, key_listener, TRUE);

771

      break;

772

    default:

773

      g_assert_not_reached ();

774

      break;

775

776

  return FALSE;

777

778

779

static void

780

set_reply (DBusPendingCall *pending, void *user_data)

781

782

  void **replyptr = (void **) user_data;

783

784

  *replyptr = dbus_pending_call_steal_reply (pending);

785

786

787

static GSList *hung_processes = NULL;

788

789

static void

790

reset_hung_process (DBusPendingCall *pending, void *data)

791

792

  DBusMessage *message = data;

793

  const char *dest = dbus_message_get_destination (message);

794

  GSList *l;

795

796

  /* At this point we don't care about the result */

797

  dbus_pending_call_unref (pending);

798

799

  for (l = hung_processes; l; l = l->next)

800

801

      if (!strcmp (l->data, dest))

802

803

          gpointer l_data = l->data;

804

          hung_processes = g_slist_remove (hung_processes, l_data);

805

          g_free (l_data);

806

          break;

807

808

809

810

811

static gint

812

time_elapsed (struct timeval *origin)

813

814

  struct timeval tv;

815

816

  gettimeofday (&tv, NULL);

817

  return (tv.tv_sec - origin->tv_sec) * 1000 + (tv.tv_usec - origin->tv_usec) / 1000;

818

819

820

static void

821

reset_hung_process_from_ping (DBusPendingCall *pending, void *data)

822

823

  GSList *l;

824

825

  for (l = hung_processes; l; l = l->next)

826

827

      if (!strcmp (l->data, data))

828

829

          gpointer l_data = l->data;

830

          hung_processes = g_slist_remove (hung_processes, l_data);

831

          g_free (l_data);

832

          break;

833

834

835

  g_free (data);

836

  dbus_pending_call_unref (pending);

837

838

839

static DBusMessage *

840

send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, int timeout, DBusError *error)

841

842

  DBusPendingCall *pending;

843

  DBusMessage *reply = NULL;

844

  struct timeval tv;

845

846

  if (!dbus_connection_send_with_reply (bus, message, &pending, -1))

847

848

      return NULL;

849

850

  dbus_pending_call_set_notify (pending, set_reply, (void *) &reply, NULL);

851

  gettimeofday (&tv, NULL);

852

  while (!reply)

853

854

      if (!dbus_connection_read_write_dispatch (bus, timeout) ||

855

          time_elapsed (&tv) > timeout)

856

857

          const char *dest = dbus_message_get_destination (message);

858

          GSList *l;

859

          gchar *bus_name_dup;

860

          dbus_message_ref (message);

861

          dbus_pending_call_set_notify (pending, reset_hung_process, message,

862

                                        (DBusFreeFunction) dbus_message_unref);

863

          message = dbus_message_new_method_call (dest, "/",

864

                                                  "org.freedesktop.DBus.Peer",

865

                                                  "Ping");

866

          if (!message)

867

            return NULL;

868

          dbus_connection_send_with_reply (bus, message, &pending, -1);

869

          dbus_message_unref (message);

870

          if (!pending)

871

            return NULL;

872

          bus_name_dup = g_strdup (dest);

873

          dbus_pending_call_set_notify (pending, reset_hung_process_from_ping,

874

                                        bus_name_dup, NULL);

875

          for (l = hung_processes; l; l = l->next)

876

            if (!strcmp (l->data, dest))

877

              return NULL;

878

          hung_processes = g_slist_prepend (hung_processes, g_strdup (dest));

879

          return NULL;

880

881

882

  dbus_pending_call_unref (pending);

883

  return reply;

884

885

static gboolean

886

Accessibility_DeviceEventListener_NotifyEvent (SpiDEController *controller,

887

                                               DEControllerListener *listener,

888

                                               const Accessibility_DeviceEvent *key_event)

889

890

  DBusMessage *message = dbus_message_new_method_call (listener->bus_name,

891

                                                       listener->path,

892

                                                       SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER,

893

                                                       "NotifyEvent");

894

  dbus_bool_t consumed = FALSE;

895

  GSList *l;

896

  gboolean hung = FALSE;

897

898

  for (l = hung_processes; l; l = l->next)

899

900

      if (!strcmp (l->data, listener->bus_name))

901

902

          dbus_message_set_no_reply (message, TRUE);

903

          hung = TRUE;

904

          break;

905

906

907

908

  if (spi_dbus_marshal_deviceEvent (message, key_event))

909

910

      DBusMessage *reply;

911

912

      if (hung)

913

914

          dbus_connection_send (controller->bus, message, NULL);

915

          dbus_message_unref (message);

916

          return FALSE;

917

918

919

      reply = send_and_allow_reentry (controller->bus, message, 3000, NULL);

920

      if (reply)

921

922

          dbus_message_get_args (reply, NULL, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID);

923

          dbus_message_unref (reply);

924

925

926

  dbus_message_unref (message);

927

  return consumed;

928

929

930

static gboolean

931

key_set_contains_key (GSList *key_set,

932

                      const Accessibility_DeviceEvent *key_event)

933

934

  gint i;

935

  gint len;

936

  GSList *l;

937

938

  if (!key_set)

939

940

#ifdef SPI_DEBUG

941

      g_print ("null key set!\n");

942

#endif

943

      return TRUE;

944

945

946

  len = g_slist_length (key_set);

947

948

  if (len == 0) /* special case, means "all keys/any key" */

949

950

#ifdef SPI_DEBUG

951

      g_print ("anykey\n");

952

#endif

953

      return TRUE;

954

955

956

  for (l = key_set, i = 0; l; l = g_slist_next (l), i++)

957

958

      Accessibility_KeyDefinition *kd = l->data;

959

#ifdef SPI_KEYEVENT_DEBUG

960

      g_print ("key_set[%d] event = %d, code = %d; key_event %d, code %d, string %s\n",

961

i,

962

               (int) kd->keysym,

963

               (int) kd->keycode,

964

               (int) key_event->id,

965

               (int) key_event->hw_code,

966

               key_event->event_string);

967

#endif

968

      if (kd->keysym == (dbus_uint32_t) key_event->id)

969

970

          return TRUE;

971

972

      if (kd->keycode == (dbus_uint32_t) key_event->hw_code)

973

974

          return TRUE;

975

976

      if (key_event->event_string && key_event->event_string[0] &&

977

          !strcmp (kd->keystring, key_event->event_string))

978

979

          return TRUE;

980

981

982

983

  return FALSE;

984

985

986

static gboolean

987

eventtype_seq_contains_event (dbus_uint32_t types,

988

                              const Accessibility_DeviceEvent *event)

989

990

  if (types == 0) /* special case, means "all events/any event" */

991

992

      return TRUE;

993

994

995

  return (types & (1 << event->type));

996

997

998

static gboolean

999

spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,

1000

                                DEControllerKeyListener *listener,

1001

                                dbus_bool_t is_system_global)

1002

1003

  if (((key_event->modifiers & 0xFF) == (dbus_uint16_t) (listener->mask & 0xFF)) &&

1004

      key_set_contains_key (listener->keys, key_event) &&

1005

      eventtype_seq_contains_event (listener->listener.types, key_event) &&

1006

      (is_system_global == listener->mode->global))

1007

1008

      return TRUE;

1009

1010

  else

1011

1012

      return FALSE;

1013

1014

1015

1016

gboolean

1017

spi_controller_notify_keylisteners (SpiDEController *controller,

1018

                                    Accessibility_DeviceEvent *key_event,

1019

                                    dbus_bool_t is_system_global)

1020

1021

  GList *l;

1022

  GSList *notify = NULL, *l2;

1023

  GList **key_listeners = &controller->key_listeners;

1024

  gboolean is_consumed;

1025

1026

  if (!key_listeners)

1027

1028

      return FALSE;

1029

1030

1031

  /* set the NUMLOCK event mask bit if appropriate: see bug #143702 */

1032

  if (key_event->modifiers & _numlock_physical_mask)

1033

    key_event->modifiers |= SPI_KEYMASK_NUMLOCK;

1034

1035

  for (l = *key_listeners; l; l = l->next)

1036

1037

      DEControllerKeyListener *key_listener = l->data;

1038

1039

      if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))

1040

1041

          /* we clone (don't dup) the listener, to avoid refcount inc. */

1042

          notify = g_slist_prepend (notify,

1043

                                    spi_key_listener_clone (key_listener));

1044

1045

1046

1047

#ifdef SPI_KEYEVENT_DEBUG

1048

  if (!notify)

1049

1050

      g_print ("no match for event\n");

1051

1052

#endif

1053

1054

  is_consumed = FALSE;

1055

  for (l2 = notify; l2 && !is_consumed; l2 = l2->next)

1056

1057

      DEControllerKeyListener *key_listener = l2->data;

1058

1059

      is_consumed = Accessibility_DeviceEventListener_NotifyEvent (controller, &key_listener->listener, key_event) &&

1060

                    key_listener->mode->preemptive;

1061

1062

      spi_key_listener_clone_free (key_listener);

1063

1064

1065

  for (; l2; l2 = l2->next)

1066

1067

      DEControllerKeyListener *key_listener = l2->data;

1068

      spi_key_listener_clone_free (key_listener);

1069

      /* clone doesn't have its own ref, so don't use spi_dec_listener_free */

1070

1071

1072

  g_slist_free (notify);

1073

1074

#ifdef SPI_DEBUG

1075

  if (is_consumed)

1076

    g_message ("consumed\n");

1077

#endif

1078

  return is_consumed;

1079

1080

1081

gboolean

1082

spi_controller_update_key_grabs (SpiDEController *controller,

1083

                                 Accessibility_DeviceEvent *recv)

1084

1085

  GList *l, *next;

1086

  gboolean update_failed = FALSE;

1087

  long keycode = 0;

1088

1089

  g_return_val_if_fail (controller != NULL, FALSE);

1090

1091

/*

1092

   * masks known to work with default RH 7.1+:

1093

   * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,

1094

   * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,

1095

   * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,

1096

   * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,

1097

1098

   * ControlMask grabs are broken, must be in use already

1099

*/

1100

  if (recv)

1101

    keycode = spi_dec_plat_get_keycode (controller, recv->id, NULL, TRUE, NULL);

1102

  for (l = controller->keygrabs_list; l; l = next)

1103

1104

      gboolean do_remove;

1105

      gboolean re_issue_grab;

1106

      DEControllerGrabMask *grab_mask = l->data;

1107

1108

      next = l->next;

1109

1110

      re_issue_grab = recv &&

1111

                      (recv->modifiers & grab_mask->mod_mask) &&

1112

                      (grab_mask->key_val == keycode);

1113

1114

#ifdef SPI_DEBUG

1115

      fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",

1116

               (long int) grab_mask->key_val,

1117

               (long int) grab_mask->mod_mask,

1118

               grab_mask->pending_add ? '+' : '.',

1119

               grab_mask->pending_remove ? '-' : '.',

1120

               re_issue_grab ? "re-issue" : "");

1121

#endif

1122

1123

      do_remove = FALSE;

1124

1125

      if (grab_mask->pending_add && grab_mask->pending_remove)

1126

1127

          do_remove = TRUE;

1128

1129

      else if (grab_mask->pending_remove)

1130

1131

#ifdef SPI_DEBUG

1132

          fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);

1133

#endif

1134

          spi_dec_plat_ungrab_key (controller,

1135

                                   grab_mask->key_val,

1136

                                   grab_mask->mod_mask);

1137

1138

          do_remove = TRUE;

1139

1140

      else if (grab_mask->pending_add || re_issue_grab)

1141

1142

1143

#ifdef SPI_DEBUG

1144

          fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask);

1145

#endif

1146

          update_failed = spi_dec_plat_grab_key (controller,

1147

                                                 grab_mask->key_val,

1148

                                                 grab_mask->mod_mask);

1149

          if (update_failed)

1150

1151

              while (grab_mask->ref_count > 0)

1152

                --grab_mask->ref_count;

1153

              do_remove = TRUE;

1154

1155

1156

1157

      grab_mask->pending_add = FALSE;

1158

      grab_mask->pending_remove = FALSE;

1159

1160

      if (do_remove)

1161

1162

          g_assert (grab_mask->ref_count <= 0);

1163

1164

          controller->keygrabs_list = g_list_delete_link (

1165

              controller->keygrabs_list, l);

1166

1167

          spi_grab_mask_free (grab_mask);

1168

1169

1170

1171

  return !update_failed;

1172

1173

1174

/*

1175

 * Implemented GObject::finalize

1176

*/

1177

static void

1178

spi_device_event_controller_object_finalize (GObject *object)

1179

1180

  SpiDEController *controller;

1181

  GObjectClass *parent_class = G_OBJECT_CLASS (spi_device_event_controller_parent_class);

1182

  SpiDEControllerClass *klass;

1183

1184

  controller = SPI_DEVICE_EVENT_CONTROLLER (object);

1185

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);

1186

#ifdef SPI_DEBUG

1187

  fprintf (stderr, "spi_device_event_controller_object_finalize called\n");

1188

#endif

1189

  if (klass->plat.finalize)

1190

    klass->plat.finalize (controller);

1191

1192

  parent_class->finalize (object);

1193

1194

1195

/*

1196

 * DBus Accessibility::DEController::RegisterKeystrokeListener

1197

 *     method implementation

1198

*/

1199

static DBusMessage *

1200

impl_register_keystroke_listener (DBusMessage *message, SpiDEController *controller)

1201

1202

  DEControllerKeyListener *dec_listener;

1203

  DBusMessageIter iter, iter_array;

1204

  const char *path;

1205

  GSList *keys = NULL;

1206

  dbus_int32_t mask, types;

1207

  Accessibility_EventListenerMode *mode;

1208

  dbus_bool_t ret;

1209

  DBusMessage *reply = NULL;

1210

  char *keystring;

1211

1212

  if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu(bbb)") != 0)

1213

    return invalid_arguments_error (message);

1214

1215

  dbus_message_iter_init (message, &iter);

1216

  dbus_message_iter_get_basic (&iter, &path);

1217

  dbus_message_iter_next (&iter);

1218

  dbus_message_iter_recurse (&iter, &iter_array);

1219

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

1220

1221

      Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) g_malloc (sizeof (Accessibility_KeyDefinition));

1222

      if (!spi_dbus_message_iter_get_struct (&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID))

1223

1224

          g_free (kd);

1225

          break;

1226

1227

      kd->keystring = g_strdup (keystring);

1228

      keys = g_slist_append (keys, kd);

1229

1230

  dbus_message_iter_next (&iter);

1231

  dbus_message_iter_get_basic (&iter, &mask);

1232

  dbus_message_iter_next (&iter);

1233

  dbus_message_iter_get_basic (&iter, &types);

1234

  dbus_message_iter_next (&iter);

1235

  mode = g_new0 (Accessibility_EventListenerMode, 1);

1236

  spi_dbus_message_iter_get_struct (&iter, DBUS_TYPE_BOOLEAN, &mode->synchronous, DBUS_TYPE_BOOLEAN, &mode->preemptive, DBUS_TYPE_BOOLEAN, &mode->global, DBUS_TYPE_INVALID);

1237

1238

#ifdef SPI_DEBUG

1239

  fprintf (stderr, "registering keystroke listener %s:%s with maskVal %lu\n",

1240

           dbus_message_get_sender (message), path, (unsigned long) mask);

1241

#endif

1242

  dec_listener = spi_dec_key_listener_new (dbus_message_get_sender (message), path, keys, mask, types, mode);

1243

  g_free (mode);

1244

  ret = spi_controller_register_device_listener (

1245

      controller, (DEControllerListener *) dec_listener);

1246

  reply = dbus_message_new_method_return (message);

1247

  if (reply)

1248

1249

      dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);

1250

1251

  return reply;

1252

1253

1254

typedef struct

1255

1256

  DBusConnection *bus;

1257

  DEControllerListener *listener;

1258

} RemoveListenerClosure;

1259

1260

static SpiReEntrantContinue

1261

remove_listener_cb (GList *const *list,

1262

                    gpointer user_data)

1263

1264

  DEControllerListener *listener = (*list)->data;

1265

  RemoveListenerClosure *ctx = user_data;

1266

1267

  if (!strcmp (ctx->listener->bus_name, listener->bus_name) &&

1268

      !strcmp (ctx->listener->path, listener->path))

1269

1270

      spi_re_entrant_list_delete_link (list);

1271

      spi_dbus_remove_disconnect_match (ctx->bus, listener->bus_name);

1272

      spi_dec_listener_free (listener);

1273

1274

1275

  return SPI_RE_ENTRANT_CONTINUE;

1276

1277

1278

static SpiReEntrantContinue

1279

copy_key_listener_cb (GList *const *list,

1280

                      gpointer user_data)

1281

1282

  DEControllerKeyListener *key_listener = (*list)->data;

1283

  RemoveListenerClosure *ctx = user_data;

1284

1285

  if (!strcmp (ctx->listener->bus_name, key_listener->listener.bus_name) &&

1286

      !strcmp (ctx->listener->path, key_listener->listener.path))

1287

1288

      /* TODO: FIXME aggregate keys in case the listener is registered twice */

1289

      DEControllerKeyListener *ctx_key_listener =

1290

          (DEControllerKeyListener *) ctx->listener;

1291

      keylist_free (ctx_key_listener->keys);

1292

      ctx_key_listener->keys = keylist_clone (key_listener->keys);

1293

1294

1295

  return SPI_RE_ENTRANT_CONTINUE;

1296

1297

1298

static void

1299

spi_deregister_controller_key_listener (SpiDEController *controller,

1300

                                        DEControllerKeyListener *key_listener)

1301

1302

  RemoveListenerClosure ctx;

1303

1304

  ctx.bus = controller->bus;

1305

  ctx.listener = (DEControllerListener *) spi_key_listener_clone (key_listener);

1306

1307

  notify_keystroke_listener (controller, key_listener, FALSE);

1308

1309

  /* special case, copy keyset from existing controller list entry */

1310

  if (g_slist_length (key_listener->keys) == 0)

1311

1312

      spi_re_entrant_list_foreach (&controller->key_listeners,

1313

                                   copy_key_listener_cb, &ctx);

1314

1315

1316

  spi_controller_deregister_global_keygrabs (controller, key_listener);

1317

1318

  spi_re_entrant_list_foreach (&controller->key_listeners,

1319

                               remove_listener_cb, &ctx);

1320

1321

  spi_key_listener_clone_free ((DEControllerKeyListener *) ctx.listener);

1322

1323

1324

void

1325

162

spi_remove_device_listeners (SpiDEController *controller, const char *bus_name)

1326

1327

  GList *l, *tmp;

1328

1329

162

  for (l = controller->key_listeners; l; l = tmp)

1330

1331

      DEControllerKeyListener *key_listener = l->data;

1332

      tmp = l->next;

1333

      if (!strcmp (key_listener->listener.bus_name, bus_name))

1334

1335

          /* TODO: untangle the below line(s) */

1336

          spi_deregister_controller_key_listener (controller, key_listener);

1337

          tmp = controller->key_listeners;

1338

1339

1340

162

1341

1342

/*

1343

 * DBus Accessibility::DEController::DeregisterKeystrokeListener

1344

 *     method implementation

1345

*/

1346

static DBusMessage *

1347

impl_deregister_keystroke_listener (DBusMessage *message, SpiDEController *controller)

1348

1349

  DEControllerKeyListener *key_listener;

1350

  DBusMessageIter iter, iter_array;

1351

  const char *path;

1352

  GSList *keys = NULL;

1353

  dbus_int32_t mask, type;

1354

  DBusMessage *reply = NULL;

1355

1356

  dbus_message_iter_init (message, &iter);

1357

  if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu") != 0)

1358

1359

      g_warning ("Received DeregisterKeystrokeListener with strange signature '%s'", dbus_message_get_signature (message));

1360

      return invalid_arguments_error (message);

1361

1362

1363

  dbus_message_iter_get_basic (&iter, &path);

1364

  dbus_message_iter_next (&iter);

1365

  dbus_message_iter_recurse (&iter, &iter_array);

1366

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

1367

1368

      Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) g_malloc (sizeof (Accessibility_KeyDefinition));

1369

      char *keystring;

1370

1371

      if (!spi_dbus_message_iter_get_struct (&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID))

1372

1373

          g_free (kd);

1374

          break;

1375

1376

      kd->keystring = g_strdup (keystring);

1377

      keys = g_slist_append (keys, kd);

1378

1379

  dbus_message_iter_next (&iter);

1380

  dbus_message_iter_get_basic (&iter, &mask);

1381

  dbus_message_iter_next (&iter);

1382

  dbus_message_iter_get_basic (&iter, &type);

1383

  dbus_message_iter_next (&iter);

1384

  key_listener = spi_dec_key_listener_new (dbus_message_get_sender (message), path, keys, mask, type, NULL);

1385

#ifdef SPI_DEREGISTER_DEBUG

1386

  fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",

1387

           (void *) l, (unsigned long) mask->value);

1388

#endif

1389

1390

  spi_deregister_controller_key_listener (controller, key_listener);

1391

1392

  spi_dec_listener_free ((DEControllerListener *) key_listener);

1393

  reply = dbus_message_new_method_return (message);

1394

  return reply;

1395

1396

1397

static DBusMessage *

1398

161

impl_get_keystroke_listeners (DBusMessage *message, SpiDEController *controller)

1399

1400

  DBusMessageIter iter, iter_array;

1401

161

  DBusMessage *reply = dbus_message_new_method_return (message);

1402

  GList *l;

1403

1404

161

  if (!reply)

1405

    return NULL;

1406

1407

161

  dbus_message_iter_init_append (reply, &iter);

1408

161

  dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,

1409

                                    "(souua(iisi)u(bbb))", &iter_array);

1410

161

  for (l = controller->key_listeners; l; l = l->next)

1411

1412

      append_keystroke_listener (&iter_array, l->data);

1413

1414

161

  dbus_message_iter_close_container (&iter, &iter_array);

1415

161

  return reply;

1416

1417

1418

static unsigned

1419

get_modifier_state (SpiDEController *controller)

1420

1421

  spi_dec_poll_mouse_moved (controller);

1422

  return controller->mouse_mask_state;

1423

1424

1425

gboolean

1426

spi_dec_synth_keysym (SpiDEController *controller, long keysym)

1427

1428

  long key_synth_code;

1429

  unsigned int modifiers, synth_mods, lock_mods;

1430

1431

  key_synth_code = spi_dec_plat_get_keycode (controller, keysym, NULL, TRUE, &synth_mods);

1432

1433

  if ((key_synth_code == 0) || (synth_mods == 0xFF))

1434

    return FALSE;

1435

1436

  /* TODO: set the modifiers accordingly! */

1437

  modifiers = get_modifier_state (controller);

1438

  /* side-effect; we may unset mousebutton modifiers here! */

1439

1440

  lock_mods = 0;

1441

  if (synth_mods != modifiers)

1442

1443

      lock_mods = synth_mods & ~modifiers;

1444

      spi_dec_plat_lock_modifiers (controller, lock_mods);

1445

      if (modifiers & SPI_KEYMASK_SHIFTLOCK)

1446

        spi_dec_plat_unlock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK);

1447

1448

  spi_dec_plat_synth_keycode_press (controller, key_synth_code);

1449

  spi_dec_plat_synth_keycode_release (controller, key_synth_code);

1450

1451

  if (synth_mods != modifiers)

1452

1453

      spi_dec_plat_unlock_modifiers (controller, lock_mods);

1454

      if (modifiers & SPI_KEYMASK_SHIFTLOCK)

1455

        spi_dec_plat_lock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK);

1456

1457

  return TRUE;

1458

1459

1460

/*

1461

 * DBus Accessibility::DEController::RegisterKeystrokeListener

1462

 *     method implementation

1463

*/

1464

static DBusMessage *

1465

impl_generate_keyboard_event (DBusMessage *message, SpiDEController *controller)

1466

1467

  dbus_int32_t keycode;

1468

  char *keystring;

1469

  dbus_uint32_t synth_type;

1470

  DBusMessage *reply = NULL;

1471

1472

  if (!dbus_message_get_args (message, NULL, DBUS_TYPE_INT32, &keycode, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_UINT32, &synth_type, DBUS_TYPE_INVALID))

1473

1474

      return invalid_arguments_error (message);

1475

1476

1477

#ifdef SPI_DEBUG

1478

  fprintf (stderr, "synthesizing keystroke %ld, type %d\n",

1479

           (long) keycode, (int) synth_type);

1480

#endif

1481

  /* TODO: hide/wrap/remove X dependency */

1482

1483

/*

1484

   * TODO: when initializing, query for XTest extension before using,

1485

   * and fall back to XSendEvent() if XTest is not available.

1486

*/

1487

1488

  switch (synth_type)

1489

1490

    case Accessibility_KEY_PRESS:

1491

      spi_dec_plat_synth_keycode_press (controller, keycode);

1492

      break;

1493

    case Accessibility_KEY_PRESSRELEASE:

1494

      spi_dec_plat_synth_keycode_press (controller, keycode);

1495

    case Accessibility_KEY_RELEASE:

1496

      spi_dec_plat_synth_keycode_release (controller, keycode);

1497

      break;

1498

    case Accessibility_KEY_SYM:

1499

#ifdef SPI_XKB_DEBUG

1500

      fprintf (stderr, "KeySym synthesis\n");

1501

#endif

1502

/*

1503

       * note: we are using long for 'keycode'

1504

       * in our arg list; it can contain either

1505

       * a keycode or a keysym.

1506

*/

1507

      spi_dec_synth_keysym (controller, keycode);

1508

      break;

1509

    case Accessibility_KEY_STRING:

1510

      if (!spi_dec_plat_synth_keystring (controller, synth_type, keycode, keystring))

1511

        fprintf (stderr, "Keystring synthesis failure, string=%s\n",

1512

                 keystring);

1513

      break;

1514

    case Accessibility_KEY_LOCKMODIFIERS:

1515

      spi_dec_plat_lock_modifiers (controller, keycode);

1516

      break;

1517

    case Accessibility_KEY_UNLOCKMODIFIERS:

1518

      spi_dec_plat_unlock_modifiers (controller, keycode);

1519

      break;

1520

1521

  reply = dbus_message_new_method_return (message);

1522

  return reply;

1523

1524

1525

/* Accessibility::DEController::GenerateMouseEvent */

1526

static DBusMessage *

1527

impl_generate_mouse_event (DBusMessage *message, SpiDEController *controller)

1528

1529

  dbus_int32_t x;

1530

  dbus_int32_t y;

1531

  char *eventName;

1532

  DBusMessage *reply = NULL;

1533

1534

  if (!dbus_message_get_args (message, NULL, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_STRING, &eventName, DBUS_TYPE_INVALID))

1535

1536

      return invalid_arguments_error (message);

1537

1538

1539

#ifdef SPI_DEBUG

1540

  fprintf (stderr, "generating mouse %s event at %ld, %ld\n",

1541

           eventName, (long int) x, (long int) y);

1542

#endif

1543

  spi_dec_plat_generate_mouse_event (controller, x, y, eventName);

1544

  reply = dbus_message_new_method_return (message);

1545

  return reply;

1546

1547

1548

/* Accessibility::DEController::NotifyListenersSync */

1549

static DBusMessage *

1550

impl_notify_listeners_sync (DBusMessage *message, SpiDEController *controller)

1551

1552

  Accessibility_DeviceEvent event;

1553

  dbus_bool_t ret;

1554

  DBusMessage *reply = NULL;

1555

1556

  if (!spi_dbus_demarshal_deviceEvent (message, &event))

1557

1558

      return invalid_arguments_error (message);

1559

1560

#ifdef SPI_DEBUG

1561

  g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",

1562

           controller, (int) event.id);

1563

#endif

1564

  ret = spi_controller_notify_keylisteners (controller,

1565

                                            (Accessibility_DeviceEvent *) &event, FALSE)

1566

            ? TRUE

1567

            : FALSE;

1568

  reply = dbus_message_new_method_return (message);

1569

  if (reply)

1570

1571

      dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);

1572

1573

  return reply;

1574

1575

1576

static DBusMessage *

1577

impl_notify_listeners_async (DBusMessage *message, SpiDEController *controller)

1578

1579

  Accessibility_DeviceEvent event;

1580

  DBusMessage *reply = NULL;

1581

1582

  if (!spi_dbus_demarshal_deviceEvent (message, &event))

1583

1584

      return invalid_arguments_error (message);

1585

1586

#ifdef SPI_DEBUG

1587

  g_print ("notifylistening listeners asynchronously: controller %p, event id %d\n",

1588

           controller, (int) event.id);

1589

#endif

1590

  spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *) &event, FALSE);

1591

  reply = dbus_message_new_method_return (message);

1592

  return reply;

1593

1594

1595

static void

1596

28

spi_device_event_controller_class_init (SpiDEControllerClass *klass)

1597

1598

28

  GObjectClass *object_class = (GObjectClass *) klass;

1599

1600

28

  spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);

1601

1602

28

  object_class->finalize = spi_device_event_controller_object_finalize;

1603

1604

#ifdef HAVE_X11

1605

28

  if (g_getenv ("DISPLAY") != NULL && g_getenv ("WAYLAND_DISPLAY") == NULL)

1606

28

    spi_dec_setup_x11 (klass);

1607

#endif

1608

28

1609

1610

static void

1611

28

spi_device_event_controller_init (SpiDEController *device_event_controller)

1612

1613

  SpiDEControllerClass *klass;

1614

28

  klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (device_event_controller);

1615

1616

28

  device_event_controller->message_queue = g_queue_new ();

1617

1618

28

  if (klass->plat.init)

1619

28

    klass->plat.init (device_event_controller);

1620

28

1621

1622

/*---------------------------------------------------------------------------*/

1623

1624

static const char *introspection_header =

1625

    "<?xml version=\"1.0\"?>\n";

1626

1627

static const char *introspection_node_element =

1628

    "<node name=\"%s\">\n";

1629

1630

static const char *introspection_footer =

1631

    "</node>";

1632

1633

static DBusMessage *

1634

impl_Introspect (DBusMessage *message, SpiDEController *controller)

1635

1636

  GString *output;

1637

  gchar *final;

1638

1639

  const gchar *pathstr = SPI_DBUS_PATH_DEC;

1640

1641

  DBusMessage *reply;

1642

1643

  output = g_string_new (introspection_header);

1644

1645

  g_string_append_printf (output, introspection_node_element, pathstr);

1646

1647

  g_string_append (output, spi_org_a11y_atspi_DeviceEventController);

1648

1649

  g_string_append (output, introspection_footer);

1650

  final = g_string_free (output, FALSE);

1651

1652

  reply = dbus_message_new_method_return (message);

1653

  dbus_message_append_args (reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);

1654

1655

  g_free (final);

1656

  return reply;

1657

1658

1659

/*---------------------------------------------------------------------------*/

1660

1661

static void

1662

161

handle_message (DBusMessage *message, SpiDEController *controller)

1663

1664

161

  const gchar *iface = dbus_message_get_interface (message);

1665

161

  const gchar *member = dbus_message_get_member (message);

1666

161

  DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1667

161

  DBusMessage *reply = NULL;

1668

1669

161

  if (!strcmp (iface, SPI_DBUS_INTERFACE_DEC))

1670

1671

161

      result = DBUS_HANDLER_RESULT_HANDLED;

1672

161

      if (!strcmp (member, "RegisterKeystrokeListener"))

1673

        reply = impl_register_keystroke_listener (message, controller);

1674

161

      else if (!strcmp (member, "DeregisterKeystrokeListener"))

1675

        reply = impl_deregister_keystroke_listener (message, controller);

1676

161

      else if (!strcmp (member, "GetKeystrokeListeners"))

1677

161

        reply = impl_get_keystroke_listeners (message, controller);

1678

      else if (!strcmp (member, "GenerateKeyboardEvent"))

1679

        reply = impl_generate_keyboard_event (message, controller);

1680

      else if (!strcmp (member, "GenerateMouseEvent"))

1681

        reply = impl_generate_mouse_event (message, controller);

1682

      else if (!strcmp (member, "NotifyListenersSync"))

1683

        reply = impl_notify_listeners_sync (message, controller);

1684

      else if (!strcmp (member, "NotifyListenersAsync"))

1685

        reply = impl_notify_listeners_async (message, controller);

1686

      else

1687

        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1688

1689

1690

161

  if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))

1691

1692

      result = DBUS_HANDLER_RESULT_HANDLED;

1693

      if (!strcmp (member, "Introspect"))

1694

        reply = impl_Introspect (message, controller);

1695

      else

1696

        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1697

1698

1699

161

  if (result == DBUS_HANDLER_RESULT_HANDLED)

1700

1701

161

      if (!reply)

1702

1703

          reply = dbus_message_new_method_return (message);

1704

1705

1706

161

      dbus_connection_send (controller->bus, reply, NULL);

1707

161

      dbus_message_unref (reply);

1708

1709

161

1710

1711

static gboolean

1712

161

message_queue_dispatch (gpointer data)

1713

1714

161

  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data);

1715

1716

161

  controller->message_queue_idle = 0;

1717

322

  while (!g_queue_is_empty (controller->message_queue))

1718

1719

161

      DBusMessage *message = g_queue_pop_head (controller->message_queue);

1720

161

      handle_message (message, controller);

1721

161

      dbus_message_unref (message);

1722

1723

161

  return FALSE;

1724

1725

1726

static DBusHandlerResult

1727

161

handle_dec_method (DBusConnection *bus, DBusMessage *message, void *user_data)

1728

1729

161

  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (user_data);

1730

161

  const gchar *iface = dbus_message_get_interface (message);

1731

161

  const gchar *member = dbus_message_get_member (message);

1732

161

  const gint type = dbus_message_get_type (message);

1733

1734

  /* Check for basic reasons not to handle */

1735

161

  if (type != DBUS_MESSAGE_TYPE_METHOD_CALL ||

1736

161

      member == NULL ||

1737

      iface == NULL)

1738

    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1739

1740

161

  dbus_message_ref (message);

1741

161

  g_queue_push_tail (controller->message_queue, message);

1742

161

  if (!controller->message_queue_idle)

1743

1744

161

      controller->message_queue_idle = g_idle_add (message_queue_dispatch, controller);

1745

161

      g_source_set_name_by_id (controller->message_queue_idle, "[at-spi2-core] message_queue_dispatch");

1746

1747

161

  return DBUS_HANDLER_RESULT_HANDLED;

1748

1749

1750

static DBusObjectPathVTable dec_vtable = {

1751

  NULL,

1752

  &handle_dec_method,

1753

  NULL, NULL, NULL, NULL

1754

};

1755

1756

SpiDEController *

1757

28

spi_registry_dec_new (DBusConnection *bus)

1758

1759

28

  SpiDEController *dec = g_object_new (SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);

1760

1761

28

  dec->bus = bus;

1762

1763

28

  dbus_connection_register_object_path (bus, SPI_DBUS_PATH_DEC, &dec_vtable, dec);

1764

1765

28

  return dec;

1766

1767

1768

void

1769

spi_device_event_controller_start_poll_mouse (SpiDEController *dec)

1770

1771

  if (!dec->have_mouse_event_listener)

1772

1773

      dec->have_mouse_event_listener = TRUE;

1774

      guint id;

1775

      id = g_timeout_add (100, spi_dec_poll_mouse_idle, dec);

1776

      g_source_set_name_by_id (id, "[at-spi2-core] spi_dec_poll_mouse_idle");

1777

1778

1779

1780

void

1781

325

spi_device_event_controller_stop_poll_mouse (SpiDEController *dec)

1782

1783

325

  dec->have_mouse_event_listener = FALSE;

1784

325