Grcov report - event.c

1

/*

2

 * AT-SPI - Assistive Technology Service Provider Interface

3

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

4

5

 * Copyright 2011, F123 Consulting & Mais Diferenças

6

 * Copyright 2008, 2009, Codethink Ltd.

7

 * Copyright 2001, 2002, 2003 Sun Microsystems Inc.,

8

 * Copyright 2001, 2002, 2003 Ximian, Inc.

9

10

 * This library is free software; you can redistribute it and/or

11

 * modify it under the terms of the GNU Lesser General Public

12

 * License as published by the Free Software Foundation; either

13

 * version 2.1 of the License, or (at your option) any later version.

14

15

 * This library is distributed in the hope that it will be useful,

16

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

17

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

18

 * Lesser General Public License for more details.

19

20

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

21

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

22

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

23

 * Boston, MA 02110-1301, USA.

24

*/

25

26

#include <ctype.h>

27

#include <string.h>

28

29

#define ATK_DISABLE_DEPRECATION_WARNINGS

30

#include <atk/atk.h>

31

#include <atspi/atspi.h>

32

#include <droute/droute.h>

33

34

#include "accessible-register.h"

35

#include "bridge.h"

36

37

#include "event.h"

38

#include "object.h"

39

#include "spi-dbus.h"

40

41

static GArray *listener_ids = NULL;

42

43

static gint atk_bridge_key_event_listener_id;

44

static gint atk_bridge_focus_tracker_id;

45

46

GMainContext *spi_context = NULL;

47

48

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

49

50

#define ITF_EVENT_OBJECT "org.a11y.atspi.Event.Object"

51

#define ITF_EVENT_WINDOW "org.a11y.atspi.Event.Window"

52

#define ITF_EVENT_DOCUMENT "org.a11y.atspi.Event.Document"

53

#define ITF_EVENT_FOCUS "org.a11y.atspi.Event.Focus"

54

55

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

56

57

typedef struct _SpiReentrantCallClosure

58

59

  DBusConnection *bus;

60

  GMainLoop *loop;

61

  DBusMessage *reply;

62

  guint timeout;

63

} SpiReentrantCallClosure;

64

65

static void

66

switch_main_context (GMainContext *cnx)

67

68

  GList *list;

69

70

  if (spi_global_app_data->server)

71

    atspi_dbus_server_setup_with_g_main (spi_global_app_data->server, cnx);

72

  atspi_dbus_connection_setup_with_g_main (spi_global_app_data->bus, cnx);

73

  atspi_set_main_context (cnx);

74

  for (list = spi_global_app_data->direct_connections; list; list = list->next)

75

    atspi_dbus_connection_setup_with_g_main (list->data, cnx);

76

77

  if (_atk_bridge_remove_pending_application_registration (spi_global_app_data))

78

    _atk_bridge_schedule_application_registration (spi_global_app_data);

79

80

81

guint

82

spi_idle_add (GSourceFunc function, gpointer data)

83

84

  GSource *source;

85

  guint id;

86

87

  source = g_idle_source_new ();

88

  g_source_set_callback (source, function, data, NULL);

89

  id = g_source_attach (source, spi_context);

90

  g_source_unref (source);

91

92

  return id;

93

94

95

guint

96

161

spi_timeout_add_seconds (gint interval, GSourceFunc function, gpointer data)

97

98

  GSource *source;

99

  guint id;

100

101

161

  source = g_timeout_source_new_seconds (interval);

102

161

  g_source_set_callback (source, function, data, NULL);

103

161

  id = g_source_attach (source, spi_context);

104

161

  g_source_unref (source);

105

106

161

  return id;

107

108

109

guint

110

161

spi_timeout_add_full (gint priority, guint interval, GSourceFunc function, gpointer data, GDestroyNotify notify)

111

112

  GSource *source;

113

  guint id;

114

115

161

  source = g_timeout_source_new (interval);

116

161

  g_source_set_priority (source, priority);

117

161

  g_source_set_callback (source, function, data, notify);

118

161

  id = g_source_attach (source, spi_context);

119

161

  g_source_unref (source);

120

121

161

  return id;

122

123

124

static void

125

set_reply (DBusPendingCall *pending, void *user_data)

126

127

  SpiReentrantCallClosure *closure = (SpiReentrantCallClosure *) user_data;

128

129

  closure->reply = dbus_pending_call_steal_reply (pending);

130

  dbus_pending_call_unref (pending);

131

  switch_main_context (spi_context);

132

  g_main_loop_quit (closure->loop);

133

134

135

static gboolean

136

timeout_reply (void *data)

137

138

  SpiReentrantCallClosure *closure = data;

139

140

  switch_main_context (spi_context);

141

  g_main_loop_quit (closure->loop);

142

  closure->timeout = -1;

143

  return FALSE;

144

145

146

static DBusMessage *

147

send_and_allow_reentry (DBusConnection *bus, DBusMessage *message)

148

149

  DBusPendingCall *pending;

150

  SpiReentrantCallClosure closure;

151

  GSource *source;

152

153

  closure.bus = bus;

154

  closure.loop = g_main_loop_new (spi_global_app_data->main_context, FALSE);

155

  closure.reply = NULL;

156

  switch_main_context (spi_global_app_data->main_context);

157

158

  if (!dbus_connection_send_with_reply (bus, message, &pending, 9000) || !pending)

159

160

      switch_main_context (spi_context);

161

      return NULL;

162

163

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

164

  source = g_timeout_source_new (500);

165

  g_source_set_callback (source, timeout_reply, &closure, NULL);

166

  closure.timeout = g_source_attach (source, spi_global_app_data->main_context);

167

  g_source_unref (source);

168

  g_main_loop_run (closure.loop);

169

  if (closure.timeout != -1)

170

    g_source_destroy (source);

171

172

  g_main_loop_unref (closure.loop);

173

  if (!closure.reply)

174

    dbus_pending_call_cancel (pending);

175

  return closure.reply;

176

177

178

void

179

atk_bridge_set_event_context (GMainContext *cnx)

180

181

  spi_context = cnx;

182

  switch_main_context (spi_context);

183

184

185

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

186

187

/*

188

 * Functionality related to sending device events from the application.

189

190

 * This is used for forwarding key events on to the registry daemon.

191

*/

192

193

static gboolean

194

Accessibility_DeviceEventController_NotifyListenersSync (const AtspiDeviceEvent

195

                                                             *key_event)

196

197

  DBusMessage *message;

198

  dbus_bool_t consumed = FALSE;

199

200

  message =

201

      dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,

202

                                    ATSPI_DBUS_PATH_DEC,

203

                                    ATSPI_DBUS_INTERFACE_DEC,

204

                                    "NotifyListenersSync");

205

206

  if (spi_dbus_marshal_deviceEvent (message, key_event))

207

208

      DBusMessage *reply =

209

          send_and_allow_reentry (spi_global_app_data->bus, message);

210

      if (reply)

211

212

          DBusError error;

213

          dbus_error_init (&error);

214

          if (!dbus_message_get_args (reply, &error, DBUS_TYPE_BOOLEAN,

215

                                      &consumed, DBUS_TYPE_INVALID))

216

217

              /* TODO: print a warning */

218

              dbus_error_free (&error);

219

220

          dbus_message_unref (reply);

221

222

223

  dbus_message_unref (message);

224

  return consumed;

225

226

227

static void

228

spi_init_keystroke_from_atk_key_event (AtspiDeviceEvent *keystroke,

229

                                       AtkKeyEventStruct *event)

230

231

  keystroke->id = (dbus_int32_t) event->keyval;

232

  keystroke->hw_code = (dbus_int16_t) event->keycode;

233

  keystroke->timestamp = (dbus_uint32_t) event->timestamp;

234

  keystroke->modifiers = (dbus_uint16_t) (event->state & 0xFFFF);

235

  if (event->string)

236

237

      gunichar c;

238

239

      keystroke->event_string = g_strdup (event->string);

240

      c = g_utf8_get_char_validated (event->string, -1);

241

      if (c > 0 && g_unichar_isprint (c))

242

        keystroke->is_text = TRUE;

243

      else

244

        keystroke->is_text = FALSE;

245

246

  else

247

248

      keystroke->event_string = g_strdup ("");

249

      keystroke->is_text = FALSE;

250

251

  switch (event->type)

252

253

    case (ATK_KEY_EVENT_PRESS):

254

      keystroke->type = ATSPI_KEY_PRESSED_EVENT;

255

      break;

256

    case (ATK_KEY_EVENT_RELEASE):

257

      keystroke->type = ATSPI_KEY_RELEASED_EVENT;

258

      break;

259

    default:

260

      g_error ("atk passed us an AtkKeyEventStruct invalid type %d", event->type);

261

      return;

262

263

#if 0

264

  g_print

265

    ("key_event type %d; val=%d code=%d modifiers=%x name=%s is_text=%d, time=%lx\n",

266

     (int) keystroke->type, (int) keystroke->id, (int) keystroke->hw_code,

267

     (int) keystroke->modifiers, keystroke->event_string,

268

     (int) keystroke->is_text, (unsigned long) keystroke->timestamp);

269

#endif

270

271

272

static gint

273

spi_atk_bridge_key_listener (AtkKeyEventStruct *event, gpointer data)

274

275

  gboolean result;

276

  AtspiDeviceEvent key_event;

277

278

  spi_init_keystroke_from_atk_key_event (&key_event, event);

279

280

  result =

281

      Accessibility_DeviceEventController_NotifyListenersSync (&key_event);

282

283

  if (key_event.event_string)

284

    g_free (key_event.event_string);

285

286

  return result;

287

288

289

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

290

291

static const void *

292

331

validate_for_dbus (const gint type,

293

                   const void *val)

294

295

331

  switch (type)

296

297

331

    case DBUS_TYPE_STRING:

298

    case DBUS_TYPE_OBJECT_PATH:

299

331

      if (!val)

300

        return "";

301

331

      else if (!g_utf8_validate (val, -1, NULL))

302

303

          g_warning ("atk-bridge: Received bad UTF-8 string when emitting event");

304

          return "";

305

306

      else

307

331

        return val;

308

    default:

309

      return val;

310

311

312

313

static void

314

331

append_basic (DBusMessageIter *iter,

315

              const char *type,

316

              const void *val)

317

318

  DBusMessageIter sub;

319

320

331

  dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, type, &sub);

321

322

331

  val = validate_for_dbus ((int) *type, val);

323

331

  dbus_message_iter_append_basic (&sub, (int) *type, &val);

324

325

331

  dbus_message_iter_close_container (iter, &sub);

326

331

327

328

static void

329

append_rect (DBusMessageIter *iter,

330

             const char *type,

331

             const void *val)

332

333

  DBusMessageIter variant, sub;

334

  const AtkRectangle *rect = (const AtkRectangle *) val;

335

336

  dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, type, &variant);

337

338

  dbus_message_iter_open_container (&variant, DBUS_TYPE_STRUCT, NULL, &sub);

339

340

  dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->x));

341

  dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->y));

342

  dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->width));

343

  dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->height));

344

345

  dbus_message_iter_close_container (&variant, &sub);

346

347

  dbus_message_iter_close_container (iter, &variant);

348

349

350

static void

351

append_object (DBusMessageIter *iter,

352

               const char *type,

353

               const void *val)

354

355

  spi_object_append_v_reference (iter, ATK_OBJECT (val));

356

357

358

static gchar *

359

331

signal_name_to_dbus (const gchar *s)

360

361

331

  gchar *ret = g_strdup (s);

362

  gchar *t;

363

364

331

  if (!ret)

365

    return NULL;

366

331

  ret[0] = toupper (ret[0]);

367

331

  while ((t = strchr (ret, '-')) != NULL)

368

369

      memmove (t, t + 1, strlen (t));

370

      *t = toupper (*t);

371

372

331

  return ret;

373

374

375

/*

376

 * Converts names of the form "active-descendant-changed" to

377

 * "ActiveDescendantChanged"

378

*/

379

static gchar *

380

ensure_proper_format (const char *name)

381

382

  gchar *ret = (gchar *) g_malloc (strlen (name) * 2 + 2);

383

  gchar *p = ret;

384

  gboolean need_upper = TRUE;

385

386

  if (!ret)

387

    return NULL;

388

  while (*name)

389

390

      if (need_upper)

391

392

          *p++ = toupper (*name);

393

          need_upper = FALSE;

394

395

      else if (*name == '-')

396

        need_upper = TRUE;

397

      else if (*name == ':')

398

399

          need_upper = TRUE;

400

          *p++ = *name;

401

402

      else

403

        *p++ = *name;

404

      name++;

405

406

  *p = '\0';

407

  return ret;

408

409

410

void

411

append_properties (GArray *properties, event_data *evdata)

412

413

  GSList *ls;

414

  gint i;

415

416

  for (ls = evdata->properties; ls; ls = ls->next)

417

418

      gboolean dup = FALSE;

419

      for (i = 0; i < properties->len; i++)

420

421

          if (ls->data == g_array_index (properties, AtspiPropertyDefinition *, i))

422

423

              dup = TRUE;

424

              break;

425

426

427

      if (!dup)

428

        g_array_append_val (properties, ls->data);

429

430

431

432

static gboolean

433

331

signal_is_needed (AtkObject *obj, const gchar *klass, const gchar *major, const gchar *minor, GArray **properties)

434

435

  gchar *data[4];

436

  event_data *evdata;

437

331

  gboolean ret = FALSE;

438

  GList *list;

439

331

  GArray *props = NULL;

440

441

331

  if (!spi_global_app_data->events_initialized)

442

331

    return TRUE;

443

444

  data[0] = ensure_proper_format (klass[0] ? klass + 21 : klass);

445

  data[1] = ensure_proper_format (major);

446

  data[2] = ensure_proper_format (minor);

447

  data[3] = NULL;

448

449

  /* Hack: Always pass events that update the cache.

450

   * TODO: FOr 2.2, have at-spi2-core define a special "cache listener" for

451

   * this instead, so that we don't send these if no one is listening */

452

  if (!g_strcmp0 (data[1], "ChildrenChanged") ||

453

      ((!g_strcmp0 (data[1], "PropertyChange")) &&

454

       (!g_strcmp0 (data[2], "AccessibleName") ||

455

        !g_strcmp0 (data[2], "AccessibleDescription") ||

456

        !g_strcmp0 (data[2], "AccessibleParent") ||

457

        !g_strcmp0 (data[2], "AccessibleRole"))) ||

458

      !g_strcmp0 (data[1], "StateChanged"))

459

460

      if (minor && !g_strcmp0 (minor, "defunct"))

461

        ret = TRUE;

462

      else

463

464

          AtkStateSet *set = atk_object_ref_state_set (obj);

465

          AtkState state = ((!g_strcmp0 (data[1], "ChildrenChanged")) ? ATK_STATE_MANAGES_DESCENDANTS : ATK_STATE_TRANSIENT);

466

          ret = !atk_state_set_contains_state (set, state);

467

          g_object_unref (set);

468

469

470

471

  /* Hack: events such as "object::text-changed::insert:system" as

472

     generated by Gecko */

473

  data[2][strcspn (data[2], ":")] = '\0';

474

475

  for (list = spi_global_app_data->events; list; list = list->next)

476

477

      evdata = list->data;

478

      if (spi_event_is_subtype (data, evdata->data))

479

480

          ret = TRUE;

481

          if (!props)

482

            props = g_array_new (TRUE, TRUE, sizeof (AtspiPropertyDefinition *));

483

          append_properties (props, evdata);

484

485

486

487

  g_free (data[2]);

488

  g_free (data[1]);

489

  g_free (data[0]);

490

  *properties = props;

491

  return ret;

492

493

494

/* Convert a : to a / so that listeners can use arg0path to match only

495

 *  * the prefix */

496

static char *

497

331

adapt_minor_for_dbus (const char *source)

498

499

331

  gchar *ret = g_strdup (source);

500

331

  int i = strcspn (ret, ":");

501

331

  if (ret[i] == ':')

502

    ret[i] = '/';

503

331

  return ret;

504

505

506

/*

507

 * Emits an AT-SPI event.

508

 * AT-SPI events names are split into three parts:

509

 * class:major:minor

510

 * This is mapped onto D-Bus events as:

511

 * D-Bus Interface:Signal Name:Detail argument

512

513

 * Marshals a basic type into the 'any_data' attribute of

514

 * the AT-SPI event.

515

*/

516

static void

517

331

emit_event (AtkObject *obj,

518

            const char *klass,

519

            const char *major,

520

            const char *minor,

521

            dbus_int32_t detail1,

522

            dbus_int32_t detail2,

523

            const char *type,

524

            const void *val,

525

            void (*append_variant) (DBusMessageIter *, const char *, const void *))

526

527

331

  DBusConnection *bus = spi_global_app_data->bus;

528

  char *path;

529

  char *minor_dbus;

530

531

  gchar *cname;

532

  DBusMessage *sig;

533

  DBusMessageIter iter, iter_dict, iter_dict_entry;

534

331

  GArray *properties = NULL;

535

536

331

  if (!klass)

537

    klass = "";

538

331

  if (!major)

539

    major = "";

540

331

  if (!minor)

541

331

    minor = "";

542

331

  if (!type)

543

    type = "u";

544

545

331

  if (!signal_is_needed (obj, klass, major, minor, &properties))

546

    return;

547

548

331

  path = spi_register_object_to_path (spi_global_register, G_OBJECT (obj));

549

331

  g_return_if_fail (path != NULL);

550

551

/*

552

   * This is very annoying, but as '-' isn't a legal signal

553

   * name in D-Bus (Why not??!?) The names need converting

554

   * on this side, and again on the client side.

555

*/

556

331

  cname = signal_name_to_dbus (major);

557

331

  sig = dbus_message_new_signal (path, klass, cname);

558

559

331

  dbus_message_iter_init_append (sig, &iter);

560

561

331

  minor_dbus = adapt_minor_for_dbus (minor);

562

331

  dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &minor_dbus);

563

331

  g_free (minor_dbus);

564

331

  dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &detail1);

565

331

  dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &detail2);

566

331

  append_variant (&iter, type, val);

567

568

331

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

569

  /* Add requested properties, unless the object is being marked defunct, in

570

     which case it's safest not to touch it */

571

331

  if (minor == NULL || strcmp (minor, "defunct") != 0 || detail1 == 0)

572

573

331

      if (properties)

574

575

          gint i;

576

          for (i = 0; i < properties->len; i++)

577

578

              AtspiPropertyDefinition *prop = g_array_index (properties, AtspiPropertyDefinition *, i);

579

              dbus_message_iter_open_container (&iter_dict, DBUS_TYPE_DICT_ENTRY, NULL,

580

                                                &iter_dict_entry);

581

              dbus_message_iter_append_basic (&iter_dict_entry, DBUS_TYPE_STRING, &prop->name);

582

              prop->func (&iter_dict_entry, obj);

583

              dbus_message_iter_close_container (&iter_dict, &iter_dict_entry);

584

585

          g_array_free (properties, TRUE);

586

587

588

331

  dbus_message_iter_close_container (&iter, &iter_dict);

589

590

331

  dbus_connection_send (bus, sig, NULL);

591

331

  dbus_message_unref (sig);

592

593

331

  if (g_strcmp0 (cname, "ChildrenChanged") != 0)

594

331

    spi_object_lease_if_needed (G_OBJECT (obj));

595

596

331

  g_free (cname);

597

331

  g_free (path);

598

599

600

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

601

602

/*

603

 * The focus listener handles the ATK 'focus' signal and forwards it

604

 * as the AT-SPI event, 'focus:'

605

*/

606

static void

607

focus_tracker (AtkObject *accessible)

608

609

  emit_event (accessible, ITF_EVENT_FOCUS, "focus", "", 0, 0,

610

              DBUS_TYPE_INT32_AS_STRING, 0, append_basic);

611

612

613

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

614

615

#define PCHANGE "PropertyChange"

616

617

/*

618

 * This handler handles the following ATK signals and

619

 * converts them to AT-SPI events:

620

621

 * Gtk:AtkObject:property-change -> object:property-change:(property-name)

622

623

 * The property-name is part of the ATK property-change signal.

624

*/

625

static gboolean

626

property_event_listener (GSignalInvocationHint *signal_hint,

627

                         guint n_param_values,

628

                         const GValue *param_values,

629

                         gpointer data)

630

631

  AtkObject *accessible;

632

  AtkPropertyValues *values;

633

634

  const gchar *pname = NULL;

635

636

  AtkObject *otemp;

637

  const gchar *s1;

638

  gint i;

639

640

  accessible = g_value_get_object (&param_values[0]);

641

  values = (AtkPropertyValues *) g_value_get_pointer (&param_values[1]);

642

643

  pname = values[0].property_name;

644

645

  /* TODO Could improve this control statement by matching

646

   * on only the end of the signal names,

647

*/

648

  if (strcmp (pname, "accessible-name") == 0)

649

650

      s1 = atk_object_get_name (accessible);

651

      if (s1 != NULL)

652

        emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

653

                    DBUS_TYPE_STRING_AS_STRING, s1, append_basic);

654

655

  else if (strcmp (pname, "accessible-description") == 0)

656

657

      s1 = atk_object_get_description (accessible);

658

      if (s1 != NULL)

659

        emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

660

                    DBUS_TYPE_STRING_AS_STRING, s1, append_basic);

661

662

  else if (strcmp (pname, "accessible-help-text") == 0)

663

664

      s1 = atk_object_get_help_text (accessible);

665

      if (s1 != NULL)

666

        emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

667

                    DBUS_TYPE_STRING_AS_STRING, s1, append_basic);

668

669

  else if (strcmp (pname, "accessible-parent") == 0)

670

671

      otemp = atk_object_get_parent (accessible);

672

      if (otemp != NULL)

673

        emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

674

                    "(so)", otemp, append_object);

675

676

  else if (strcmp (pname, "accessible-role") == 0)

677

678

      i = atk_object_get_role (accessible);

679

      emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

680

                  DBUS_TYPE_UINT32_AS_STRING, GINT_TO_POINTER (i), append_basic);

681

682

  else if (strcmp (pname, "accessible-table-summary") == 0)

683

684

      otemp = atk_table_get_summary (ATK_TABLE (accessible));

685

      if (otemp != NULL)

686

        emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

687

                    "(so)", otemp, append_object);

688

689

  else if (strcmp (pname, "accessible-table-column-header") == 0)

690

691

      i = g_value_get_int (&(values->new_value));

692

      otemp = atk_table_get_column_header (ATK_TABLE (accessible), i);

693

      if (otemp != NULL)

694

        emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

695

                    "(so)", otemp, append_object);

696

697

  else if (strcmp (pname, "accessible-table-row-header") == 0)

698

699

      i = g_value_get_int (&(values->new_value));

700

      otemp = atk_table_get_row_header (ATK_TABLE (accessible), i);

701

      if (otemp != NULL)

702

        emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

703

                    "(so)", otemp, append_object);

704

705

  else if (strcmp (pname, "accessible-table-row-description") == 0)

706

707

      i = g_value_get_int (&(values->new_value));

708

      s1 = atk_table_get_row_description (ATK_TABLE (accessible), i);

709

      emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

710

                  DBUS_TYPE_STRING_AS_STRING, s1, append_basic);

711

712

  else if (strcmp (pname, "accessible-table-column-description") == 0)

713

714

      i = g_value_get_int (&(values->new_value));

715

      s1 = atk_table_get_column_description (ATK_TABLE (accessible), i);

716

      emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

717

                  DBUS_TYPE_STRING_AS_STRING, s1, append_basic);

718

719

  else if (strcmp (pname, "accessible-table-caption-object") == 0)

720

721

      otemp = atk_table_get_caption (ATK_TABLE (accessible));

722

      emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

723

                  "(so)", otemp, append_object);

724

725

  else

726

727

      emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,

728

                  DBUS_TYPE_INT32_AS_STRING, 0, append_basic);

729

730

  return TRUE;

731

732

733

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

734

735

#define STATE_CHANGED "state-changed"

736

737

/*

738

 * The state event listener handles 'Gtk:AtkObject:state-change' ATK signals

739

 * and forwards them as object:state-changed:(param-name) AT-SPI events. Where

740

 * the param-name is part of the ATK state-change signal.

741

*/

742

static gboolean

743

state_event_listener (GSignalInvocationHint *signal_hint,

744

                      guint n_param_values,

745

                      const GValue *param_values,

746

                      gpointer data)

747

748

  AtkObject *accessible;

749

  const gchar *pname;

750

  guint detail1;

751

752

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

753

  pname = g_value_get_string (&param_values[1]);

754

755

  detail1 = (g_value_get_boolean (&param_values[2])) ? 1 : 0;

756

  emit_event (accessible, ITF_EVENT_OBJECT, STATE_CHANGED, pname, detail1, 0,

757

              DBUS_TYPE_INT32_AS_STRING, 0, append_basic);

758

759

  if (!g_strcmp0 (pname, "defunct") && detail1)

760

    spi_register_deregister_object (spi_global_register, G_OBJECT (accessible),

761

                                    TRUE);

762

  return TRUE;

763

764

765

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

766

767

/*

768

 * The window event listener handles the following ATK signals and forwards

769

 * them as AT-SPI events:

770

771

 * window:create     -> window:create

772

 * window:destroy    -> window:destroy

773

 * window:minimize   -> window:minimize

774

 * window:maximize   -> window:maximize

775

 * window:activate   -> window:activate

776

 * window:deactivate -> window:deactivate

777

*/

778

static gboolean

779

window_event_listener (GSignalInvocationHint *signal_hint,

780

                       guint n_param_values,

781

                       const GValue *param_values,

782

                       gpointer data)

783

784

  AtkObject *accessible;

785

  GSignalQuery signal_query;

786

  const gchar *name, *s;

787

788

  g_signal_query (signal_hint->signal_id, &signal_query);

789

  name = signal_query.signal_name;

790

791

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

792

  s = atk_object_get_name (accessible);

793

  emit_event (accessible, ITF_EVENT_WINDOW, name, "", 0, 0,

794

              DBUS_TYPE_STRING_AS_STRING, s, append_basic);

795

796

  return TRUE;

797

798

799

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

800

801

/*

802

 * The document event listener handles the following ATK signals

803

 * and converts them to AT-SPI events:

804

805

 * Gtk:AtkDocument:load-complete ->  document:load-complete

806

 * Gtk:AtkDocument:load-stopped  ->  document:load-stopped

807

 * Gtk:AtkDocument:reload        ->  document:reload

808

 * Gtk:AtkDocument:page-changed  ->  document:page-changed

809

*/

810

static gboolean

811

document_event_listener (GSignalInvocationHint *signal_hint,

812

                         guint n_param_values,

813

                         const GValue *param_values,

814

                         gpointer data)

815

816

  AtkObject *accessible;

817

  GSignalQuery signal_query;

818

  const gchar *name, *s;

819

  gint detail1 = 0;

820

821

  g_signal_query (signal_hint->signal_id, &signal_query);

822

  name = signal_query.signal_name;

823

824

  if (n_param_values > 0) // on the case of page-changed

825

    if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)

826

      detail1 = g_value_get_int (&param_values[1]);

827

828

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

829

  s = atk_object_get_name (accessible);

830

  emit_event (accessible, ITF_EVENT_DOCUMENT, name, "", detail1, 0,

831

              DBUS_TYPE_STRING_AS_STRING, s, append_basic);

832

833

  return TRUE;

834

835

836

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

837

838

/*

839

 * Signal handler for  "Gtk:AtkComponent:bounds-changed". Converts

840

 * this to an AT-SPI event - "object:bounds-changed".

841

*/

842

static gboolean

843

bounds_event_listener (GSignalInvocationHint *signal_hint,

844

                       guint n_param_values,

845

                       const GValue *param_values,

846

                       gpointer data)

847

848

  AtkObject *accessible;

849

  AtkRectangle *atk_rect;

850

  GSignalQuery signal_query;

851

  const gchar *name;

852

853

  g_signal_query (signal_hint->signal_id, &signal_query);

854

  name = signal_query.signal_name;

855

856

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

857

858

  if (G_VALUE_HOLDS_BOXED (param_values + 1))

859

860

      atk_rect = g_value_get_boxed (param_values + 1);

861

862

      emit_event (accessible, ITF_EVENT_OBJECT, name, "", 0, 0,

863

                  "(iiii)", atk_rect, append_rect);

864

865

  return TRUE;

866

867

868

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

869

870

/*

871

 * Handles the ATK signal 'Gtk:AtkObject:active-descendant-changed' and

872

 * converts it to the AT-SPI signal - 'object:active-descendant-changed'.

873

874

*/

875

static gboolean

876

active_descendant_event_listener (GSignalInvocationHint *signal_hint,

877

                                  guint n_param_values,

878

                                  const GValue *param_values,

879

                                  gpointer data)

880

881

  AtkObject *accessible;

882

  AtkObject *child;

883

  GSignalQuery signal_query;

884

  const gchar *name;

885

  gint detail1;

886

887

  g_signal_query (signal_hint->signal_id, &signal_query);

888

  name = signal_query.signal_name;

889

890

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

891

  child = ATK_OBJECT (g_value_get_pointer (&param_values[1]));

892

  g_return_val_if_fail (ATK_IS_OBJECT (child), TRUE);

893

894

  detail1 = atk_object_get_index_in_parent (child);

895

896

  emit_event (accessible, ITF_EVENT_OBJECT, name, "", detail1, 0,

897

              "(so)", child, append_object);

898

  return TRUE;

899

900

901

static gboolean

902

announcement_event_listener (GSignalInvocationHint *signal_hint,

903

                             guint n_param_values,

904

                             const GValue *param_values,

905

                             gpointer data)

906

907

  AtkObject *accessible;

908

  const gchar *text;

909

  GSignalQuery signal_query;

910

  const gchar *name;

911

912

  g_signal_query (signal_hint->signal_id, &signal_query);

913

  name = signal_query.signal_name;

914

915

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

916

  text = g_value_get_string (&param_values[1]);

917

  g_return_val_if_fail (text != NULL, TRUE);

918

919

  emit_event (accessible, ITF_EVENT_OBJECT, name, "", ATSPI_LIVE_POLITE, 0,

920

              "s", text, append_basic);

921

  return TRUE;

922

923

924

static gboolean

925

notification_event_listener (GSignalInvocationHint *signal_hint,

926

                             guint n_param_values,

927

                             const GValue *param_values,

928

                             gpointer data)

929

930

  AtkObject *accessible;

931

  const gchar *text;

932

  gint politeness;

933

934

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

935

  text = g_value_get_string (&param_values[1]);

936

  g_return_val_if_fail (text != NULL, TRUE);

937

  politeness = g_value_get_int (&param_values[2]);

938

939

  emit_event (accessible, ITF_EVENT_OBJECT, "announcement", "", politeness, 0,

940

              "s", text, append_basic);

941

  return TRUE;

942

943

944

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

945

946

/*

947

 * Handles the ATK signal 'Gtk:AtkHypertext:link-selected' and

948

 * converts it to the AT-SPI signal - 'object:link-selected'

949

950

*/

951

static gboolean

952

link_selected_event_listener (GSignalInvocationHint *signal_hint,

953

                              guint n_param_values,

954

                              const GValue *param_values,

955

                              gpointer data)

956

957

  AtkObject *accessible;

958

  GSignalQuery signal_query;

959

  const gchar *name, *minor;

960

  gint detail1 = 0;

961

962

  g_signal_query (signal_hint->signal_id, &signal_query);

963

  name = signal_query.signal_name;

964

965

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

966

  minor = g_quark_to_string (signal_hint->detail);

967

968

  if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)

969

    detail1 = g_value_get_int (&param_values[1]);

970

971

  emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, 0,

972

              DBUS_TYPE_INT32_AS_STRING, 0, append_basic);

973

  return TRUE;

974

975

976

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

977

978

/*

979

 * Handles the ATK signal 'Gtk:AtkText:text-changed' and

980

 * converts it to the AT-SPI signal - 'object:text-changed'

981

 * This signal is deprecated by Gtk:AtkText:text-insert

982

 * and Gtk:AtkText:text-remove

983

984

*/

985

static gboolean

986

text_changed_event_listener (GSignalInvocationHint *signal_hint,

987

                             guint n_param_values,

988

                             const GValue *param_values,

989

                             gpointer data)

990

991

  AtkObject *accessible;

992

  GSignalQuery signal_query;

993

  const gchar *name, *minor;

994

  gchar *selected;

995

  gint detail1 = 0, detail2 = 0;

996

997

  g_signal_query (signal_hint->signal_id, &signal_query);

998

  name = signal_query.signal_name;

999

1000

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

1001

  minor = g_quark_to_string (signal_hint->detail);

1002

1003

  if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)

1004

    detail1 = g_value_get_int (&param_values[1]);

1005

1006

  if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)

1007

    detail2 = g_value_get_int (&param_values[2]);

1008

1009

  selected =

1010

      atk_text_get_text (ATK_TEXT (accessible), detail1, detail1 + detail2);

1011

1012

  emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,

1013

              DBUS_TYPE_STRING_AS_STRING, selected, append_basic);

1014

  g_free (selected);

1015

1016

  return TRUE;

1017

1018

1019

/*

1020

 * Handles the ATK signal 'Gtk:AtkText:text-insert' and

1021

 * converts it to the AT-SPI signal - 'object:text-changed'

1022

1023

*/

1024

static gboolean

1025

text_insert_event_listener (GSignalInvocationHint *signal_hint,

1026

                            guint n_param_values,

1027

                            const GValue *param_values,

1028

                            gpointer data)

1029

1030

  AtkObject *accessible;

1031

  guint text_changed_signal_id;

1032

  GSignalQuery signal_query;

1033

  const gchar *name;

1034

  const gchar *minor_raw, *text;

1035

  gchar *minor;

1036

  gint detail1 = 0, detail2 = 0;

1037

1038

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

1039

  /* Get signal name for 'Gtk:AtkText:text-changed' so

1040

   * we convert it to the AT-SPI signal - 'object:text-changed'

1041

*/

1042

  text_changed_signal_id = g_signal_lookup ("text-changed", G_OBJECT_TYPE (accessible));

1043

  g_signal_query (text_changed_signal_id, &signal_query);

1044

  name = signal_query.signal_name;

1045

1046

  /* Add the insert and keep any detail coming from atk */

1047

  minor_raw = g_quark_to_string (signal_hint->detail);

1048

  if (minor_raw)

1049

    minor = g_strconcat ("insert:", minor_raw, NULL);

1050

  else

1051

    minor = g_strdup ("insert");

1052

1053

  if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)

1054

    detail1 = g_value_get_int (&param_values[1]);

1055

1056

  if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)

1057

    detail2 = g_value_get_int (&param_values[2]);

1058

1059

  if (G_VALUE_TYPE (&param_values[3]) == G_TYPE_STRING)

1060

    text = g_value_get_string (&param_values[3]);

1061

  else

1062

    text = "";

1063

1064

  emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,

1065

              DBUS_TYPE_STRING_AS_STRING, text, append_basic);

1066

  g_free (minor);

1067

  return TRUE;

1068

1069

1070

/*

1071

 * Handles the ATK signal 'Gtk:AtkText:text-remove' and

1072

 * converts it to the AT-SPI signal - 'object:text-changed'

1073

1074

*/

1075

static gboolean

1076

text_remove_event_listener (GSignalInvocationHint *signal_hint,

1077

                            guint n_param_values,

1078

                            const GValue *param_values,

1079

                            gpointer data)

1080

1081

  AtkObject *accessible;

1082

  guint text_changed_signal_id;

1083

  GSignalQuery signal_query;

1084

  const gchar *name;

1085

  const gchar *minor_raw, *text;

1086

  gchar *minor;

1087

  gint detail1 = 0, detail2 = 0;

1088

1089

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

1090

  /* Get signal name for 'Gtk:AtkText:text-changed' so

1091

   * we convert it to the AT-SPI signal - 'object:text-changed'

1092

*/

1093

  text_changed_signal_id = g_signal_lookup ("text-changed", G_OBJECT_TYPE (accessible));

1094

  g_signal_query (text_changed_signal_id, &signal_query);

1095

  name = signal_query.signal_name;

1096

1097

  minor_raw = g_quark_to_string (signal_hint->detail);

1098

1099

  /* Add the delete and keep any detail coming from atk */

1100

  if (minor_raw)

1101

    minor = g_strconcat ("delete:", minor_raw, NULL);

1102

  else

1103

    minor = g_strdup ("delete");

1104

1105

  if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)

1106

    detail1 = g_value_get_int (&param_values[1]);

1107

1108

  if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)

1109

    detail2 = g_value_get_int (&param_values[2]);

1110

1111

  if (G_VALUE_TYPE (&param_values[3]) == G_TYPE_STRING)

1112

    text = g_value_get_string (&param_values[3]);

1113

  else

1114

    text = "";

1115

1116

  emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,

1117

              DBUS_TYPE_STRING_AS_STRING, text, append_basic);

1118

  g_free (minor);

1119

  return TRUE;

1120

1121

1122

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

1123

1124

/*

1125

 * Handles the ATK signal 'Gtk:AtkText:text-selection-changed' and

1126

 * converts it to the AT-SPI signal - 'object:text-selection-changed'

1127

1128

*/

1129

static gboolean

1130

text_selection_changed_event_listener (GSignalInvocationHint *signal_hint,

1131

                                       guint n_param_values,

1132

                                       const GValue *param_values,

1133

                                       gpointer data)

1134

1135

  AtkObject *accessible;

1136

  GSignalQuery signal_query;

1137

  const gchar *name, *minor;

1138

1139

  g_signal_query (signal_hint->signal_id, &signal_query);

1140

  name = signal_query.signal_name;

1141

1142

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

1143

  minor = g_quark_to_string (signal_hint->detail);

1144

1145

  emit_event (accessible, ITF_EVENT_OBJECT, name, minor, 0, 0,

1146

              DBUS_TYPE_STRING_AS_STRING, "", append_basic);

1147

  return TRUE;

1148

1149

1150

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

1151

1152

/*

1153

 * Children changed signal converter and forwarder.

1154

1155

 * Klass (Interface) org.a11y.atspi.Event.Object

1156

 * Major is the signal name.

1157

 * Minor is 'add' or 'remove'

1158

 * detail1 is the index.

1159

 * detail2 is 0.

1160

 * any_data is the child reference.

1161

*/

1162

static gboolean

1163

children_changed_event_listener (GSignalInvocationHint *signal_hint,

1164

                                 guint n_param_values,

1165

                                 const GValue *param_values,

1166

                                 gpointer data)

1167

1168

  GSignalQuery signal_query;

1169

  const gchar *name, *minor;

1170

  gint detail1 = 0, detail2 = 0;

1171

1172

  AtkObject *accessible, *ao = NULL;

1173

  gpointer child;

1174

  AtkStateSet *set;

1175

  gboolean ret;

1176

1177

  g_signal_query (signal_hint->signal_id, &signal_query);

1178

  name = signal_query.signal_name;

1179

1180

  /* If the accessible is on STATE_MANAGES_DESCENDANTS state,

1181

     children-changed signal are not forwarded. */

1182

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

1183

  set = atk_object_ref_state_set (accessible);

1184

  ret = atk_state_set_contains_state (set, ATK_STATE_MANAGES_DESCENDANTS);

1185

  g_object_unref (set);

1186

1187

  if (ret)

1188

    return TRUE;

1189

1190

  minor = g_quark_to_string (signal_hint->detail);

1191

1192

  detail1 = g_value_get_uint (param_values + 1);

1193

  child = g_value_get_pointer (param_values + 2);

1194

1195

  if (ATK_IS_OBJECT (child))

1196

1197

      ao = ATK_OBJECT (child);

1198

      emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,

1199

                  "(so)", ao, append_object);

1200

1201

  else if ((minor != NULL) && (strcmp (minor, "add") == 0))

1202

1203

      ao = atk_object_ref_accessible_child (accessible,

1204

                                            detail1);

1205

      emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,

1206

                  "(so)", ao, append_object);

1207

      g_object_unref (ao);

1208

1209

  else

1210

1211

      emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,

1212

                  "(so)", ao, append_object);

1213

1214

1215

  return TRUE;

1216

1217

1218

/*

1219

 * Handles the ATK signal 'Gtk:AtkObject:attribute-changed' and

1220

 * converts it to the AT-SPI signal - 'object:attributes-changed'

1221

1222

*/

1223

static gboolean

1224

attribute_changed_event_listener (GSignalInvocationHint *signal_hint,

1225

                                  guint n_param_values,

1226

                                  const GValue *param_values,

1227

                                  gpointer data)

1228

1229

  AtkObject *accessible;

1230

  const gchar *key = NULL, *value = NULL;

1231

1232

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

1233

  if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_STRING)

1234

    key = g_value_get_string (&param_values[1]);

1235

  else

1236

    key = "";

1237

  if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_STRING)

1238

    value = g_value_get_string (&param_values[2]);

1239

  else

1240

    value = "";

1241

1242

  emit_event (accessible, ITF_EVENT_OBJECT, "attributes-changed", key, 0, 0,

1243

              DBUS_TYPE_STRING_AS_STRING, value, append_basic);

1244

  return TRUE;

1245

1246

1247

/*

1248

 * Handles the ATK signal 'Gtk:AtkDocument:attribute-changed' and

1249

 * converts it to the AT-SPI signal - 'document:attributes-changed'

1250

1251

*/

1252

static gboolean

1253

document_attribute_changed_event_listener (GSignalInvocationHint *signal_hint,

1254

                                           guint n_param_values,

1255

                                           const GValue *param_values,

1256

                                           gpointer data)

1257

1258

  AtkObject *accessible;

1259

  const gchar *key = NULL, *value = NULL;

1260

1261

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

1262

  if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_STRING)

1263

    key = g_value_get_string (&param_values[1]);

1264

  else

1265

    key = "";

1266

  if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_STRING)

1267

    value = g_value_get_string (&param_values[2]);

1268

  else

1269

    value = "";

1270

1271

  emit_event (accessible, ITF_EVENT_DOCUMENT, "attributes-changed", key, 0, 0,

1272

              DBUS_TYPE_STRING_AS_STRING, value, append_basic);

1273

  return TRUE;

1274

1275

1276

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

1277

1278

/*

1279

 * Generic signal converter and forwarder.

1280

1281

 * Klass (Interface) org.a11y.atspi.Event.Object

1282

 * Major is the signal name.

1283

 * Minor is NULL.

1284

 * detail1 is 0.

1285

 * detail2 is 0.

1286

 * any_data is NULL.

1287

*/

1288

static gboolean

1289

generic_event_listener (GSignalInvocationHint *signal_hint,

1290

                        guint n_param_values,

1291

                        const GValue *param_values,

1292

                        gpointer data)

1293

1294

  AtkObject *accessible;

1295

  GSignalQuery signal_query;

1296

  const gchar *name;

1297

  int detail1 = 0, detail2 = 0;

1298

1299

  g_signal_query (signal_hint->signal_id, &signal_query);

1300

  name = signal_query.signal_name;

1301

1302

  accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));

1303

1304

  if (n_param_values > 1 && G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)

1305

    detail1 = g_value_get_int (&param_values[1]);

1306

1307

  if (n_param_values > 2 && G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)

1308

    detail2 = g_value_get_int (&param_values[2]);

1309

1310

  emit_event (accessible, ITF_EVENT_OBJECT, name, "", detail1, detail2,

1311

              DBUS_TYPE_INT32_AS_STRING, 0, append_basic);

1312

  return TRUE;

1313

1314

1315

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

1316

1317

/*

1318

 * Registers the provided function as a handler for the given signal name

1319

 * and stores the signal id returned so that the function may be

1320

 * de-registered later.

1321

*/

1322

static guint

1323

5957

add_signal_listener (GSignalEmissionHook listener, const char *signal_name)

1324

1325

  guint id;

1326

1327

5957

  id = atk_add_global_event_listener (listener, signal_name);

1328

1329

5957

  if (id > 0) /* id == 0 is a failure */

1330

5796

    g_array_append_val (listener_ids, id);

1331

1332

5957

  return id;

1333

1334

1335

/*

1336

 * Initialization for the signal handlers.

1337

1338

 * Registers all required signal handlers.

1339

*/

1340

void

1341

161

spi_atk_register_event_listeners (void)

1342

1343

/*

1344

   * Kludge to make sure the Atk interface types are registered, otherwise

1345

   * the AtkText signal handlers below won't get registered

1346

*/

1347

161

  GObject *ao = g_object_new (ATK_TYPE_OBJECT, NULL);

1348

161

  AtkObject *bo = atk_no_op_object_new (ao);

1349

161

  guint id = 0;

1350

1351

161

  g_object_unref (G_OBJECT (bo));

1352

161

  g_object_unref (ao);

1353

1354

161

  if (listener_ids)

1355

1356

      g_warning ("atk_bridge: spi_atk-register_event_listeners called multiple times");

1357

      return;

1358

1359

1360

  /* Register for focus event notifications, and register app with central registry  */

1361

161

  listener_ids = g_array_sized_new (FALSE, TRUE, sizeof (guint), 16);

1362

1363

161

  atk_bridge_focus_tracker_id = atk_add_focus_tracker (focus_tracker);

1364

1365

161

  add_signal_listener (property_event_listener,

1366

                       "Gtk:AtkObject:property-change");

1367

1368

  /* window events: we tentative try to register using the old format */

1369

161

  id = add_signal_listener (window_event_listener, "window:create");

1370

1371

161

  if (id != 0)

1372

1373

      /* If we are able to register using the old format, we assume

1374

       * that the ATK implementor is managing window events without

1375

       * AtkWindow. We can't use the opposite test because after

1376

       * including AtkWindow on ATK you would be able to register to

1377

       * that event, although the ATK implementor could or not use it.

1378

*/

1379

1380

      add_signal_listener (window_event_listener, "window:destroy");

1381

      add_signal_listener (window_event_listener, "window:minimize");

1382

      add_signal_listener (window_event_listener, "window:maximize");

1383

      add_signal_listener (window_event_listener, "window:restore");

1384

      add_signal_listener (window_event_listener, "window:activate");

1385

      add_signal_listener (window_event_listener, "window:deactivate");

1386

1387

  else

1388

1389

161

      add_signal_listener (window_event_listener, "Atk:AtkWindow:create");

1390

161

      add_signal_listener (window_event_listener, "Atk:AtkWindow:destroy");

1391

161

      add_signal_listener (window_event_listener, "Atk:AtkWindow:minimize");

1392

161

      add_signal_listener (window_event_listener, "Atk:AtkWindow:maximize");

1393

161

      add_signal_listener (window_event_listener, "Atk:AtkWindow:restore");

1394

161

      add_signal_listener (window_event_listener, "Atk:AtkWindow:activate");

1395

161

      add_signal_listener (window_event_listener, "Atk:AtkWindow:deactivate");

1396

1397

1398

161

  add_signal_listener (document_event_listener,

1399

                       "Gtk:AtkDocument:load-complete");

1400

161

  add_signal_listener (document_event_listener, "Gtk:AtkDocument:reload");

1401

161

  add_signal_listener (document_event_listener,

1402

                       "Gtk:AtkDocument:load-stopped");

1403

161

  add_signal_listener (document_event_listener,

1404

                       "Gtk:AtkDocument:page-changed");

1405

161

  add_signal_listener (document_attribute_changed_event_listener,

1406

                       "Gtk:AtkDocument:document-attribute-changed");

1407

  /* TODO Fake this event on the client side */

1408

161

  add_signal_listener (state_event_listener, "Gtk:AtkObject:state-change");

1409

  /* TODO */

1410

161

  add_signal_listener (active_descendant_event_listener,

1411

                       "Gtk:AtkObject:active-descendant-changed");

1412

161

  add_signal_listener (announcement_event_listener,

1413

                       "Gtk:AtkObject:announcement");

1414

161

  add_signal_listener (notification_event_listener,

1415

                       "Gtk:AtkObject:notification");

1416

161

  add_signal_listener (attribute_changed_event_listener,

1417

                       "Gtk:AtkObject:attribute-changed");

1418

161

  add_signal_listener (bounds_event_listener,

1419

                       "Gtk:AtkComponent:bounds-changed");

1420

161

  add_signal_listener (text_selection_changed_event_listener,

1421

                       "Gtk:AtkText:text-selection-changed");

1422

161

  add_signal_listener (text_changed_event_listener,

1423

                       "Gtk:AtkText:text-changed");

1424

161

  add_signal_listener (text_insert_event_listener,

1425

                       "Gtk:AtkText:text-insert");

1426

161

  add_signal_listener (text_remove_event_listener,

1427

                       "Gtk:AtkText:text-remove");

1428

161

  add_signal_listener (link_selected_event_listener,

1429

                       "Gtk:AtkHypertext:link-selected");

1430

161

  add_signal_listener (generic_event_listener,

1431

                       "Gtk:AtkObject:visible-data-changed");

1432

161

  add_signal_listener (generic_event_listener,

1433

                       "Gtk:AtkSelection:selection-changed");

1434

161

  add_signal_listener (generic_event_listener,

1435

                       "Gtk:AtkText:text-attributes-changed");

1436

161

  add_signal_listener (generic_event_listener,

1437

                       "Gtk:AtkText:text-caret-moved");

1438

161

  add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-inserted");

1439

161

  add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-reordered");

1440

161

  add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-deleted");

1441

161

  add_signal_listener (generic_event_listener,

1442

                       "Gtk:AtkTable:column-inserted");

1443

161

  add_signal_listener (generic_event_listener,

1444

                       "Gtk:AtkTable:column-reordered");

1445

161

  add_signal_listener (generic_event_listener, "Gtk:AtkTable:column-deleted");

1446

161

  add_signal_listener (generic_event_listener, "Gtk:AtkTable:model-changed");

1447

161

  add_signal_listener (children_changed_event_listener, "Gtk:AtkObject:children-changed");

1448

1449

#if 0

1450

  g_signal_connect (G_OBJECT (spi_global_app_data->root),

1451

                    "children-changed::add",

1452

                    (GCallback) toplevel_added_event_listener, NULL);

1453

1454

  g_signal_connect (G_OBJECT (spi_global_app_data->root),

1455

                    "children-changed::remove",

1456

                    (GCallback) toplevel_removed_event_listener, NULL);

1457

#endif

1458

1459

/*

1460

   * May add the following listeners to implement preemptive key listening for GTK+

1461

1462

   * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-press-event");

1463

   * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-release-event");

1464

*/

1465

161

  atk_bridge_key_event_listener_id =

1466

161

      atk_add_key_event_listener (spi_atk_bridge_key_listener, NULL);

1467

1468

1469

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

1470

1471

/*

1472

 * De-registers all ATK signal handlers.

1473

*/

1474

void

1475

161

spi_atk_deregister_event_listeners (void)

1476

1477

  gint i;

1478

161

  GArray *ids = listener_ids;

1479

161

  listener_ids = NULL;

1480

1481

161

  if (atk_bridge_focus_tracker_id)

1482

1483

161

      atk_remove_focus_tracker (atk_bridge_focus_tracker_id);

1484

161

      atk_bridge_focus_tracker_id = 0;

1485

1486

1487

161

  if (ids)

1488

1489

5957

      for (i = 0; i < ids->len; i++)

1490

1491

5796

          atk_remove_global_event_listener (g_array_index (ids, guint, i));

1492

1493

161

      g_array_free (ids, TRUE);

1494

1495

1496

161

  if (atk_bridge_key_event_listener_id)

1497

1498

      atk_remove_key_event_listener (atk_bridge_key_event_listener_id);

1499

      atk_bridge_key_event_listener_id = 0;

1500

1501

161

1502

1503

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

1504

1505

/*

1506

 * TODO This function seems out of place here.

1507

1508

 * Emits fake deactivate signals on all top-level windows.

1509

 * Used when shutting down AT-SPI, ensuring that all

1510

 * windows have been removed on the client side.

1511

*/

1512

void

1513

161

spi_atk_tidy_windows (void)

1514

1515

  AtkObject *root;

1516

  gint n_children;

1517

  gint i;

1518

1519

161

  root = atk_get_root ();

1520

161

  n_children = atk_object_get_n_accessible_children (root);

1521

491

  for (i = 0; i < n_children; i++)

1522

1523

      AtkObject *child;

1524

      AtkStateSet *stateset;

1525

      const gchar *name;

1526

1527

330

      child = atk_object_ref_accessible_child (root, i);

1528

330

      stateset = atk_object_ref_state_set (child);

1529

1530

330

      name = atk_object_get_name (child);

1531

330

      if (atk_state_set_contains_state (stateset, ATK_STATE_ACTIVE))

1532

1533

1

          emit_event (child, ITF_EVENT_WINDOW, "deactivate", NULL, 0, 0,

1534

                      DBUS_TYPE_STRING_AS_STRING, name, append_basic);

1535

1536

330

      g_object_unref (stateset);

1537

1538

330

      emit_event (child, ITF_EVENT_WINDOW, "destroy", NULL, 0, 0,

1539

                  DBUS_TYPE_STRING_AS_STRING, name, append_basic);

1540

330

      g_object_unref (child);

1541

1542

161

1543

1544

gboolean

1545

spi_event_is_subtype (gchar **needle, gchar **haystack)

1546

1547

  while (*haystack && **haystack)

1548

1549

      if (g_strcmp0 (*needle, *haystack))

1550

        return FALSE;

1551

      needle++;