Grcov report - atspi-misc.c

1

/*

2

 * AT-SPI - Assistive Technology Service Provider Interface

3

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

4

5

 * Copyright 2001, 2002 Sun Microsystems Inc.,

6

 * Copyright 2001, 2002 Ximian, Inc.

7

 * Copyright 2010, 2011 Novell, Inc.

8

9

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

10

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

11

 * License as published by the Free Software Foundation; either

12

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

13

14

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

15

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

16

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

17

 * Lesser General Public License for more details.

18

19

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

20

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

21

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

22

 * Boston, MA 02110-1301, USA.

23

*/

24

25

/*

26

27

 * Basic SPI initialization and event loop function prototypes

28

29

*/

30

31

#include "atspi-private.h"

32

#ifdef HAVE_X11

33

#include "X11/Xlib.h"

34

#endif

35

#include "atspi-gmain.h"

36

#include <ctype.h>

37

#include <locale.h>

38

#include <stdio.h>

39

#include <string.h>

40

41

/**

42

 * AtspiMisc:

43

44

 * Miscellaneous methods for using AT-SPI services.

45

*/

46

47

/* These are listed here for extraction by intltool */

48

#if 0

49

  N_("invalid")

50

  N_("accelerator label")

51

  N_("alert")

52

  N_("animation")

53

  N_("arrow")

54

  N_("calendar")

55

  N_("canvas")

56

  N_("check box")

57

  N_("check menu item")

58

  N_("color chooser")

59

  N_("column header")

60

  N_("combo box")

61

  N_("dateeditor")

62

  N_("desktop icon")

63

  N_("desktop frame")

64

  N_("dial")

65

  N_("dialog")

66

  N_("directory pane")

67

  N_("drawing area")

68

  N_("file chooser")

69

  N_("filler")

70

  /* I know it looks wrong but that is what Java returns */

71

  N_("fontchooser")

72

  N_("frame")

73

  N_("glass pane")

74

  N_("html container")

75

  N_("icon")

76

  N_("image")

77

  N_("internal frame")

78

  N_("label")

79

  N_("layered pane")

80

  N_("list")

81

  N_("list item")

82

  N_("menu")

83

  N_("menu bar")

84

  N_("menu button")

85

  N_("menu item")

86

  N_("option pane")

87

  N_("page tab")

88

  N_("page tab list")

89

  N_("panel")

90

  N_("password text")

91

  N_("popup menu")

92

  N_("progress bar")

93

  N_("button")

94

  N_("radio button")

95

  N_("radio menu item")

96

  N_("root pane")

97

  N_("row header")

98

  N_("scroll bar")

99

  N_("scroll pane")

100

  N_("separator")

101

  N_("slider")

102

  N_("split pane")

103

  N_("spin button")

104

  N_("statusbar")

105

  N_("switch")

106

  N_("table")

107

  N_("table cell")

108

  N_("table column header")

109

  N_("table row header")

110

  N_("tear off menu item")

111

  N_("terminal")

112

  N_("text")

113

  N_("toggle button")

114

  N_("tool bar")

115

  N_("tool tip")

116

  N_("tree")

117

  N_("tree table")

118

  N_("unknown")

119

  N_("viewport")

120

  N_("window")

121

  N_("header")

122

  N_("footer")

123

  N_("paragraph")

124

  N_("ruler")

125

  N_("application")

126

  N_("autocomplete")

127

  N_("edit bar")

128

  N_("embedded component")

129

  N_("entry")

130

  N_("chart")

131

  N_("caption")

132

  N_("document frame")

133

  N_("heading")

134

  N_("page")

135

  N_("section")

136

  N_("redundant object")

137

  N_("form")

138

  N_("link")

139

  N_("input method window")

140

  N_("table row")

141

  N_("tree item")

142

  N_("document spreadsheet")

143

  N_("document presentation")

144

  N_("document text")

145

  N_("document web")

146

  N_("document email")

147

  N_("comment")

148

  N_("list box")

149

  N_("grouping")

150

  N_("image map")

151

  N_("notification")

152

  N_("info bar")

153

  N_("level bar")

154

  N_("title bar")

155

  N_("block quote")

156

  N_("audio")

157

  N_("video")

158

  N_("definition")

159

  N_("article")

160

  N_("landmark")

161

  N_("log")

162

  N_("marquee")

163

  N_("math")

164

  N_("rating")

165

  N_("timer")

166

  N_("description list")

167

  N_("description term")

168

  N_("description value")

169

#endif /* 0 */

170

171

static void

172

1

_gettext_initialization (void)

173

174

  static gboolean gettext_initialized = FALSE;

175

176

1

  if (!gettext_initialized)

177

178

1

      gettext_initialized = TRUE;

179

1

      setlocale (LC_ALL, "");

180

1

      bindtextdomain (GETTEXT_PACKAGE, ATSPI_LOCALEDIR);

181

1

      bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

182

183

1

184

185

static void handle_get_items (DBusPendingCall *pending, void *user_data);

186

187

static DBusConnection *bus = NULL;

188

static GHashTable *live_refs = NULL;

189

static gint method_call_timeout = 800;

190

static gint app_startup_time = 15000;

191

192

GMainLoop *atspi_main_loop;

193

GMainContext *atspi_main_context;

194

gboolean atspi_no_cache;

195

196

const char *atspi_path_dec = ATSPI_DBUS_PATH_DEC;

197

const char *atspi_path_registry = ATSPI_DBUS_PATH_REGISTRY;

198

const char *atspi_path_root = ATSPI_DBUS_PATH_ROOT;

199

const char *atspi_bus_registry = ATSPI_DBUS_NAME_REGISTRY;

200

const char *atspi_interface_accessible = ATSPI_DBUS_INTERFACE_ACCESSIBLE;

201

const char *atspi_interface_action = ATSPI_DBUS_INTERFACE_ACTION;

202

const char *atspi_interface_application = ATSPI_DBUS_INTERFACE_APPLICATION;

203

const char *atspi_interface_collection = ATSPI_DBUS_INTERFACE_COLLECTION;

204

const char *atspi_interface_component = ATSPI_DBUS_INTERFACE_COMPONENT;

205

const char *atspi_interface_dec = ATSPI_DBUS_INTERFACE_DEC;

206

const char *atspi_interface_device_event_listener = ATSPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER;

207

const char *atspi_interface_document = ATSPI_DBUS_INTERFACE_DOCUMENT;

208

const char *atspi_interface_editable_text = ATSPI_DBUS_INTERFACE_EDITABLE_TEXT;

209

const char *atspi_interface_event_object = ATSPI_DBUS_INTERFACE_EVENT_OBJECT;

210

const char *atspi_interface_hyperlink = ATSPI_DBUS_INTERFACE_HYPERLINK;

211

const char *atspi_interface_hypertext = ATSPI_DBUS_INTERFACE_HYPERTEXT;

212

const char *atspi_interface_image = ATSPI_DBUS_INTERFACE_IMAGE;

213

const char *atspi_interface_registry = ATSPI_DBUS_INTERFACE_REGISTRY;

214

const char *atspi_interface_selection = ATSPI_DBUS_INTERFACE_SELECTION;

215

const char *atspi_interface_table = ATSPI_DBUS_INTERFACE_TABLE;

216

const char *atspi_interface_table_cell = ATSPI_DBUS_INTERFACE_TABLE_CELL;

217

const char *atspi_interface_text = ATSPI_DBUS_INTERFACE_TEXT;

218

const char *atspi_interface_cache = ATSPI_DBUS_INTERFACE_CACHE;

219

const char *atspi_interface_value = ATSPI_DBUS_INTERFACE_VALUE;

220

221

static const char *interfaces[] = {

222

  ATSPI_DBUS_INTERFACE_ACCESSIBLE,

223

  ATSPI_DBUS_INTERFACE_ACTION,

224

  ATSPI_DBUS_INTERFACE_APPLICATION,

225

  ATSPI_DBUS_INTERFACE_COLLECTION,

226

  ATSPI_DBUS_INTERFACE_COMPONENT,

227

  ATSPI_DBUS_INTERFACE_DOCUMENT,

228

  ATSPI_DBUS_INTERFACE_EDITABLE_TEXT,

229

  ATSPI_DBUS_INTERFACE_HYPERLINK,

230

  ATSPI_DBUS_INTERFACE_HYPERTEXT,

231

  ATSPI_DBUS_INTERFACE_IMAGE,

232

  ATSPI_DBUS_INTERFACE_SELECTION,

233

  ATSPI_DBUS_INTERFACE_SOCKET,

234

  ATSPI_DBUS_INTERFACE_TABLE,

235

  ATSPI_DBUS_INTERFACE_TABLE_CELL,

236

  ATSPI_DBUS_INTERFACE_TEXT,

237

  ATSPI_DBUS_INTERFACE_VALUE,

238

  NULL

239

};

240

241

/* Holds a dbus object reference as a pair of app_name/path.  These have the lifetime

242

 * of the DBusMessage that is being processed.

243

*/

244

typedef struct

245

246

  const char *app_name;

247

  const char *path;

248

} ReferenceFromMessage;

249

250

static void

251

3443

get_reference_from_iter (DBusMessageIter *iter, ReferenceFromMessage *ref)

252

253

  DBusMessageIter iter_struct;

254

255

3443

  dbus_message_iter_recurse (iter, &iter_struct);

256

3443

  dbus_message_iter_get_basic (&iter_struct, &ref->app_name);

257

3443

  dbus_message_iter_next (&iter_struct);

258

3443

  dbus_message_iter_get_basic (&iter_struct, &ref->path);

259

3443

  dbus_message_iter_next (iter);

260

3443

261

262

gint

263

3852

_atspi_get_iface_num (const char *iface)

264

265

  /* TODO: Use a binary search or hash to improve performance */

266

  int i;

267

268

17328

  for (i = 0; interfaces[i]; i++)

269

270

17328

      if (!strcmp (iface, interfaces[i]))

271

3852

        return i;

272

273

  return -1;

274

275

276

GHashTable *

277

2

_atspi_get_live_refs (void)

278

279

2

  if (!live_refs)

280

281

2

      live_refs = g_hash_table_new (g_direct_hash, g_direct_equal);

282

283

2

  return live_refs;

284

285

286

/* TODO: Add an application parameter */

287

DBusConnection *

288

337

_atspi_bus ()

289

290

337

  if (!bus)

291

    atspi_init ();

292

337

  if (!bus)

293

    g_error ("AT-SPI: Couldn't connect to accessibility bus. Is at-spi-bus-launcher running?");

294

337

  return bus;

295

296

297

#define APP_IS_REGISTRY(app) (!strcmp (app->bus_name, atspi_bus_registry))

298

299

static AtspiAccessible *desktop;

300

301

static void cleanup_deferred_message (void);

302

303

static void

304

2

cleanup ()

305

306

  GHashTable *refs;

307

  gint i;

308

309

2

  refs = live_refs;

310

2

  live_refs = NULL;

311

2

  if (refs)

312

313

2

      g_hash_table_destroy (refs);

314

315

316

2

  if (!desktop)

317

    goto end;

318

319

  /* TODO: Do we need this code, or should we just dispose the desktop? */

320

326

  for (i = desktop->children->len - 1; i >= 0; i--)

321

322

324

      AtspiAccessible *child = g_ptr_array_index (desktop->children, i);

323

324

      if (child->parent.app)

324

54

        g_object_run_dispose (G_OBJECT (child->parent.app));

325

324

      g_object_run_dispose (G_OBJECT (child));

326

327

328

2

  g_object_run_dispose (G_OBJECT (desktop->parent.app));

329

2

  g_object_unref (desktop);

330

2

  desktop = NULL;

331

332

2

end:

333

2

  if (bus)

334

335

2

      dbus_connection_close (bus);

336

2

      dbus_connection_unref (bus);

337

2

      bus = NULL;

338

339

340

2

  cleanup_deferred_message ();

341

2

342

343

static gboolean atspi_inited = FALSE;

344

345

static GHashTable *app_hash = NULL;

346

347

static void

348

166

handle_get_bus_address (DBusPendingCall *pending, void *user_data)

349

350

166

  AtspiApplication *app = user_data;

351

166

  DBusMessage *reply = dbus_pending_call_steal_reply (pending);

352

  DBusMessage *message;

353

  const char *address;

354

  DBusPendingCall *new_pending;

355

356

166

  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN)

357

358

161

      if (dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &address,

359

161

                                 DBUS_TYPE_INVALID) &&

360

161

          address[0])

361

362

          DBusError error;

363

          DBusConnection *bus;

364

365

161

          dbus_error_init (&error);

366

161

          bus = dbus_connection_open_private (address, &error);

367

161

          if (bus)

368

369

157

              if (app->bus)

370

371

157

                  dbus_connection_unref (app->bus);

372

373

157

              app->bus = bus;

374

157

              atspi_dbus_connection_setup_with_g_main (bus, g_main_context_default ());

375

376

          else

377

378

8

              if (!strcmp (error.name, DBUS_ERROR_FILE_NOT_FOUND) &&

379

4

                  !g_getenv ("ATSPI_IN_TESTS"))

380

                g_warning ("AT-SPI: Unable to open bus connection: %s", error.message);

381

4

              dbus_error_free (&error);

382

383

384

385

166

  dbus_message_unref (reply);

386

166

  dbus_pending_call_unref (pending);

387

388

166

  if (!app->bus)

389

    return; /* application has gone away / been disposed */

390

391

166

  message = dbus_message_new_method_call (app->bus_name,

392

                                          "/org/a11y/atspi/cache",

393

                                          atspi_interface_cache, "GetItems");

394

395

166

  dbus_connection_send_with_reply (app->bus, message, &new_pending, 2000);

396

166

  dbus_message_unref (message);

397

166

  if (!new_pending)

398

    return;

399

166

  dbus_pending_call_set_notify (new_pending, handle_get_items, app, NULL);

400

401

402

static AtspiApplication *

403

7358

get_application (const char *bus_name)

404

405

7358

  AtspiApplication *app = NULL;

406

  char *bus_name_dup;

407

  DBusMessage *message;

408

7358

  DBusPendingCall *pending = NULL;

409

410

7358

  if (!app_hash)

411

412

2

      app_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_object_unref);

413

414

7358

  app = g_hash_table_lookup (app_hash, bus_name);

415

7358

  if (app)

416

7192

    return app;

417

166

  bus_name_dup = g_strdup (bus_name);

418

419

  // TODO: change below to something that will send state-change:defunct notification if necessary */

420

166

  app = _atspi_application_new (bus_name);

421

166

  app->bus = dbus_connection_ref (_atspi_bus ());

422

166

  gettimeofday (&app->time_added, NULL);

423

166

  app->cache = ATSPI_CACHE_UNDEFINED;

424

166

  g_hash_table_insert (app_hash, bus_name_dup, app);

425

166

  message = dbus_message_new_method_call (bus_name, atspi_path_root,

426

                                          atspi_interface_application, "GetApplicationBusAddress");

427

428

166

  dbus_connection_send_with_reply (app->bus, message, &pending, 2000);

429

166

  dbus_message_unref (message);

430

166

  if (!pending)

431

432

      g_hash_table_remove (app_hash, bus_name_dup);

433

      return NULL;

434

435

166

  dbus_pending_call_set_notify (pending, handle_get_bus_address, app, NULL);

436

166

  return app;

437

438

439

static AtspiAccessible *

440

3436

ref_accessible (ReferenceFromMessage *ref)

441

442

  AtspiApplication *app;

443

  AtspiAccessible *a;

444

445

3436

  if (!strcmp (ref->path, ATSPI_DBUS_PATH_NULL))

446

133

    return NULL;

447

448

3303

  app = get_application (ref->app_name);

449

450

3303

  if (!strcmp (ref->path, "/org/a11y/atspi/accessible/root"))

451

452

865

      if (!app->root)

453

454

324

          app->root = _atspi_accessible_new (app, atspi_path_root);

455

324

          app->root->accessible_parent = atspi_get_desktop (0);

456

324

          g_ptr_array_add (app->root->accessible_parent->children, g_object_ref (app->root));

457

458

865

      return g_object_ref (app->root);

459

460

461

2438

  a = g_hash_table_lookup (app->hash, ref->path);

462

2438

  if (a)

463

464

1184

      return g_object_ref (a);

465

466

1254

  a = _atspi_accessible_new (app, ref->path);

467

2508

  g_hash_table_insert (app->hash, g_strdup (a->parent.path), g_object_ref (a));

468

1254

  return a;

469

470

471

static AtspiHyperlink *

472

9

ref_hyperlink (const char *app_name, const char *path)

473

474

9

  AtspiApplication *app = get_application (app_name);

475

  AtspiHyperlink *hyperlink;

476

477

9

  if (!strcmp (path, ATSPI_DBUS_PATH_NULL))

478

    return NULL;

479

480

9

  hyperlink = g_hash_table_lookup (app->hash, path);

481

9

  if (hyperlink)

482

483

      return g_object_ref (hyperlink);

484

485

9

  hyperlink = _atspi_hyperlink_new (app, path);

486

18

  g_hash_table_insert (app->hash, g_strdup (hyperlink->parent.path), hyperlink);

487

  /* TODO: This should be a weak ref */

488

9

  g_object_ref (hyperlink); /* for the hash */

489

9

  return hyperlink;

490

491

492

typedef struct

493

494

  char *path;

495

  char *parent;

496

  GArray *children;

497

  GArray *interfaces;

498

  char *name;

499

  dbus_uint32_t role;

500

  char *description;

501

  GArray *state_bitflags;

502

} CACHE_ADDITION;

503

504

static DBusHandlerResult

505

handle_remove_accessible (DBusConnection *bus, DBusMessage *message)

506

507

  ReferenceFromMessage ref;

508

  AtspiApplication *app;

509

  DBusMessageIter iter;

510

  const char *signature = dbus_message_get_signature (message);

511

  AtspiAccessible *a;

512

513

  if (strcmp (signature, "(so)") != 0)

514

515

      g_warning ("AT-SPI: Unknown signature %s for RemoveAccessible", signature);

516

      return DBUS_HANDLER_RESULT_HANDLED;

517

518

519

  dbus_message_iter_init (message, &iter);

520

521

  get_reference_from_iter (&iter, &ref);

522

  app = get_application (ref.app_name);

523

  a = ref_accessible (&ref);

524

  if (!a)

525

    return DBUS_HANDLER_RESULT_HANDLED;

526

  g_object_run_dispose (G_OBJECT (a));

527

  g_hash_table_remove (app->hash, a->parent.path);

528

  g_object_unref (a); /* unref our own ref */

529

  return DBUS_HANDLER_RESULT_HANDLED;

530

531

532

static DBusHandlerResult

533

646

handle_name_owner_changed (DBusConnection *bus, DBusMessage *message)

534

535

  const char *name, *new, *old;

536

  static gboolean registry_lost = FALSE;

537

538

646

  if (!dbus_message_get_args (message, NULL,

539

                              DBUS_TYPE_STRING, &name,

540

                              DBUS_TYPE_STRING, &old,

541

                              DBUS_TYPE_STRING, &new,

542

                              DBUS_TYPE_INVALID))

543

544

      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

545

546

547

646

  if (!strcmp (name, "org.a11y.atspi.Registry"))

548

549

1

      if (registry_lost && !old[0])

550

551

          _atspi_reregister_event_listeners ();

552

          _atspi_reregister_device_listeners ();

553

          registry_lost = FALSE;

554

555

1

      else if (!new[0])

556

        registry_lost = TRUE;

557

558

645

  else if (app_hash)

559

560

641

      AtspiApplication *app = g_hash_table_lookup (app_hash, old);

561

641

      if (app && !strcmp (app->bus_name, old))

562

321

        g_object_run_dispose (G_OBJECT (app));

563

564

646

  return DBUS_HANDLER_RESULT_HANDLED;

565

566

567

static gboolean

568

2

add_app_to_desktop (AtspiAccessible *a, const char *bus_name)

569

570

2

  ReferenceFromMessage ref = {

571

    .app_name = bus_name,

572

    .path = atspi_path_root,

573

};

574

2

  AtspiAccessible *obj = ref_accessible (&ref);

575

  /* The app will be added to the desktop as a side-effect of calling

576

   * ref_accessible */

577

2

  g_object_unref (obj);

578

2

  return (obj != NULL);

579

580

581

static void

582

1384

add_accessible_from_iter (DBusMessageIter *iter)

583

584

  DBusMessageIter iter_struct, iter_array;

585

  AtspiAccessible *accessible;

586

  AtspiAccessible *parent;

587

  const char *name, *description;

588

  dbus_uint32_t role;

589

1384

  gboolean children_cached = FALSE;

590

  dbus_int32_t count, index;

591

592

1384

  dbus_message_iter_recurse (iter, &iter_struct);

593

594

  /* get accessible */

595

1384

  accessible = _atspi_dbus_consume_accessible (&iter_struct);

596

1384

  if (!accessible)

597

    return;

598

599

  /* Get application: TODO */

600

1384

  dbus_message_iter_next (&iter_struct);

601

602

  /* get parent */

603

1384

  parent = _atspi_dbus_consume_accessible (&iter_struct);

604

1384

  if (accessible->accessible_parent)

605

130

    g_object_unref (accessible->accessible_parent);

606

1384

  if (parent == accessible)

607

608

      guint pid = atspi_accessible_get_process_id (accessible, NULL);

609

      if (!g_getenv ("ATSPI_IN_TESTS"))

610

        g_warning ("Process %d sent an accessible with itself as its parent. This shouldn't happen.", pid);

611

      accessible->accessible_parent = NULL;

612

613

  else

614

1384

    accessible->accessible_parent = parent;

615

616

1384

  if (dbus_message_iter_get_arg_type (&iter_struct) == 'i')

617

618

      /* Get index in parent */

619

1384

      dbus_message_iter_get_basic (&iter_struct, &index);

620

1384

      if (index >= 0 && accessible->accessible_parent)

621

622

1253

          AtspiAccessible *old_child = NULL;

623

1253

          if (index >= accessible->accessible_parent->children->len)

624

625

              /* There is no room for this object */

626

357

              g_ptr_array_set_size (accessible->accessible_parent->children, index + 1);

627

628

          else

629

630

              /* This place is already taken - let's free this place with dignity */

631

896

              if (g_ptr_array_index (accessible->accessible_parent->children, index))

632

                old_child = g_ptr_array_index (accessible->accessible_parent->children, index);

633

634

1253

          g_ptr_array_index (accessible->accessible_parent->children, index) = g_object_ref (accessible);

635

1253

          g_clear_object (&old_child);

636

637

638

      /* get child count */

639

1384

      dbus_message_iter_next (&iter_struct);

640

1384

      dbus_message_iter_get_basic (&iter_struct, &count);

641

1384

      if (count >= 0)

642

643

1384

          g_ptr_array_set_size (accessible->children, count);

644

1384

          children_cached = TRUE;

645

646

647

  else if (dbus_message_iter_get_arg_type (&iter_struct) == 'a')

648

649

      /* It's the old API with a list of children */

650

      /* TODO: Perhaps remove this code eventually */

651

      dbus_message_iter_recurse (&iter_struct, &iter_array);

652

      while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

653

654

          AtspiAccessible *child;

655

          child = _atspi_dbus_consume_accessible (&iter_array);

656

          g_ptr_array_remove (accessible->children, child);

657

          g_ptr_array_add (accessible->children, child);

658

659

      children_cached = TRUE;

660

661

662

  /* interfaces */

663

1384

  dbus_message_iter_next (&iter_struct);

664

1384

  _atspi_dbus_set_interfaces (accessible, &iter_struct);

665

1384

  dbus_message_iter_next (&iter_struct);

666

667

  /* name */

668

1384

  if (accessible->name)

669

131

    g_free (accessible->name);

670

1384

  dbus_message_iter_get_basic (&iter_struct, &name);

671

1384

  accessible->name = g_strdup (name);

672

1384

  dbus_message_iter_next (&iter_struct);

673

674

  /* role */

675

1384

  dbus_message_iter_get_basic (&iter_struct, &role);

676

1384

  accessible->role = role;

677

1384

  dbus_message_iter_next (&iter_struct);

678

679

  /* description */

680

1384

  if (accessible->description)

681

    g_free (accessible->description);

682

1384

  dbus_message_iter_get_basic (&iter_struct, &description);

683

1384

  accessible->description = g_strdup (description);

684

1384

  dbus_message_iter_next (&iter_struct);

685

686

1384

  _atspi_dbus_set_state (accessible, &iter_struct);

687

1384

  dbus_message_iter_next (&iter_struct);

688

689

1384

  _atspi_accessible_add_cache (accessible, ATSPI_CACHE_NAME | ATSPI_CACHE_ROLE |

690

                                               ATSPI_CACHE_PARENT | ATSPI_CACHE_DESCRIPTION);

691

1384

  if (!atspi_state_set_contains (accessible->states,

692

1384

                                 ATSPI_STATE_MANAGES_DESCENDANTS) &&

693

      children_cached)

694

1384

    _atspi_accessible_add_cache (accessible, ATSPI_CACHE_CHILDREN);

695

696

  /* This is a bit of a hack since the cache holds a ref, so we don't need

697

   * the one provided for us anymore */

698

1384

  g_object_unref (accessible);

699

700

701

static void

702

140

handle_get_items (DBusPendingCall *pending, void *user_data)

703

704

140

  DBusMessage *reply = dbus_pending_call_steal_reply (pending);

705

  DBusMessageIter iter, iter_array;

706

707

140

  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)

708

709

5

      const char *sender = dbus_message_get_sender (reply);

710

5

      const char *error = NULL;

711

5

      const char *error_name = dbus_message_get_error_name (reply);

712

5

      if (!strcmp (error_name, DBUS_ERROR_SERVICE_UNKNOWN) || !strcmp (error_name, DBUS_ERROR_NO_REPLY))

713

714

715

      else

716

717

          dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &error,

718

                                 DBUS_TYPE_INVALID);

719

          g_warning ("AT-SPI: Error in GetItems, sender=%s, error=%s", sender, error);

720

721

5

      dbus_message_unref (reply);

722

5

      dbus_pending_call_unref (pending);

723

5

      return;

724

725

726

135

  dbus_message_iter_init (reply, &iter);

727

135

  dbus_message_iter_recurse (&iter, &iter_array);

728

1519

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

729

730

1384

      add_accessible_from_iter (&iter_array);

731

1384

      dbus_message_iter_next (&iter_array);

732

733

135

  dbus_message_unref (reply);

734

135

  dbus_pending_call_unref (pending);

735

736

737

/* TODO: Do we stil need this function? */

738

static AtspiAccessible *

739

2

ref_accessible_desktop (AtspiApplication *app)

740

741

  GError *error;

742

  DBusMessage *message, *reply;

743

  DBusMessageIter iter, iter_array;

744

  gchar *bus_name_dup;

745

746

2

  if (desktop)

747

748

      g_object_ref (desktop);

749

      return desktop;

750

751

2

  desktop = _atspi_accessible_new (app, atspi_path_root);

752

4

  g_hash_table_insert (app->hash, g_strdup (desktop->parent.path),

753

                       g_object_ref (desktop));

754

2

  app->root = g_object_ref (desktop);

755

2

  desktop->name = g_strdup ("main");

756

2

  message = dbus_message_new_method_call (atspi_bus_registry,

757

                                          atspi_path_root,

758

                                          atspi_interface_accessible,

759

                                          "GetChildren");

760

2

  if (!message)

761

    return NULL;

762

2

  error = NULL;

763

2

  reply = _atspi_dbus_send_with_reply_and_block (message, &error);

764

2

  if (!reply || strcmp (dbus_message_get_signature (reply), "a(so)") != 0)

765

766

      if (error != NULL)

767

768

          g_warning ("Couldn't get application list: %s", error->message);

769

          g_clear_error (&error);

770

771

      if (reply)

772

        dbus_message_unref (reply);

773

      return NULL;

774

775

2

  dbus_message_iter_init (reply, &iter);

776

2

  dbus_message_iter_recurse (&iter, &iter_array);

777

4

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

778

779

      ReferenceFromMessage ref;

780

781

2

      get_reference_from_iter (&iter_array, &ref);

782

2

      add_app_to_desktop (desktop, ref.app_name);

783

784

785

  /* Record the alternate name as an alias for org.a11y.atspi.Registry */

786

2

  bus_name_dup = g_strdup (dbus_message_get_sender (reply));

787

2

  if (bus_name_dup)

788

2

    g_hash_table_insert (app_hash, bus_name_dup, app);

789

790

2

  dbus_message_unref (reply);

791

792

2

  return g_object_ref (desktop);

793

794

795

AtspiAccessible *

796

4030

_atspi_ref_accessible (const char *app, const char *path)

797

798

4030

  ReferenceFromMessage ref = {

799

    .app_name = app,

800

    .path = path,

801

};

802

4030

  AtspiApplication *a = get_application (app);

803

4030

  if (!a)

804

    return NULL;

805

4030

  if (APP_IS_REGISTRY (a))

806

807

4028

      if (!a->root)

808

2

        g_object_unref (ref_accessible_desktop (a)); /* sets a->root */

809

4028

      return g_object_ref (a->root);

810

811

2

  return ref_accessible (&ref);

812

813

814

AtspiAccessible *

815

312

_atspi_dbus_return_accessible_from_message (DBusMessage *message)

816

817

  DBusMessageIter iter;

818

312

  AtspiAccessible *retval = NULL;

819

  const char *signature;

820

821

312

  if (!message)

822

    return NULL;

823

824

312

  signature = dbus_message_get_signature (message);

825

312

  if (!strcmp (signature, "(so)"))

826

827

312

      dbus_message_iter_init (message, &iter);

828

312

      retval = _atspi_dbus_consume_accessible (&iter);

829

830

  else

831

832

      g_warning ("AT-SPI: Called _atspi_dbus_return_accessible_from_message with strange signature %s", signature);

833

834

312

  dbus_message_unref (message);

835

312

  return retval;

836

837

838

/* Enters an iter which must be already pointing to a (so) and returns the accessible for it */

839

AtspiAccessible *

840

3432

_atspi_dbus_consume_accessible (DBusMessageIter *iter)

841

842

  ReferenceFromMessage ref;

843

844

3432

  get_reference_from_iter (iter, &ref);

845

3432

  return ref_accessible (&ref);

846

847

848

AtspiHyperlink *

849

9

_atspi_dbus_return_hyperlink_from_message (DBusMessage *message)

850

851

  DBusMessageIter iter;

852

9

  AtspiHyperlink *retval = NULL;

853

  const char *signature;

854

855

9

  if (!message)

856

    return NULL;

857

858

9

  signature = dbus_message_get_signature (message);

859

9

  if (!strcmp (signature, "(so)"))

860

861

9

      dbus_message_iter_init (message, &iter);

862

9

      retval = _atspi_dbus_return_hyperlink_from_iter (&iter);

863

864

  else

865

866

      g_warning ("AT-SPI: Called _atspi_dbus_return_hyperlink_from_message with strange signature %s", signature);

867

868

9

  dbus_message_unref (message);

869

9

  return retval;

870

871

872

AtspiHyperlink *

873

9

_atspi_dbus_return_hyperlink_from_iter (DBusMessageIter *iter)

874

875

  ReferenceFromMessage ref;

876

877

9

  get_reference_from_iter (iter, &ref);

878

9

  return ref_hyperlink (ref.app_name, ref.path);

879

880

881

const char *cache_signal_type = "((so)(so)(so)iiassusau)";

882

const char *old_cache_signal_type = "((so)(so)(so)a(so)assusau)";

883

884

static DBusHandlerResult

885

handle_add_accessible (DBusConnection *bus, DBusMessage *message)

886

887

  DBusMessageIter iter;

888

  const char *signature = dbus_message_get_signature (message);

889

890

  if (strcmp (signature, cache_signal_type) != 0 &&

891

      strcmp (signature, old_cache_signal_type) != 0)

892

893

      g_warning ("AT-SPI: AddAccessible with unknown signature %s\n", signature);

894

      return DBUS_HANDLER_RESULT_HANDLED;

895

896

897

  dbus_message_iter_init (message, &iter);

898

  add_accessible_from_iter (&iter);

899

  return DBUS_HANDLER_RESULT_HANDLED;

900

901

902

typedef struct

903

904

  DBusConnection *bus;

905

  DBusMessage *message;

906

} BusDataClosure;

907

908

static GSource *process_deferred_messages_source = NULL;

909

910

static void

911

969

process_deferred_message (BusDataClosure *closure)

912

913

969

  int type = dbus_message_get_type (closure->message);

914

969

  const char *interface = dbus_message_get_interface (closure->message);

915

916

969

  if (type == DBUS_MESSAGE_TYPE_SIGNAL &&

917

969

      !strncmp (interface, "org.a11y.atspi.Event.", 21))

918

919

323

      _atspi_dbus_handle_event (closure->message);

920

921

646

  else if (dbus_message_is_method_call (closure->message, atspi_interface_device_event_listener, "NotifyEvent"))

922

923

      _atspi_dbus_handle_DeviceEvent (closure->bus, closure->message);

924

925

646

  else if (dbus_message_is_signal (closure->message, atspi_interface_cache, "AddAccessible"))

926

927

      handle_add_accessible (closure->bus, closure->message);

928

929

646

  else if (dbus_message_is_signal (closure->message, atspi_interface_cache, "RemoveAccessible"))

930

931

      handle_remove_accessible (closure->bus, closure->message);

932

933

646

  else if (dbus_message_is_signal (closure->message, "org.freedesktop.DBus", "NameOwnerChanged"))

934

935

646

      handle_name_owner_changed (closure->bus, closure->message);

936

937

969

938

939

static GQueue *deferred_messages = NULL;

940

941

static void

942

969

destroy_deferred_message_item (gpointer ptr)

943

944

969

  BusDataClosure *c = ptr;

945

969

  dbus_message_unref (c->message);

946

969

  dbus_connection_unref (c->bus);

947

969

  g_free (c);

948

969

949

950

static void

951

2

cleanup_deferred_message (void)

952

953

2

  if (deferred_messages)

954

955

2

      g_queue_free_full (deferred_messages, destroy_deferred_message_item);

956

2

      deferred_messages = NULL;

957

958

2

959

960

static gboolean

961

1651

process_deferred_messages (void)

962

963

  static int in_process_deferred_messages = 0;

964

  BusDataClosure *closure;

965

966

1651

  if (in_process_deferred_messages)

967

493

    return TRUE;

968

1158

  in_process_deferred_messages = 1;

969

2127

  while ((closure = g_queue_pop_head (deferred_messages)))

970

971

969

      process_deferred_message (closure);

972

969

      destroy_deferred_message_item (closure);

973

974

1158

  in_process_deferred_messages = 0;

975

1158

  return FALSE;

976

977

978

static gboolean

979

658

process_deferred_messages_callback (gpointer data)

980

981

658

  if (process_deferred_messages ())

982

    return G_SOURCE_CONTINUE;

983

984

658

  process_deferred_messages_source = NULL;

985

658

  return G_SOURCE_REMOVE;

986

987

988

static DBusHandlerResult

989

969

defer_message (DBusConnection *connection, DBusMessage *message)

990

991

969

  BusDataClosure *closure = g_new (BusDataClosure, 1);

992

993

969

  closure->bus = dbus_connection_ref (bus);

994

969

  closure->message = dbus_message_ref (message);

995

996

969

  g_queue_push_tail (deferred_messages, closure);

997

998

969

  if (process_deferred_messages_source == NULL)

999

1000

658

      process_deferred_messages_source = g_idle_source_new ();

1001

658

      g_source_set_callback (process_deferred_messages_source,

1002

                             process_deferred_messages_callback, NULL, NULL);

1003

658

      g_source_attach (process_deferred_messages_source, atspi_main_context);

1004

658

      g_source_unref (process_deferred_messages_source);

1005

1006

1007

969

  return DBUS_HANDLER_RESULT_HANDLED;

1008

1009

1010

static DBusHandlerResult

1011

972

atspi_dbus_filter (DBusConnection *bus, DBusMessage *message, void *data)

1012

1013

  /* Check that we don't start passing stuff from whatever calls dbus_connection_add_filter() */

1014

972

  g_assert (data == NULL);

1015

1016

972

  int type = dbus_message_get_type (message);

1017

972

  const char *interface = dbus_message_get_interface (message);

1018

1019

972

  if (type == DBUS_MESSAGE_TYPE_SIGNAL &&

1020

971

      !strncmp (interface, "org.a11y.atspi.Event.", 21))

1021

1022

323

      return defer_message (bus, message);

1023

1024

649

  if (dbus_message_is_method_call (message, atspi_interface_device_event_listener, "NotifyEvent"))

1025

1026

      return defer_message (bus, message);

1027

1028

649

  if (dbus_message_is_signal (message, atspi_interface_cache, "AddAccessible"))

1029

1030

      return defer_message (bus, message);

1031

1032

649

  if (dbus_message_is_signal (message, atspi_interface_cache, "RemoveAccessible"))

1033

1034

      return defer_message (bus, message);

1035

1036

649

  if (dbus_message_is_signal (message, "org.freedesktop.DBus", "NameOwnerChanged"))

1037

1038

646

      defer_message (bus, message);

1039

646

      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1040

1041

3

  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1042

1043

1044

/**

1045

 * atspi_init:

1046

1047

 * Connects to the accessibility registry and initializes the SPI.

1048

1049

 * Returns: 0 on success, 1 if already initialized, or an integer error code.

1050

**/

1051

int

1052

2

atspi_init (void)

1053

1054

  char *match;

1055

  const gchar *no_cache;

1056

1057

2

  if (atspi_inited)

1058

1059

      return 1;

1060

1061

1062

2

  atspi_inited = TRUE;

1063

1064

2

  _atspi_get_live_refs ();

1065

1066

2

  bus = atspi_get_a11y_bus ();

1067

2

  if (!bus)

1068

    return 2;

1069

2

  dbus_bus_register (bus, NULL);

1070

2

  atspi_dbus_connection_setup_with_g_main (bus, g_main_context_default ());

1071

2

  dbus_connection_add_filter (bus, atspi_dbus_filter, NULL, NULL);

1072

2

  match = g_strdup_printf ("type='signal',interface='%s',member='AddAccessible'", atspi_interface_cache);

1073

2

  dbus_bus_add_match (bus, match, NULL);

1074

2

  g_free (match);

1075

2

  match = g_strdup_printf ("type='signal',interface='%s',member='RemoveAccessible'", atspi_interface_cache);

1076

2

  dbus_bus_add_match (bus, match, NULL);

1077

2

  g_free (match);

1078

2

  match = g_strdup_printf ("type='signal',interface='%s',member='ChildrenChanged'", atspi_interface_event_object);

1079

2

  dbus_bus_add_match (bus, match, NULL);

1080

2

  g_free (match);

1081

2

  match = g_strdup_printf ("type='signal',interface='%s',member='PropertyChange'", atspi_interface_event_object);

1082

2

  dbus_bus_add_match (bus, match, NULL);

1083

2

  g_free (match);

1084

2

  match = g_strdup_printf ("type='signal',interface='%s',member='StateChanged'", atspi_interface_event_object);

1085

2

  dbus_bus_add_match (bus, match, NULL);

1086

2

  g_free (match);

1087

1088

2

  dbus_bus_add_match (bus,

1089

                      "type='signal', interface='org.freedesktop.DBus', member='NameOwnerChanged'",

1090

                      NULL);

1091

1092

2

  no_cache = g_getenv ("ATSPI_NO_CACHE");

1093

2

  if (no_cache && g_strcmp0 (no_cache, "0") != 0)

1094

    atspi_no_cache = TRUE;

1095

1096

2

  deferred_messages = g_queue_new ();

1097

1098

2

  return 0;

1099

1100

1101

/**

1102

 * atspi_is_initialized:

1103

1104

 * Indicates whether AT-SPI has been initialized.

1105

1106

 * Returns: %True if initialized; %False otherwise.

1107

*/

1108

gboolean

1109

161

atspi_is_initialized ()

1110

1111

161

  return atspi_inited;

1112

1113

1114

/**

1115

 * atspi_event_main:

1116

1117

 * Starts/enters the main event loop for the AT-SPI services.

1118

1119

 * NOTE: This method does not return control; it is exited via a call to

1120

 * #atspi_event_quit from within an event handler.

1121

1122

**/

1123

void

1124

162

atspi_event_main (void)

1125

1126

162

  atspi_main_loop = g_main_loop_new (NULL, FALSE);

1127

162

  g_main_loop_run (atspi_main_loop);

1128

161

  g_main_loop_unref (atspi_main_loop);

1129

161

  atspi_main_loop = NULL;

1130

161

1131

1132

/**

1133

 * atspi_event_quit:

1134

1135

 * Quits the last main event loop for the AT-SPI services,

1136

 * See: #atspi_event_main

1137

**/

1138

void

1139

162

atspi_event_quit (void)

1140

1141

162

  if (atspi_main_loop)

1142

162

    g_main_loop_quit (atspi_main_loop);

1143

162

1144

1145

/**

1146

 * atspi_exit:

1147

1148

 * Disconnects from #AtspiRegistry instances and releases

1149

 * any floating resources. Call only once at exit.

1150

1151

 * Returns: 0 if there were no leaks, otherwise other integer values.

1152

**/

1153

int

1154

2

atspi_exit (void)

1155

1156

  int leaked;

1157

1158

2

  if (!atspi_inited)

1159

1160

      return 0;

1161

1162

1163

2

  atspi_inited = FALSE;

1164

1165

2

  if (live_refs)

1166

1167

2

      leaked = g_hash_table_size (live_refs);

1168

1169

  else

1170

1171

      leaked = 0;

1172

1173

1174

2

  cleanup ();

1175

1176

2

  return leaked;

1177

1178

1179

static GSList *hung_processes;

1180

1181

static void

1182

remove_hung_process (DBusPendingCall *pending, void *data)

1183

1184

  hung_processes = g_slist_remove (hung_processes, data);

1185

  g_free (data);

1186

  dbus_pending_call_unref (pending);

1187

1188

1189

static void

1190

977

check_for_hang (DBusMessage *message, DBusError *error, DBusConnection *bus, const char *bus_name)

1191

1192

977

  if (!message && error->name &&

1193

      !strcmp (error->name, "org.freedesktop.DBus.Error.NoReply"))

1194

1195

      GSList *l;

1196

      DBusMessage *message;

1197

      gchar *bus_name_dup;

1198

      DBusPendingCall *pending = NULL;

1199

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

1200

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

1201

          return;

1202

      message = dbus_message_new_method_call (bus_name, "/",

1203

                                              "org.freedesktop.DBus.Peer",

1204

                                              "Ping");

1205

      if (!message)

1206

        return;

1207

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

1208

      dbus_message_unref (message);

1209

      if (!pending)

1210

        return;

1211

      bus_name_dup = g_strdup (bus_name);

1212

      hung_processes = g_slist_append (hung_processes, bus_name_dup);

1213

      dbus_pending_call_set_notify (pending, remove_hung_process, bus_name_dup, NULL);

1214

1215

1216

1217

static gboolean

1218

490

connection_is_hung (const char *bus_name)

1219

1220

  GSList *l;

1221

1222

490

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

1223

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

1224

      return TRUE;

1225

490

  return FALSE;

1226

1227

1228

static gboolean

1229

977

check_app (AtspiApplication *app, GError **error)

1230

1231

977

  if (!app || !app->bus)

1232

1233

      g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_APPLICATION_GONE,

1234

                           _ ("The application no longer exists"));

1235

      return FALSE;

1236

1237

1238

977

  if (atspi_main_loop && connection_is_hung (app->bus_name))

1239

1240

      g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_IPC,

1241

                           "The process appears to be hung.");

1242

      return FALSE;

1243

1244

1245

977

  return TRUE;

1246

1247

1248

static void

1249

993

set_timeout (AtspiApplication *app)

1250

1251

  struct timeval tv;

1252

  int diff;

1253

1254

993

  if (app && app_startup_time > 0)

1255

1256

993

      gettimeofday (&tv, NULL);

1257

993

      diff = (tv.tv_sec - app->time_added.tv_sec) * 1000 + (tv.tv_usec - app->time_added.tv_usec) / 1000;

1258

993

      dbind_set_timeout (MAX (method_call_timeout, app_startup_time - diff));

1259

1260

  else

1261

    dbind_set_timeout (method_call_timeout);

1262

993

1263

1264

/* Makes a DBus call and returns a success value.  Simple return values can be demarshaled automatically

1265

 * by passing their types after a "=>" marker in the @type argument (e.g. s=>i for a call that takes a string

1266

 * and returns an int).

1267

*/

1268

dbus_bool_t

1269

137

_atspi_dbus_call (gpointer obj, const char *interface, const char *method, GError **error, const char *type, ...)

1270

1271

  va_list args;

1272

  dbus_bool_t retval;

1273

  DBusError err;

1274

137

  AtspiObject *aobj = ATSPI_OBJECT (obj);

1275

1276

137

  if (!check_app (aobj->app, error))

1277

    return FALSE;

1278

1279

137

  va_start (args, type);

1280

137

  dbus_error_init (&err);

1281

137

  set_timeout (aobj->app);

1282

137

  retval = dbind_method_call_reentrant_va (aobj->app->bus, aobj->app->bus_name,

1283

137

                                           aobj->path, interface, method, &err,

1284

                                           type, args);

1285

137

  va_end (args);

1286

137

  check_for_hang (NULL, &err, aobj->app->bus, aobj->app->bus_name);

1287

137

  process_deferred_messages ();

1288

137

  if (dbus_error_is_set (&err))

1289

1290

      g_set_error (error, ATSPI_ERROR, ATSPI_ERROR_IPC, "%s", err.message);

1291

      dbus_error_free (&err);

1292

1293

137

  return retval;

1294

1295

1296

static DBusMessage *

1297

465

_atspi_dbus_call_partial_va (gpointer obj,

1298

                             const char *interface,

1299

                             const char *method,

1300

                             GError **error,

1301

                             const char *type,

1302

                             va_list args)

1303

1304

465

  AtspiObject *aobj = ATSPI_OBJECT (obj);

1305

  DBusError err;

1306

465

  DBusMessage *msg = NULL, *reply = NULL;

1307

  DBusMessageIter iter;

1308

  const char *p;

1309

1310

465

  dbus_error_init (&err);

1311

1312

465

  if (!check_app (aobj->app, error))

1313

    goto out;

1314

1315

465

  msg = dbus_message_new_method_call (aobj->app->bus_name, aobj->path, interface, method);

1316

465

  if (!msg)

1317

    goto out;

1318

1319

465

  p = type;

1320

465

  dbus_message_iter_init_append (msg, &iter);

1321

465

  dbind_any_marshal_va (&iter, &p, args);

1322

1323

465

  set_timeout (aobj->app);

1324

465

  reply = dbind_send_and_allow_reentry (aobj->app->bus, msg, &err);

1325

465

  check_for_hang (reply, &err, aobj->app->bus, aobj->app->bus_name);

1326

465

out:

1327

465

  if (msg)

1328

465

    dbus_message_unref (msg);

1329

465

  process_deferred_messages ();

1330

465

  if (dbus_error_is_set (&err))

1331

1332

      /* TODO: Set gerror */

1333

      dbus_error_free (&err);

1334

1335

1336

465

  if (reply && dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)

1337

1338

      const char *err_str = NULL;

1339

      dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &err_str, DBUS_TYPE_INVALID);

1340

      if (err_str)

1341

        g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_IPC, err_str);

1342

      dbus_message_unref (reply);

1343

      return NULL;

1344

1345

1346

465

  return reply;

1347

1348

1349

/* Makes a DBus call but returns the raw DBusMessage reply.  Use this

1350

 * when you need to demarshal complex return values by hand.  Remember

1351

 * to dbus_message_unref() the return value when you are done.

1352

*/

1353

DBusMessage *

1354

465

_atspi_dbus_call_partial (gpointer obj,

1355

                          const char *interface,

1356

                          const char *method,

1357

                          GError **error,

1358

                          const char *type,

1359

                          ...)

1360

1361

  DBusMessage *ret;

1362

  va_list args;

1363

1364

465

  va_start (args, type);

1365

465

  ret = _atspi_dbus_call_partial_va (obj, interface, method, error, type, args);

1366

465

  va_end (args);

1367

1368

465

  return ret;

1369

1370

1371

dbus_bool_t

1372

375

_atspi_dbus_get_property (gpointer obj, const char *interface, const char *name, GError **error, const char *type, void *data)

1373

1374

  DBusMessage *message, *reply;

1375

  DBusMessageIter iter, iter_variant;

1376

  DBusError err;

1377

375

  dbus_bool_t retval = FALSE;

1378

375

  AtspiObject *aobj = ATSPI_OBJECT (obj);

1379

375

  char expected_type = (type[0] == '(' ? 'r' : type[0]);

1380

1381

375

  if (!aobj)

1382

    return FALSE;

1383

1384

375

  if (!check_app (aobj->app, error))

1385

    return FALSE;

1386

1387

375

  message = dbus_message_new_method_call (aobj->app->bus_name,

1388

375

                                          aobj->path,

1389

                                          "org.freedesktop.DBus.Properties",

1390

                                          "Get");

1391

375

  if (!message)

1392

1393

      // TODO: throw exception

1394

      return FALSE;

1395

1396

375

  dbus_message_append_args (message, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);

1397

375

  dbus_error_init (&err);

1398

375

  set_timeout (aobj->app);

1399

375

  reply = dbind_send_and_allow_reentry (aobj->app->bus, message, &err);

1400

375

  check_for_hang (reply, &err, aobj->app->bus, aobj->app->bus_name);

1401

375

  dbus_message_unref (message);

1402

375

  process_deferred_messages ();

1403

375

  if (!reply)

1404

1405

      /* TODO: throw exception */

1406

      goto done;

1407

1408

1409

375

  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)

1410

1411

      const char *err_str = NULL;

1412

      dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &err_str, DBUS_TYPE_INVALID);

1413

      if (err_str)

1414

        g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_IPC, err_str);

1415

      goto done;

1416

1417

1418

375

  dbus_message_iter_init (reply, &iter);

1419

375

  if (dbus_message_iter_get_arg_type (&iter) != 'v')

1420

1421

      g_warning ("atspi_dbus_get_property: expected a variant when fetching %s:%s; got %s instead", interface, name, dbus_message_get_signature (reply));

1422

      goto done;

1423

1424

375

  dbus_message_iter_recurse (&iter, &iter_variant);

1425

375

  if (dbus_message_iter_get_arg_type (&iter_variant) != expected_type)

1426

1427

      g_warning ("atspi_dbus_get_property: Wrong type: expected %s when fetching %s:%s; got %c instead", type, interface, name, dbus_message_iter_get_arg_type (&iter_variant));

1428

      goto done;

1429

1430

375

  if (!strcmp (type, "(so)"))

1431

1432

3

      *((AtspiAccessible **) data) = _atspi_dbus_consume_accessible (&iter_variant);

1433

1434

  else

1435

1436

372

      if (type[0] == 's')

1437

1438

174

          *(char **) data = NULL;

1439

1440

1441

372

      dbus_message_iter_get_basic (&iter_variant, data);

1442

372

      if (type[0] == 's')

1443

348

        *(char **) data = g_strdup (*(char **) data);

1444

1445

375

  retval = TRUE;

1446

375

done:

1447

375

  dbus_error_free (&err);

1448

375

  if (reply)

1449

375

    dbus_message_unref (reply);

1450

375

  return retval;

1451

1452

1453

DBusMessage *

1454

16

_atspi_dbus_send_with_reply_and_block (DBusMessage *message, GError **error)

1455

1456

  DBusMessage *reply;

1457

  DBusError err;

1458

  AtspiApplication *app;

1459

  DBusConnection *bus;

1460

1461

16

  app = get_application (dbus_message_get_destination (message));

1462

1463

16

  if (app && !app->bus)

1464

    return NULL; /* will fail anyway; app has been disposed */

1465

1466

16

  bus = (app ? app->bus : _atspi_bus ());

1467

16

  dbus_error_init (&err);

1468

16

  set_timeout (app);

1469

16

  reply = dbind_send_and_allow_reentry (bus, message, &err);

1470

16

  process_deferred_messages ();

1471

16

  dbus_message_unref (message);

1472

16

  if (dbus_error_is_set (&err))

1473

1474

      if (error)

1475

        g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_IPC, err.message);

1476

      dbus_error_free (&err);

1477

1478

16

  return reply;

1479

1480

1481

GHashTable *

1482

3

_atspi_dbus_return_hash_from_message (DBusMessage *message)

1483

1484

  DBusMessageIter iter;

1485

  GHashTable *ret;

1486

1487

3

  if (!message)

1488

    return NULL;

1489

1490

3

  _ATSPI_DBUS_CHECK_SIG (message, "a{ss}", NULL, NULL);

1491

1492

3

  dbus_message_iter_init (message, &iter);

1493

3

  ret = _atspi_dbus_hash_from_iter (&iter);

1494

3

  dbus_message_unref (message);

1495

3

  return ret;

1496

1497

1498

GHashTable *

1499

5

_atspi_dbus_hash_from_iter (DBusMessageIter *iter)

1500

1501

5

  GHashTable *hash = g_hash_table_new_full (g_str_hash, g_str_equal,

1502

                                            (GDestroyNotify) g_free,

1503

                                            (GDestroyNotify) g_free);

1504

  DBusMessageIter iter_array, iter_dict;

1505

1506

5

  dbus_message_iter_recurse (iter, &iter_array);

1507

16

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

1508

1509

      const char *name, *value;

1510

11

      dbus_message_iter_recurse (&iter_array, &iter_dict);

1511

11

      dbus_message_iter_get_basic (&iter_dict, &name);

1512

11

      dbus_message_iter_next (&iter_dict);

1513

11

      dbus_message_iter_get_basic (&iter_dict, &value);

1514

22

      g_hash_table_insert (hash, g_strdup (name), g_strdup (value));

1515

11

      dbus_message_iter_next (&iter_array);

1516

1517

5

  return hash;

1518

1519

1520

GArray *

1521

1

_atspi_dbus_return_attribute_array_from_message (DBusMessage *message)

1522

1523

  DBusMessageIter iter;

1524

  GArray *ret;

1525

1526

1

  if (!message)

1527

    return NULL;

1528

1529

1

  _ATSPI_DBUS_CHECK_SIG (message, "a{ss}", NULL, NULL);

1530

1531

1

  dbus_message_iter_init (message, &iter);

1532

1533

1

  ret = _atspi_dbus_attribute_array_from_iter (&iter);

1534

1

  dbus_message_unref (message);

1535

1

  return ret;

1536

1537

1538

GArray *

1539

1

_atspi_dbus_attribute_array_from_iter (DBusMessageIter *iter)

1540

1541

  DBusMessageIter iter_array, iter_dict;

1542

1

  GArray *array = g_array_new (TRUE, TRUE, sizeof (gchar *));

1543

1544

1

  dbus_message_iter_recurse (iter, &iter_array);

1545

3

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

1546

1547

      const char *name, *value;

1548

      gchar *str;

1549

2

      dbus_message_iter_recurse (&iter_array, &iter_dict);

1550

2

      dbus_message_iter_get_basic (&iter_dict, &name);

1551

2

      dbus_message_iter_next (&iter_dict);

1552

2

      dbus_message_iter_get_basic (&iter_dict, &value);

1553

2

      str = g_strdup_printf ("%s:%s", name, value);

1554

2

      array = g_array_append_val (array, str);

1555

2

      dbus_message_iter_next (&iter_array);

1556

1557

1558

1

  return array;

1559

1560

1561

typedef enum

1562

1563

  DEMARSHAL_STATUS_SUCCESS,

1564

  DEMARSHAL_STATUS_INVALID_SIGNATURE,

1565

  DEMARSHAL_STATUS_INVALID_VALUE,

1566

} DemarshalStatus;

1567

1568

typedef struct

1569

1570

  /* array of (char *) */

1571

  GPtrArray *names;

1572

} InterfaceNames;

1573

1574

static DemarshalStatus

1575

1506

interface_names_demarshal (DBusMessageIter *iter, InterfaceNames **out_interfaces)

1576

1577

1506

  char *sig = dbus_message_iter_get_signature (iter);

1578

1506

  gboolean matches = strcmp (sig, "as") == 0;

1579

1506

  dbus_free (sig);

1580

1581

1506

  *out_interfaces = NULL;

1582

1583

1506

  GPtrArray *names = g_ptr_array_new_with_free_func (g_free);

1584

1585

1506

  if (!matches)

1586

1587

      return DEMARSHAL_STATUS_INVALID_SIGNATURE;

1588

1589

1590

  DBusMessageIter iter_array;

1591

1506

  dbus_message_iter_recurse (iter, &iter_array);

1592

5215

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

1593

1594

      const char *iface;

1595

3709

      dbus_message_iter_get_basic (&iter_array, &iface);

1596

7418

      g_ptr_array_add (names, g_strdup (iface));

1597

3709

      dbus_message_iter_next (&iter_array);

1598

1599

1600

1506

  InterfaceNames *ifaces = g_new0 (InterfaceNames, 1);

1601

1506

  ifaces->names = names;

1602

1506

  *out_interfaces = ifaces;

1603

1506

  return DEMARSHAL_STATUS_SUCCESS;

1604

1605

1606

/* Converts an array of interface names to a value suitable for AtspiAccessible.interfaces */

1607

static gint

1608

1506

interface_names_to_bitmask (const InterfaceNames *ifaces)

1609

1610

1506

  gint val = 0;

1611

  guint i;

1612

1613

1506

  g_assert (ifaces->names != NULL);

1614

1615

5215

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

1616

1617

3709

      const char *name = g_ptr_array_index (ifaces->names, i);

1618

3709

      gint iface_num = _atspi_get_iface_num (name);

1619

3709

      if (iface_num == -1)

1620

1621

          g_warning ("AT-SPI: Unknown interface %s", name);

1622

1623

      else

1624

1625

3709

          val |= (1 << iface_num);

1626

1627

1628

1629

1506

  return val;

1630

1631

1632

static void

1633

1506

interface_names_free (InterfaceNames *ifaces)

1634

1635

1506

  g_ptr_array_free (ifaces->names, TRUE);

1636

1506

  g_free (ifaces);

1637

1506

1638

1639

void

1640

1506

_atspi_dbus_set_interfaces (AtspiAccessible *accessible, DBusMessageIter *iter)

1641

1642

  InterfaceNames *ifaces;

1643

1644

1506

  accessible->interfaces = 0;

1645

1646

1506

  if (interface_names_demarshal (iter, &ifaces) != DEMARSHAL_STATUS_SUCCESS)

1647

1648

      g_warning ("Passed iterator with invalid signature");

1649

      return;

1650

1651

1652

1506

  accessible->interfaces = interface_names_to_bitmask (ifaces);

1653

1506

  interface_names_free (ifaces);

1654

1655

1506

  _atspi_accessible_add_cache (accessible, ATSPI_CACHE_INTERFACES);

1656

1657

1658

void

1659

1395

_atspi_dbus_set_state (AtspiAccessible *accessible, DBusMessageIter *iter)

1660

1661

  DBusMessageIter iter_array;

1662

  gint count;

1663

  dbus_uint32_t *states;

1664

1665

1395

  dbus_message_iter_recurse (iter, &iter_array);

1666

1395

  dbus_message_iter_get_fixed_array (&iter_array, &states, &count);

1667

1395

  if (count != 2)

1668

1669

      g_warning ("AT-SPI: expected 2 values in states array; got %d\n", count);

1670

      if (!accessible->states)

1671

        accessible->states = _atspi_state_set_new_internal (accessible, 0);

1672

1673

  else

1674

1675

1395

      guint64 val = ((guint64) states[1]) << 32;

1676

1395

      val += states[0];

1677

1395

      if (!accessible->states)

1678

1384

        accessible->states = _atspi_state_set_new_internal (accessible, val);

1679

      else

1680

11

        accessible->states->states = val;

1681

1682

1395

  _atspi_accessible_add_cache (accessible, ATSPI_CACHE_STATES);

1683

1395

1684

1685

GQuark

1686

_atspi_error_quark (void)

1687

1688

  return g_quark_from_static_string ("atspi_error");

1689

1690

1691

/*

1692

 * Gets the IOR from the XDisplay.

1693

*/

1694

#ifdef HAVE_X11

1695

/*

1696

 * Returns a 'canonicalized' value for DISPLAY,

1697

 * with the screen number stripped off if present.

1698

1699

 * TODO: Avoid having duplicate functions for this here and in at-spi2-atk

1700

*/

1701

static gchar *

1702

191

spi_display_name (void)

1703

1704

191

  char *canonical_display_name = NULL;

1705

191

  const gchar *display_env = g_getenv ("AT_SPI_DISPLAY");

1706

1707

191

  if (!display_env)

1708

1709

191

      display_env = g_getenv ("DISPLAY");

1710

191

      if (!display_env || !display_env[0])

1711

        return NULL;

1712

      else

1713

1714

          gchar *display_p, *screen_p;

1715

191

          canonical_display_name = g_strdup (display_env);

1716

191

          display_p = g_utf8_strrchr (canonical_display_name, -1, ':');

1717

191

          screen_p = g_utf8_strrchr (canonical_display_name, -1, '.');

1718

191

          if (screen_p && display_p && (screen_p > display_p))

1719

1720

              *screen_p = '\0';

1721

1722

1723

1724

  else

1725

1726

      canonical_display_name = g_strdup (display_env);

1727

1728

1729

191

  return canonical_display_name;

1730

1731

1732

static char *

1733

191

get_accessibility_bus_address_x11 (void)

1734

1735

  Atom AT_SPI_BUS;

1736

  Atom actual_type;

1737

191

  Display *bridge_display = NULL;

1738

  int actual_format;

1739

  char *data;

1740

191

  unsigned char *data_x11 = NULL;

1741

  unsigned long nitems;

1742

  unsigned long leftover;

1743

  char *display_name;

1744

1745

191

  display_name = spi_display_name ();

1746

191

  if (!display_name)

1747

    return NULL;

1748

1749

191

  bridge_display = XOpenDisplay (display_name);

1750

191

  g_free (display_name);

1751

1752

191

  if (!bridge_display)

1753

1754

      g_warning ("Could not open X display");

1755

      return NULL;

1756

1757

1758

191

  AT_SPI_BUS = XInternAtom (bridge_display, "AT_SPI_BUS", False);

1759

191

  XGetWindowProperty (bridge_display,

1760

                      XDefaultRootWindow (bridge_display),

1761

                      AT_SPI_BUS, 0L,

1762

                      (long) BUFSIZ, False,

1763

                      (Atom) 31, &actual_type, &actual_format,

1764

                      &nitems, &leftover, &data_x11);

1765

191

  XCloseDisplay (bridge_display);

1766

1767

191

  data = g_strdup ((gchar *) data_x11);

1768

191

  XFree (data_x11);

1769

191

  return data;

1770

1771

#endif

1772

1773

static char *

1774

191

get_accessibility_bus_address_dbus (void)

1775

1776

191

  DBusConnection *session_bus = NULL;

1777

  DBusMessage *message;

1778

  DBusMessage *reply;

1779

  DBusError error;

1780

191

  char *address = NULL;

1781

1782

191

  session_bus = dbus_bus_get (DBUS_BUS_SESSION, NULL);

1783

191

  if (!session_bus)

1784

    return NULL;

1785

1786

191

  message = dbus_message_new_method_call ("org.a11y.Bus",

1787

                                          "/org/a11y/bus",

1788

                                          "org.a11y.Bus",

1789

                                          "GetAddress");

1790

1791

191

  dbus_error_init (&error);

1792

191

  reply = dbus_connection_send_with_reply_and_block (session_bus,

1793

                                                     message,

1794

-1,

1795

                                                     &error);

1796

191

  dbus_message_unref (message);

1797

1798

191

  if (!reply)

1799

1800

      g_warning ("AT-SPI: Error retrieving accessibility bus address: %s: %s",

1801

                 error.name, error.message);

1802

      dbus_error_free (&error);

1803

      goto out;

1804

1805

1806

1807

    const char *tmp_address;

1808

191

    if (!dbus_message_get_args (reply,

1809

                                NULL,

1810

                                DBUS_TYPE_STRING,

1811

                                &tmp_address,

1812

                                DBUS_TYPE_INVALID))

1813

1814

        dbus_message_unref (reply);

1815

        goto out;

1816

1817

191

    address = g_strdup (tmp_address);

1818

191

    dbus_message_unref (reply);

1819

1820

1821

191

out:

1822

191

  dbus_connection_unref (session_bus);

1823

191

  return address;

1824

1825

1826

static DBusConnection *a11y_bus;

1827

static dbus_int32_t a11y_dbus_slot = -1;

1828

1829

static void

1830

191

a11y_bus_free (void *data)

1831

1832

191

  if (data == a11y_bus)

1833

1834

191

      a11y_bus = NULL;

1835

191

      dbus_connection_free_data_slot (&a11y_dbus_slot);

1836

1837

191

1838

1839

/**

1840

 * atspi_get_a11y_bus: (skip)

1841

*/

1842

DBusConnection *

1843

191

atspi_get_a11y_bus (void)

1844

1845

  DBusError error;

1846

191

  char *address = NULL;

1847

191

  const char *address_env = NULL;

1848

1849

191

  if (a11y_bus && dbus_connection_get_is_connected (a11y_bus))

1850

    return a11y_bus;

1851

1852

191

  if (a11y_dbus_slot == -1)

1853

191

    if (!dbus_connection_allocate_data_slot (&a11y_dbus_slot))

1854

      g_warning ("AT-SPI: Unable to allocate D-Bus slot");

1855

1856

191

  address_env = g_getenv ("AT_SPI_BUS_ADDRESS");

1857

191

  if (address_env != NULL && *address_env != 0)

1858

    address = g_strdup (address_env);

1859

#ifdef HAVE_X11

1860

382

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

1861

191

      g_getenv ("WAYLAND_DISPLAY") == NULL)

1862

191

    address = get_accessibility_bus_address_x11 ();

1863

#endif

1864

191

  if (!address)

1865

191

    address = get_accessibility_bus_address_dbus ();

1866

191

  if (!address)

1867

    return NULL;

1868

1869

191

  dbus_error_init (&error);

1870

191

  a11y_bus = dbus_connection_open_private (address, &error);

1871

191

  g_free (address);

1872

1873

191

  if (!a11y_bus)

1874

1875

      if (!g_getenv ("SSH_CONNECTION"))

1876

        g_warning ("Couldn't connect to accessibility bus: %s", error.message);

1877

      dbus_error_free (&error);

1878

      return NULL;

1879

1880

  else

1881

1882

191

      if (!dbus_bus_register (a11y_bus, &error))

1883

1884

          g_warning ("Couldn't register with accessibility bus: %s", error.message);

1885

          dbus_error_free (&error);

1886

          dbus_connection_close (a11y_bus);

1887

          dbus_connection_unref (a11y_bus);

1888

          a11y_bus = NULL;

1889

          return NULL;

1890

1891

1892

1893

  /* Simulate a weak ref on the bus */

1894

191

  dbus_connection_set_data (a11y_bus, a11y_dbus_slot, a11y_bus, a11y_bus_free);

1895

1896

191

  return a11y_bus;

1897

1898

1899

/**

1900

 * atspi_set_timeout:

1901

 * @val: The timeout value, in milliseconds, or -1 to disable the timeout.

1902

 * @startup_time: The amount of time, in milliseconds, to allow to pass

1903

 * before enforcing timeouts on an application. Can be used to prevent

1904

 * timeout exceptions if an application is likely to block for an extended

1905

 * period of time on initialization. -1 can be passed to disable this

1906

 * behavior.

1907

1908

 * Set the timeout used for method calls. If this is not set explicitly,

1909

 * a default of 800 ms is used.

1910

 * Note that at-spi2-registryd currently uses a timeout of 3 seconds when

1911

 * sending a keyboard event notification. This means that, if an AT makes

1912

 * a call in response to the keyboard notification and the application

1913

 * being called does not respond before the timeout is reached,

1914

 * at-spi2-registryd will time out on the keyboard event notification and

1915

 * pass the key onto the application (ie, reply to indicate that the key

1916

 * was not consumed), so this may make it undesirable to set a timeout

1917

 * larger than 3 seconds.

1918

1919

 * By default, the normal timeout is set to 800 ms, and the application startup

1920

 * timeout is set to 15 seconds.

1921

*/

1922

void

1923

atspi_set_timeout (gint val, gint startup_time)

1924

1925

  method_call_timeout = val;

1926

  app_startup_time = startup_time;

1927

1928

1929

/**

1930

 * atspi_set_main_context:

1931

 * @cnx: The #GMainContext to use.

1932

1933

 * Sets the main loop context that AT-SPI should assume is in use when

1934

 * setting an idle callback.

1935

 * This function should be called by application-side implementors (ie,

1936

 * at-spi2-atk) when it is desirable to re-enter the main loop.

1937

*/

1938

void

1939

atspi_set_main_context (GMainContext *cnx)

1940

1941

  if (atspi_main_context == cnx)

1942

    return;

1943

  if (process_deferred_messages_source != NULL)

1944

1945

      g_source_destroy (process_deferred_messages_source);

1946

      process_deferred_messages_source = g_idle_source_new ();

1947

      g_source_set_callback (process_deferred_messages_source,

1948

                             process_deferred_messages_callback, NULL, NULL);

1949

      g_source_attach (process_deferred_messages_source, cnx);

1950

      g_source_unref (process_deferred_messages_source);

1951

1952

  atspi_main_context = cnx;

1953

  atspi_dbus_connection_setup_with_g_main (atspi_get_a11y_bus (), cnx);

1954

1955

  if (desktop)

1956

1957

      gint i;

1958

      for (i = desktop->children->len - 1; i >= 0; i--)

1959

1960

          AtspiAccessible *child = g_ptr_array_index (desktop->children, i);

1961

          if (child->parent.app && child->parent.app->bus)

1962

            atspi_dbus_connection_setup_with_g_main (child->parent.app->bus, cnx);

1963

1964

1965

1966

1967

#ifdef DEBUG_REF_COUNTS

1968

static void

1969

print_disposed (gpointer key, gpointer value, gpointer data)

1970

1971

  AtspiAccessible *accessible = key;

1972

  if (accessible->parent.app)

1973

    return;

1974

  g_print ("disposed: %s %d\n", accessible->name, accessible->role);

1975

1976

1977

void

1978

debug_disposed ()

1979

1980

  g_hash_table_foreach (live_refs, print_disposed, NULL);

1981

1982

#endif

1983

1984

gchar *

1985

2

_atspi_name_compat (gchar *name)

1986

1987

2

  gchar *p = name;

1988

1989

36

  while (*p)

1990

1991

34

      if (*p == '-')

1992

2

        *p = ' ';

1993

34

      p++;

1994

1995

2

  return name;

1996

1997

1998

/**

1999

 * atspi_role_get_name:

2000

 * @role: an #AtspiRole object to query.

2001

2002

 * Gets a localizable string that indicates the name of an #AtspiRole.

2003

2004

 * Returns: a localizable string name for an #AtspiRole enumerated type.

2005

**/

2006

gchar *

2007

2

atspi_role_get_name (AtspiRole role)

2008

2009

2

  gchar *retval = NULL;

2010

  GTypeClass *type_class;

2011

  GEnumValue *value;

2012

2013

2

  type_class = g_type_class_ref (ATSPI_TYPE_ROLE);

2014

2

  g_return_val_if_fail (G_IS_ENUM_CLASS (type_class), NULL);

2015

2016

2

  value = g_enum_get_value (G_ENUM_CLASS (type_class), role);

2017

2018

2

  if (value)

2019

2020

4

      retval = g_strdup (value->value_nick);

2021

2022

2023

2

  g_type_class_unref (type_class);

2024

2025

2

  if (retval)

2026

2

    return _atspi_name_compat (retval);

2027

2028

  return NULL;

2029

2030

2031

/**

2032

 * atspi_role_get_localized_name:

2033

 * @role: an #AtspiRole object to query.

2034

2035

 * Gets the localized description string describing the #AtspiRole @role.

2036

2037

 * Returns: the localized string describing the AtspiRole

2038

**/

2039

gchar *

2040

1

atspi_role_get_localized_name (AtspiRole role)

2041

2042

1

  gchar *raw_name = NULL;

2043

  const char *translated_name;

2044

2045

1

  _gettext_initialization ();

2046

2047

1

  raw_name = atspi_role_get_name (role);

2048

1

  translated_name = dgettext (GETTEXT_PACKAGE, raw_name);

2049

1

  if (translated_name != raw_name)

2050

2051

      g_free (raw_name);

2052

      return g_strdup (translated_name);

2053

2054

  else

2055

1

    return raw_name;

2056

2057

2058

GHashTable *

2059

323

_atspi_dbus_update_cache_from_dict (AtspiAccessible *accessible, DBusMessageIter *iter)

2060

2061

323

  GHashTable *cache = _atspi_accessible_ref_cache (accessible);

2062

  DBusMessageIter iter_dict, iter_dict_entry, iter_struct, iter_variant;

2063

2064

323

  dbus_message_iter_recurse (iter, &iter_dict);

2065

323

  while (dbus_message_iter_get_arg_type (&iter_dict) != DBUS_TYPE_INVALID)

2066

2067

      const char *key;

2068

      GValue *val = NULL;

2069

      dbus_message_iter_recurse (&iter_dict, &iter_dict_entry);

2070

      dbus_message_iter_get_basic (&iter_dict_entry, &key);

2071

      dbus_message_iter_next (&iter_dict_entry);

2072

      dbus_message_iter_recurse (&iter_dict_entry, &iter_variant);

2073

      if (!strcmp (key, "interfaces"))

2074

2075

          _atspi_dbus_set_interfaces (accessible, &iter_variant);

2076

2077

      else if (!strcmp (key, "Attributes"))

2078

2079

          char *iter_sig = dbus_message_iter_get_signature (&iter_variant);

2080

          val = g_new0 (GValue, 1);

2081

2082

          g_value_init (val, G_TYPE_HASH_TABLE);

2083

          if (strcmp (iter_sig, "a{ss}") != 0)

2084

2085

              dbus_free (iter_sig);

2086

              break;

2087

2088

          dbus_free (iter_sig);

2089

          g_value_take_boxed (val, _atspi_dbus_hash_from_iter (&iter_variant));

2090

2091

      else if (!strcmp (key, "Component.ScreenExtents"))

2092

2093

          dbus_int32_t d_int;

2094

          AtspiRect extents;

2095

          char *iter_sig = dbus_message_iter_get_signature (&iter_variant);

2096

          val = g_new0 (GValue, 1);

2097

2098

          g_value_init (val, ATSPI_TYPE_RECT);

2099

          if (strcmp (iter_sig, "(iiii)") != 0)

2100

2101

              dbus_free (iter_sig);

2102

              break;

2103

2104

          dbus_free (iter_sig);

2105

          dbus_message_iter_recurse (&iter_variant, &iter_struct);

2106

          dbus_message_iter_get_basic (&iter_struct, &d_int);

2107

          extents.x = d_int;

2108

          dbus_message_iter_next (&iter_struct);

2109

          dbus_message_iter_get_basic (&iter_struct, &d_int);

2110

          extents.y = d_int;

2111

          dbus_message_iter_next (&iter_struct);

2112

          dbus_message_iter_get_basic (&iter_struct, &d_int);

2113

          extents.width = d_int;

2114

          dbus_message_iter_next (&iter_struct);

2115

          dbus_message_iter_get_basic (&iter_struct, &d_int);

2116

          extents.height = d_int;

2117

          g_value_set_boxed (val, &extents);

2118

2119

      if (val)

2120

        g_hash_table_insert (cache, g_strdup (key), val);

2121

      dbus_message_iter_next (&iter_dict);

2122

2123

2124

323

  return cache;

2125

2126

2127

static const char *sr_introspection = "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"

2128

                                      "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"

2129

                                      "<node name=\"/org/a11y/atspi/screenreader\">\n"

2130

                                      "  <interface name=\"org.a11y.Atspi.ScreenReader\">\n"

2131

                                      "    <signal name=\"ReadingPosition\">\n"

2132

                                      "      <arg type=\"i\"/>\n"

2133

                                      "      <arg type=\"i\"/>\n"

2134

                                      "    </signal>\n"

2135

                                      "  </interface>\n"

2136

                                      "</node>";

2137

2138

static DBusHandlerResult

2139

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

2140

2141

  if (dbus_message_is_method_call (message, DBUS_INTERFACE_INTROSPECTABLE,

2142

                                   "Introspect"))

2143

2144

      DBusMessage *reply = dbus_message_new_method_return (message);

2145

      dbus_message_append_args (reply, DBUS_TYPE_STRING, &sr_introspection,

2146

                                DBUS_TYPE_INVALID);

2147

      dbus_connection_send (bus, reply, NULL);

2148

      dbus_message_unref (reply);

2149

      return DBUS_HANDLER_RESULT_HANDLED;

2150

2151

  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

2152

2153

2154

gboolean

2155

_atspi_prepare_screen_reader_interface ()

2156

2157

  static gint initialized = 0;

2158

  DBusConnection *a11y_bus = _atspi_bus ();

2159

2160

  if (initialized)

2161

    return (initialized > 0);

2162

2163

  if (dbus_bus_request_name (a11y_bus, "org.a11y.Atspi.ScreenReader", 0, NULL) < 0)

2164

2165

      initialized = -1;

2166

      return FALSE;

2167

2168

2169

  initialized = 1;

2170

  dbus_connection_add_filter (a11y_bus, screen_reader_filter, NULL, NULL);

2171

  return TRUE;

2172

2173

2174

gchar *

2175

3480

_atspi_strdup_and_adjust_for_dbus (const char *s)

2176

2177

3480

  gchar *d = g_strdup (s);

2178

  gchar *p;

2179

3480

  int parts = 0;

2180

2181

3480

  if (!d)

2182

    return NULL;

2183

2184

70575

  for (p = d; *p; p++)

2185

2186

70573

      if (*p == '-')

2187

2188

3480

          memmove (p, p + 1, g_utf8_strlen (p, -1));

2189

3480

          *p = toupper (*p);

2190

2191

67093

      else if (*p == ':')

2192

2193

6958

          parts++;

2194

6958

          if (parts == 2)

2195

3478

            break;

2196

3480

          p[1] = toupper (p[1]);

2197

2198

2199

2200

3480

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

2201

3480

  return d;

2202

2203

2204

/**

2205

 * atspi_get_version:

2206

 * @major: (out): the major version.

2207

 * @minor: (out): the minor version.

2208

 * @micro: (out): the micro/patch version.

2209

2210

 * Returns the version of the AT-SPI library being used at runtime.

2211

2212

* Since: 2.50

2213

*/

2214

void

2215

atspi_get_version (gint *major, gint *minor, gint *micro)

2216

2217

  if (major)

2218

    *major = ATSPI_MAJOR_VERSION;

2219

  if (minor)

2220

    *minor = ATSPI_MINOR_VERSION;

2221

  if (micro)

2222

    *micro = ATSPI_MICRO_VERSION;

2223

2224

2225

gboolean

2226

_atspi_key_is_on_keypad (gint keycode)

2227

2228

  switch (keycode)

2229

2230

    case 106: /* / */

2231

    case 63:  /* * */

2232

    case 82:  /* - */

2233

    case 79:  /* 7 */

2234

    case 80:  /* 8 */

2235

    case 91:  /* 9 */

2236

    case 86:  /* + */

2237

    case 83:  /* 4 */

2238

    case 84:  /* 5 */

2239

    case 85:  /* 6 */

2240

    case 87:  /* 1 */

2241

    case 88:  /* 2 */

2242

    case 89:  /* 3 */

2243

    case 104: /* enter */

2244

    case 90:  /* 0 */

2245

    case 81:  /* . */

2246

      return TRUE;

2247

    default:

2248

      return FALSE;

2249

2250