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_("push 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_("table")

106

  N_("table cell")

107

  N_("table column header")

108

  N_("table row header")

109

  N_("tear off menu item")

110

  N_("terminal")

111

  N_("text")

112

  N_("toggle button")

113

  N_("tool bar")

114

  N_("tool tip")

115

  N_("tree")

116

  N_("tree table")

117

  N_("unknown")

118

  N_("viewport")

119

  N_("window")

120

  N_("header")

121

  N_("footer")

122

  N_("paragraph")

123

  N_("ruler")

124

  N_("application")

125

  N_("autocomplete")

126

  N_("edit bar")

127

  N_("embedded component")

128

  N_("entry")

129

  N_("chart")

130

  N_("caption")

131

  N_("document frame")

132

  N_("heading")

133

  N_("page")

134

  N_("section")

135

  N_("redundant object")

136

  N_("form")

137

  N_("link")

138

  N_("input method window")

139

  N_("table row")

140

  N_("tree item")

141

  N_("document spreadsheet")

142

  N_("document presentation")

143

  N_("document text")

144

  N_("document web")

145

  N_("document email")

146

  N_("comment")

147

  N_("list box")

148

  N_("grouping")

149

  N_("image map")

150

  N_("notification")

151

  N_("info bar")

152

  N_("level bar")

153

  N_("title bar")

154

  N_("block quote")

155

  N_("audio")

156

  N_("video")

157

  N_("definition")

158

  N_("article")

159

  N_("landmark")

160

  N_("log")

161

  N_("marquee")

162

  N_("math")

163

  N_("rating")

164

  N_("timer")

165

  N_("description list")

166

  N_("description term")

167

  N_("description value")

168

#endif /* 0 */

169

170

static void

171

1

_gettext_initialization (void)

172

173

  static gboolean gettext_initialized = FALSE;

174

175

1

  if (!gettext_initialized)

176

177

1

      gettext_initialized = TRUE;

178

1

      setlocale (LC_ALL, "");

179

1

      bindtextdomain (GETTEXT_PACKAGE, ATSPI_LOCALEDIR);

180

1

      bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

181

182

1

183

184

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

185

186

static DBusConnection *bus = NULL;

187

static GHashTable *live_refs = NULL;

188

static gint method_call_timeout = 800;

189

static gint app_startup_time = 15000;

190

191

GMainLoop *atspi_main_loop;

192

GMainContext *atspi_main_context;

193

gboolean atspi_no_cache;

194

195

const char *atspi_path_dec = ATSPI_DBUS_PATH_DEC;

196

const char *atspi_path_registry = ATSPI_DBUS_PATH_REGISTRY;

197

const char *atspi_path_root = ATSPI_DBUS_PATH_ROOT;

198

const char *atspi_bus_registry = ATSPI_DBUS_NAME_REGISTRY;

199

const char *atspi_interface_accessible = ATSPI_DBUS_INTERFACE_ACCESSIBLE;

200

const char *atspi_interface_action = ATSPI_DBUS_INTERFACE_ACTION;

201

const char *atspi_interface_application = ATSPI_DBUS_INTERFACE_APPLICATION;

202

const char *atspi_interface_collection = ATSPI_DBUS_INTERFACE_COLLECTION;

203

const char *atspi_interface_component = ATSPI_DBUS_INTERFACE_COMPONENT;

204

const char *atspi_interface_dec = ATSPI_DBUS_INTERFACE_DEC;

205

const char *atspi_interface_device_event_listener = ATSPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER;

206

const char *atspi_interface_document = ATSPI_DBUS_INTERFACE_DOCUMENT;

207

const char *atspi_interface_editable_text = ATSPI_DBUS_INTERFACE_EDITABLE_TEXT;

208

const char *atspi_interface_event_object = ATSPI_DBUS_INTERFACE_EVENT_OBJECT;

209

const char *atspi_interface_hyperlink = ATSPI_DBUS_INTERFACE_HYPERLINK;

210

const char *atspi_interface_hypertext = ATSPI_DBUS_INTERFACE_HYPERTEXT;

211

const char *atspi_interface_image = ATSPI_DBUS_INTERFACE_IMAGE;

212

const char *atspi_interface_registry = ATSPI_DBUS_INTERFACE_REGISTRY;

213

const char *atspi_interface_selection = ATSPI_DBUS_INTERFACE_SELECTION;

214

const char *atspi_interface_table = ATSPI_DBUS_INTERFACE_TABLE;

215

const char *atspi_interface_table_cell = ATSPI_DBUS_INTERFACE_TABLE_CELL;

216

const char *atspi_interface_text = ATSPI_DBUS_INTERFACE_TEXT;

217

const char *atspi_interface_cache = ATSPI_DBUS_INTERFACE_CACHE;

218

const char *atspi_interface_value = ATSPI_DBUS_INTERFACE_VALUE;

219

220

static const char *interfaces[] = {

221

  ATSPI_DBUS_INTERFACE_ACCESSIBLE,

222

  ATSPI_DBUS_INTERFACE_ACTION,

223

  ATSPI_DBUS_INTERFACE_APPLICATION,

224

  ATSPI_DBUS_INTERFACE_COLLECTION,

225

  ATSPI_DBUS_INTERFACE_COMPONENT,

226

  ATSPI_DBUS_INTERFACE_DOCUMENT,

227

  ATSPI_DBUS_INTERFACE_EDITABLE_TEXT,

228

  ATSPI_DBUS_INTERFACE_HYPERLINK,

229

  ATSPI_DBUS_INTERFACE_HYPERTEXT,

230

  ATSPI_DBUS_INTERFACE_IMAGE,

231

  ATSPI_DBUS_INTERFACE_SELECTION,

232

  ATSPI_DBUS_INTERFACE_SOCKET,

233

  ATSPI_DBUS_INTERFACE_TABLE,

234

  ATSPI_DBUS_INTERFACE_TABLE_CELL,

235

  ATSPI_DBUS_INTERFACE_TEXT,

236

  ATSPI_DBUS_INTERFACE_VALUE,

237

  NULL

238

};

239

240

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

241

 * of the DBusMessage that is being processed.

242

*/

243

typedef struct

244

245

  const char *app_name;

246

  const char *path;

247

} ReferenceFromMessage;

248

249

static void

250

3516

get_reference_from_iter (DBusMessageIter *iter, ReferenceFromMessage *ref)

251

252

  DBusMessageIter iter_struct;

253

254

3516

  dbus_message_iter_recurse (iter, &iter_struct);

255

3516

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

256

3516

  dbus_message_iter_next (&iter_struct);

257

3516

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

258

3516

  dbus_message_iter_next (iter);

259

3516

260

261

gint

262

3908

_atspi_get_iface_num (const char *iface)

263

264

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

265

  int i;

266

267

17467

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

268

269

17467

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

270

3908

        return i;

271

272

  return -1;

273

274

275

GHashTable *

276

2

_atspi_get_live_refs (void)

277

278

2

  if (!live_refs)

279

280

2

      live_refs = g_hash_table_new (g_direct_hash, g_direct_equal);

281

282

2

  return live_refs;

283

284

285

/* TODO: Add an application parameter */

286

DBusConnection *

287

337

_atspi_bus ()

288

289

337

  if (!bus)

290

    atspi_init ();

291

337

  if (!bus)

292

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

293

337

  return bus;

294

295

296

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

297

298

static AtspiAccessible *desktop;

299

300

static void cleanup_deferred_message (void);

301

302

static void

303

2

cleanup ()

304

305

  GHashTable *refs;

306

  gint i;

307

308

2

  refs = live_refs;

309

2

  live_refs = NULL;

310

2

  if (refs)

311

312

2

      g_hash_table_destroy (refs);

313

314

315

2

  if (!desktop)

316

    goto end;

317

318

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

319

326

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

320

321

324

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

322

324

      if (child->parent.app)

323

57

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

324

      g_object_run_dispose (G_OBJECT (child));

325

326

327

2

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

328

2

  g_object_unref (desktop);

329

2

  desktop = NULL;

330

331

2

end:

332

2

  if (bus)

333

334

2

      dbus_connection_close (bus);

335

2

      dbus_connection_unref (bus);

336

2

      bus = NULL;

337

338

339

2

  cleanup_deferred_message ();

340

2

341

342

static gboolean atspi_inited = FALSE;

343

344

static GHashTable *app_hash = NULL;

345

346

static void

347

166

handle_get_bus_address (DBusPendingCall *pending, void *user_data)

348

349

166

  AtspiApplication *app = user_data;

350

166

  DBusMessage *reply = dbus_pending_call_steal_reply (pending);

351

  DBusMessage *message;

352

  const char *address;

353

  DBusPendingCall *new_pending;

354

355

166

  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN)

356

357

161

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

358

161

                                 DBUS_TYPE_INVALID) &&

359

161

          address[0])

360

361

          DBusError error;

362

          DBusConnection *bus;

363

364

161

          dbus_error_init (&error);

365

161

          bus = dbus_connection_open_private (address, &error);

366

161

          if (bus)

367

368

160

              if (app->bus)

369

370

160

                  dbus_connection_unref (app->bus);

371

372

160

              app->bus = bus;

373

160

              atspi_dbus_connection_setup_with_g_main (bus, g_main_context_default ());

374

375

          else

376

377

2

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

378

1

                  !g_getenv ("ATSPI_IN_TESTS"))

379

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

380

1

              dbus_error_free (&error);

381

382

383

384

166

  dbus_message_unref (reply);

385

166

  dbus_pending_call_unref (pending);

386

387

166

  if (!app->bus)

388

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

389

390

166

  message = dbus_message_new_method_call (app->bus_name,

391

                                          "/org/a11y/atspi/cache",

392

                                          atspi_interface_cache, "GetItems");

393

394

166

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

395

166

  dbus_message_unref (message);

396

166

  if (!new_pending)

397

    return;

398

166

  dbus_pending_call_set_notify (new_pending, handle_get_items, app, NULL);

399

400

401

static AtspiApplication *

402

7984

get_application (const char *bus_name)

403

404

7984

  AtspiApplication *app = NULL;

405

  char *bus_name_dup;

406

  DBusMessage *message;

407

7984

  DBusPendingCall *pending = NULL;

408

409

7984

  if (!app_hash)

410

411

2

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

412

413

7984

  app = g_hash_table_lookup (app_hash, bus_name);

414

7984

  if (app)

415

7818

    return app;

416

166

  bus_name_dup = g_strdup (bus_name);

417

418

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

419

166

  app = _atspi_application_new (bus_name);

420

166

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

421

166

  gettimeofday (&app->time_added, NULL);

422

166

  app->cache = ATSPI_CACHE_UNDEFINED;

423

166

  g_hash_table_insert (app_hash, bus_name_dup, app);

424

166

  message = dbus_message_new_method_call (bus_name, atspi_path_root,

425

                                          atspi_interface_application, "GetApplicationBusAddress");

426

427

166

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

428

166

  dbus_message_unref (message);

429

166

  if (!pending)

430

431

      g_hash_table_remove (app_hash, bus_name_dup);

432

      return NULL;

433

434

166

  dbus_pending_call_set_notify (pending, handle_get_bus_address, app, NULL);

435

166

  return app;

436

437

438

static AtspiAccessible *

439

3509

ref_accessible (ReferenceFromMessage *ref)

440

441

  AtspiApplication *app;

442

  AtspiAccessible *a;

443

444

3509

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

445

142

    return NULL;

446

447

3367

  app = get_application (ref->app_name);

448

449

3367

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

450

451

882

      if (!app->root)

452

453

324

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

454

324

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

455

324

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

456

457

882

      return g_object_ref (app->root);

458

459

460

2485

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

461

2485

  if (a)

462

463

1201

      return g_object_ref (a);

464

465

1284

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

466

2568

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

467

1284

  return a;

468

469

470

static AtspiHyperlink *

471

9

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

472

473

9

  AtspiApplication *app = get_application (app_name);

474

  AtspiHyperlink *hyperlink;

475

476

9

  if (!strcmp (path, ATSPI_DBUS_PATH_NULL))

477

    return NULL;

478

479

9

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

480

9

  if (hyperlink)

481

482

      return g_object_ref (hyperlink);

483

484

9

  hyperlink = _atspi_hyperlink_new (app, path);

485

18

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

486

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

487

9

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

488

9

  return hyperlink;

489

490

491

typedef struct

492

493

  char *path;

494

  char *parent;

495

  GArray *children;

496

  GArray *interfaces;

497

  char *name;

498

  dbus_uint32_t role;

499

  char *description;

500

  GArray *state_bitflags;

501

} CACHE_ADDITION;

502

503

static DBusHandlerResult

504

handle_remove_accessible (DBusConnection *bus, DBusMessage *message)

505

506

  ReferenceFromMessage ref;

507

  AtspiApplication *app;

508

  DBusMessageIter iter;

509

  const char *signature = dbus_message_get_signature (message);

510

  AtspiAccessible *a;

511

512

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

513

514

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

515

      return DBUS_HANDLER_RESULT_HANDLED;

516

517

518

  dbus_message_iter_init (message, &iter);

519

520

  get_reference_from_iter (&iter, &ref);

521

  app = get_application (ref.app_name);

522

  a = ref_accessible (&ref);

523

  if (!a)

524

    return DBUS_HANDLER_RESULT_HANDLED;

525

  g_object_run_dispose (G_OBJECT (a));

526

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

527

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

528

  return DBUS_HANDLER_RESULT_HANDLED;

529

530

531

static DBusHandlerResult

532

646

handle_name_owner_changed (DBusConnection *bus, DBusMessage *message)

533

534

  const char *name, *new, *old;

535

  static gboolean registry_lost = FALSE;

536

537

646

  if (!dbus_message_get_args (message, NULL,

538

                              DBUS_TYPE_STRING, &name,

539

                              DBUS_TYPE_STRING, &old,

540

                              DBUS_TYPE_STRING, &new,

541

                              DBUS_TYPE_INVALID))

542

543

      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

544

545

546

646

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

547

548

1

      if (registry_lost && !old[0])

549

550

          _atspi_reregister_event_listeners ();

551

          _atspi_reregister_device_listeners ();

552

          registry_lost = FALSE;

553

554

1

      else if (!new[0])

555

        registry_lost = TRUE;

556

557

645

  else if (app_hash)

558

559

641

      AtspiApplication *app = g_hash_table_lookup (app_hash, old);

560

641

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

561

321

        g_object_run_dispose (G_OBJECT (app));

562

563

646

  return DBUS_HANDLER_RESULT_HANDLED;

564

565

566

static gboolean

567

2

add_app_to_desktop (AtspiAccessible *a, const char *bus_name)

568

569

2

  ReferenceFromMessage ref = {

570

    .app_name = bus_name,

571

    .path = atspi_path_root,

572

};

573

2

  AtspiAccessible *obj = ref_accessible (&ref);

574

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

575

   * ref_accessible */

576

2

  g_object_unref (obj);

577

2

  return (obj != NULL);

578

579

580

static void

581

1419

add_accessible_from_iter (DBusMessageIter *iter)

582

583

  DBusMessageIter iter_struct, iter_array;

584

  AtspiAccessible *accessible;

585

  AtspiAccessible *parent;

586

  const char *name, *description;

587

  dbus_uint32_t role;

588

1419

  gboolean children_cached = FALSE;

589

  dbus_int32_t count, index;

590

591

1419

  dbus_message_iter_recurse (iter, &iter_struct);

592

593

  /* get accessible */

594

1419

  accessible = _atspi_dbus_consume_accessible (&iter_struct);

595

1419

  if (!accessible)

596

    return;

597

598

  /* Get application: TODO */

599

1419

  dbus_message_iter_next (&iter_struct);

600

601

  /* get parent */

602

1419

  parent = _atspi_dbus_consume_accessible (&iter_struct);

603

1419

  if (accessible->accessible_parent)

604

135

    g_object_unref (accessible->accessible_parent);

605

1419

  if (parent == accessible)

606

607

      guint pid = atspi_accessible_get_process_id (accessible, NULL);

608

      if (!g_getenv ("ATSPI_IN_TESTS"))

609

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

610

      accessible->accessible_parent = NULL;

611

612

  else

613

1419

    accessible->accessible_parent = parent;

614

615

1419

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

616

617

      /* Get index in parent */

618

1419

      dbus_message_iter_get_basic (&iter_struct, &index);

619

1419

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

620

621

1283

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

622

623

              /* There is no room for this object */

624

382

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

625

626

          else

627

628

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

629

901

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

630

                g_object_unref (g_ptr_array_index (accessible->accessible_parent->children, index));

631

632

1283

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

633

634

635

      /* get child count */

636

1419

      dbus_message_iter_next (&iter_struct);

637

1419

      dbus_message_iter_get_basic (&iter_struct, &count);

638

1419

      if (count >= 0)

639

640

1419

          g_ptr_array_set_size (accessible->children, count);

641

1419

          children_cached = TRUE;

642

643

644

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

645

646

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

647

      /* TODO: Perhaps remove this code eventually */

648

      dbus_message_iter_recurse (&iter_struct, &iter_array);

649

      while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

650

651

          AtspiAccessible *child;

652

          child = _atspi_dbus_consume_accessible (&iter_array);

653

          g_ptr_array_remove (accessible->children, child);

654

          g_ptr_array_add (accessible->children, child);

655

656

      children_cached = TRUE;

657

658

659

  /* interfaces */

660

1419

  dbus_message_iter_next (&iter_struct);

661

1419

  _atspi_dbus_set_interfaces (accessible, &iter_struct);

662

1419

  dbus_message_iter_next (&iter_struct);

663

664

  /* name */

665

1419

  if (accessible->name)

666

136

    g_free (accessible->name);

667

1419

  dbus_message_iter_get_basic (&iter_struct, &name);

668

1419

  accessible->name = g_strdup (name);

669

1419

  dbus_message_iter_next (&iter_struct);

670

671

  /* role */

672

1419

  dbus_message_iter_get_basic (&iter_struct, &role);

673

1419

  accessible->role = role;

674

1419

  dbus_message_iter_next (&iter_struct);

675

676

  /* description */

677

1419

  if (accessible->description)

678

1

    g_free (accessible->description);

679

1419

  dbus_message_iter_get_basic (&iter_struct, &description);

680

1419

  accessible->description = g_strdup (description);

681

1419

  dbus_message_iter_next (&iter_struct);

682

683

1419

  _atspi_dbus_set_state (accessible, &iter_struct);

684

1419

  dbus_message_iter_next (&iter_struct);

685

686

1419

  _atspi_accessible_add_cache (accessible, ATSPI_CACHE_NAME | ATSPI_CACHE_ROLE |

687

                                               ATSPI_CACHE_PARENT | ATSPI_CACHE_DESCRIPTION);

688

1419

  if (!atspi_state_set_contains (accessible->states,

689

1419

                                 ATSPI_STATE_MANAGES_DESCENDANTS) &&

690

      children_cached)

691

1419

    _atspi_accessible_add_cache (accessible, ATSPI_CACHE_CHILDREN);

692

693

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

694

   * the one provided for us anymore */

695

1419

  g_object_unref (accessible);

696

697

698

static void

699

142

handle_get_items (DBusPendingCall *pending, void *user_data)

700

701

142

  DBusMessage *reply = dbus_pending_call_steal_reply (pending);

702

  DBusMessageIter iter, iter_array;

703

704

142

  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)

705

706

2

      const char *sender = dbus_message_get_sender (reply);

707

2

      const char *error = NULL;

708

2

      const char *error_name = dbus_message_get_error_name (reply);

709

2

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

710

711

712

      else

713

714

          dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &error,

715

                                 DBUS_TYPE_INVALID);

716

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

717

718

2

      dbus_message_unref (reply);

719

2

      dbus_pending_call_unref (pending);

720

2

      return;

721

722

723

140

  dbus_message_iter_init (reply, &iter);

724

140

  dbus_message_iter_recurse (&iter, &iter_array);

725

1559

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

726

727

1419

      add_accessible_from_iter (&iter_array);

728

1419

      dbus_message_iter_next (&iter_array);

729

730

140

  dbus_message_unref (reply);

731

140

  dbus_pending_call_unref (pending);

732

733

734

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

735

static AtspiAccessible *

736

2

ref_accessible_desktop (AtspiApplication *app)

737

738

  GError *error;

739

  DBusMessage *message, *reply;

740

  DBusMessageIter iter, iter_array;

741

  gchar *bus_name_dup;

742

743

2

  if (desktop)

744

745

      g_object_ref (desktop);

746

      return desktop;

747

748

2

  desktop = _atspi_accessible_new (app, atspi_path_root);

749

4

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

750

                       g_object_ref (desktop));

751

2

  app->root = g_object_ref (desktop);

752

2

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

753

2

  message = dbus_message_new_method_call (atspi_bus_registry,

754

                                          atspi_path_root,

755

                                          atspi_interface_accessible,

756

                                          "GetChildren");

757

2

  if (!message)

758

    return NULL;

759

2

  error = NULL;

760

2

  reply = _atspi_dbus_send_with_reply_and_block (message, &error);

761

2

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

762

763

      if (error != NULL)

764

765

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

766

          g_clear_error (&error);

767

768

      if (reply)

769

        dbus_message_unref (reply);

770

      return NULL;

771

772

2

  dbus_message_iter_init (reply, &iter);

773

2

  dbus_message_iter_recurse (&iter, &iter_array);

774

4

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

775

776

      ReferenceFromMessage ref;

777

778

2

      get_reference_from_iter (&iter_array, &ref);

779

2

      add_app_to_desktop (desktop, ref.app_name);

780

781

782

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

783

2

  bus_name_dup = g_strdup (dbus_message_get_sender (reply));

784

2

  if (bus_name_dup)

785

2

    g_hash_table_insert (app_hash, bus_name_dup, app);

786

787

2

  dbus_message_unref (reply);

788

789

2

  return g_object_ref (desktop);

790

791

792

AtspiAccessible *

793

4595

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

794

795

4595

  ReferenceFromMessage ref = {

796

    .app_name = app,

797

    .path = path,

798

};

799

4595

  AtspiApplication *a = get_application (app);

800

4595

  if (!a)

801

    return NULL;

802

4595

  if (APP_IS_REGISTRY (a))

803

804

4593

      if (!a->root)

805

2

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

806

4593

      return g_object_ref (a->root);

807

808

2

  return ref_accessible (&ref);

809

810

811

AtspiAccessible *

812

313

_atspi_dbus_return_accessible_from_message (DBusMessage *message)

813

814

  DBusMessageIter iter;

815

313

  AtspiAccessible *retval = NULL;

816

  const char *signature;

817

818

313

  if (!message)

819

    return NULL;

820

821

313

  signature = dbus_message_get_signature (message);

822

313

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

823

824

313

      dbus_message_iter_init (message, &iter);

825

313

      retval = _atspi_dbus_consume_accessible (&iter);

826

827

  else

828

829

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

830

831

313

  dbus_message_unref (message);

832

313

  return retval;

833

834

835

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

836

AtspiAccessible *

837

3505

_atspi_dbus_consume_accessible (DBusMessageIter *iter)

838

839

  ReferenceFromMessage ref;

840

841

3505

  get_reference_from_iter (iter, &ref);

842

3505

  return ref_accessible (&ref);

843

844

845

AtspiHyperlink *

846

9

_atspi_dbus_return_hyperlink_from_message (DBusMessage *message)

847

848

  DBusMessageIter iter;

849

9

  AtspiHyperlink *retval = NULL;

850

  const char *signature;

851

852

9

  if (!message)

853

    return NULL;

854

855

9

  signature = dbus_message_get_signature (message);

856

9

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

857

858

9

      dbus_message_iter_init (message, &iter);

859

9

      retval = _atspi_dbus_return_hyperlink_from_iter (&iter);

860

861

  else

862

863

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

864

865

9

  dbus_message_unref (message);

866

9

  return retval;

867

868

869

AtspiHyperlink *

870

9

_atspi_dbus_return_hyperlink_from_iter (DBusMessageIter *iter)

871

872

  ReferenceFromMessage ref;

873

874

9

  get_reference_from_iter (iter, &ref);

875

9

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

876

877

878

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

879

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

880

881

static DBusHandlerResult

882

handle_add_accessible (DBusConnection *bus, DBusMessage *message)

883

884

  DBusMessageIter iter;

885

  const char *signature = dbus_message_get_signature (message);

886

887

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

888

      strcmp (signature, old_cache_signal_type) != 0)

889

890

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

891

      return DBUS_HANDLER_RESULT_HANDLED;

892

893

894

  dbus_message_iter_init (message, &iter);

895

  add_accessible_from_iter (&iter);

896

  return DBUS_HANDLER_RESULT_HANDLED;

897

898

899

typedef struct

900

901

  DBusConnection *bus;

902

  DBusMessage *message;

903

} BusDataClosure;

904

905

static GSource *process_deferred_messages_source = NULL;

906

907

static void

908

969

process_deferred_message (BusDataClosure *closure)

909

910

969

  int type = dbus_message_get_type (closure->message);

911

969

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

912

913

969

  if (type == DBUS_MESSAGE_TYPE_SIGNAL &&

914

969

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

915

916

323

      _atspi_dbus_handle_event (closure->message);

917

918

646

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

919

920

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

921

922

646

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

923

924

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

925

926

646

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

927

928

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

929

930

646

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

931

932

646

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

933

934

969

935

936

static GQueue *deferred_messages = NULL;

937

938

static void

939

969

destroy_deferred_message_item (gpointer ptr)

940

941

969

  BusDataClosure *c = ptr;

942

969

  dbus_message_unref (c->message);

943

969

  dbus_connection_unref (c->bus);

944

969

  g_free (c);

945

969

946

947

static void

948

2

cleanup_deferred_message (void)

949

950

2

  if (deferred_messages)

951

952

2

      g_queue_free_full (deferred_messages, destroy_deferred_message_item);

953

2

      deferred_messages = NULL;

954

955

2

956

957

static gboolean

958

1708

process_deferred_messages (void)

959

960

  static int in_process_deferred_messages = 0;

961

  BusDataClosure *closure;

962

963

1708

  if (in_process_deferred_messages)

964

494

    return TRUE;

965

1214

  in_process_deferred_messages = 1;

966

2183

  while ((closure = g_queue_pop_head (deferred_messages)))

967

968

969

      process_deferred_message (closure);

969

      destroy_deferred_message_item (closure);

970

971

1214

  in_process_deferred_messages = 0;

972

1214

  return FALSE;

973

974

975

static gboolean

976

717

process_deferred_messages_callback (gpointer data)

977

978

717

  if (process_deferred_messages ())

979

    return G_SOURCE_CONTINUE;

980

981

717

  process_deferred_messages_source = NULL;

982

717

  return G_SOURCE_REMOVE;

983

984

985

static DBusHandlerResult

986

969

defer_message (DBusConnection *connection, DBusMessage *message)

987

988

969

  BusDataClosure *closure = g_new (BusDataClosure, 1);

989

990

969

  closure->bus = dbus_connection_ref (bus);

991

969

  closure->message = dbus_message_ref (message);

992

993

969

  g_queue_push_tail (deferred_messages, closure);

994

995

969

  if (process_deferred_messages_source == NULL)

996

997

717

      process_deferred_messages_source = g_idle_source_new ();

998

717

      g_source_set_callback (process_deferred_messages_source,

999

                             process_deferred_messages_callback, NULL, NULL);

1000

717

      g_source_attach (process_deferred_messages_source, atspi_main_context);

1001

717

      g_source_unref (process_deferred_messages_source);

1002

1003

1004

969

  return DBUS_HANDLER_RESULT_HANDLED;

1005

1006

1007

static DBusHandlerResult

1008

972

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

1009

1010

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

1011

972

  g_assert (data == NULL);

1012

1013

972

  int type = dbus_message_get_type (message);

1014

972

  const char *interface = dbus_message_get_interface (message);

1015

1016

972

  if (type == DBUS_MESSAGE_TYPE_SIGNAL &&

1017

971

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

1018

1019

323

      return defer_message (bus, message);

1020

1021

649

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

1022

1023

      return defer_message (bus, message);

1024

1025

649

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

1026

1027

      return defer_message (bus, message);

1028

1029

649

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

1030

1031

      return defer_message (bus, message);

1032

1033

649

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

1034

1035

646

      defer_message (bus, message);

1036

646

      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1037

1038

3

  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1039

1040

1041

/**

1042

 * atspi_init:

1043

1044

 * Connects to the accessibility registry and initializes the SPI.

1045

1046

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

1047

**/

1048

int

1049

2

atspi_init (void)

1050

1051

  char *match;

1052

  const gchar *no_cache;

1053

1054

2

  if (atspi_inited)

1055

1056

      return 1;

1057

1058

1059

2

  atspi_inited = TRUE;

1060

1061

2

  _atspi_get_live_refs ();

1062

1063

2

  bus = atspi_get_a11y_bus ();

1064

2

  if (!bus)

1065

    return 2;

1066

2

  dbus_bus_register (bus, NULL);

1067

2

  atspi_dbus_connection_setup_with_g_main (bus, g_main_context_default ());

1068

2

  dbus_connection_add_filter (bus, atspi_dbus_filter, NULL, NULL);

1069

2

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

1070

2

  dbus_bus_add_match (bus, match, NULL);

1071

2

  g_free (match);

1072

2

  match = g_strdup_printf ("type='signal',interface='%s',member='RemoveAccessible'", 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='ChildrenChanged'", atspi_interface_event_object);

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='PropertyChange'", 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='StateChanged'", atspi_interface_event_object);

1082

2

  dbus_bus_add_match (bus, match, NULL);

1083

2

  g_free (match);

1084

1085

2

  dbus_bus_add_match (bus,

1086

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

1087

                      NULL);

1088

1089

2

  no_cache = g_getenv ("ATSPI_NO_CACHE");

1090

2

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

1091

    atspi_no_cache = TRUE;

1092

1093

2

  deferred_messages = g_queue_new ();

1094

1095

2

  return 0;

1096

1097

1098

/**

1099

 * atspi_is_initialized:

1100

1101

 * Indicates whether AT-SPI has been initialized.

1102

1103

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

1104

*/

1105

gboolean

1106

161

atspi_is_initialized ()

1107

1108

161

  return atspi_inited;

1109

1110

1111

/**

1112

 * atspi_event_main:

1113

1114

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

1115

1116

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

1117

 * #atspi_event_quit from within an event handler.

1118

1119

**/

1120

void

1121

162

atspi_event_main (void)

1122

1123

162

  atspi_main_loop = g_main_loop_new (NULL, FALSE);

1124

162

  g_main_loop_run (atspi_main_loop);

1125

161

  g_main_loop_unref (atspi_main_loop);

1126

161

  atspi_main_loop = NULL;

1127

161

1128

1129

/**

1130

 * atspi_event_quit:

1131

1132

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

1133

 * See: #atspi_event_main

1134

**/

1135

void

1136

162

atspi_event_quit (void)

1137

1138

162

  g_main_loop_quit (atspi_main_loop);

1139

162

1140

1141

/**

1142

 * atspi_exit:

1143

1144

 * Disconnects from #AtspiRegistry instances and releases

1145

 * any floating resources. Call only once at exit.

1146

1147

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

1148

**/

1149

int

1150

2

atspi_exit (void)

1151

1152

  int leaked;

1153

1154

2

  if (!atspi_inited)

1155

1156

      return 0;

1157

1158

1159

2

  atspi_inited = FALSE;

1160

1161

2

  if (live_refs)

1162

1163

2

      leaked = g_hash_table_size (live_refs);

1164

1165

  else

1166

1167

      leaked = 0;

1168

1169

1170

2

  cleanup ();

1171

1172

2

  return leaked;

1173

1174

1175

static GSList *hung_processes;

1176

1177

static void

1178

remove_hung_process (DBusPendingCall *pending, void *data)

1179

1180

  hung_processes = g_slist_remove (hung_processes, data);

1181

  g_free (data);

1182

  dbus_pending_call_unref (pending);

1183

1184

1185

static void

1186

978

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

1187

1188

978

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

1189

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

1190

1191

      GSList *l;

1192

      DBusMessage *message;

1193

      gchar *bus_name_dup;

1194

      DBusPendingCall *pending = NULL;

1195

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

1196

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

1197

          return;

1198

      message = dbus_message_new_method_call (bus_name, "/",

1199

                                              "org.freedesktop.DBus.Peer",

1200

                                              "Ping");

1201

      if (!message)

1202

        return;

1203

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

1204

      dbus_message_unref (message);

1205

      if (!pending)

1206

        return;

1207

      bus_name_dup = g_strdup (bus_name);

1208

      hung_processes = g_slist_append (hung_processes, bus_name_dup);

1209

      dbus_pending_call_set_notify (pending, remove_hung_process, bus_name_dup, NULL);

1210

1211

1212

1213

static gboolean

1214

491

connection_is_hung (const char *bus_name)

1215

1216

  GSList *l;

1217

1218

491

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

1219

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

1220

      return TRUE;

1221

491

  return FALSE;

1222

1223

1224

static gboolean

1225

978

check_app (AtspiApplication *app, GError **error)

1226

1227

978

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

1228

1229

      g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_APPLICATION_GONE,

1230

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

1231

      return FALSE;

1232

1233

1234

978

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

1235

1236

      g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_IPC,

1237

                           "The process appears to be hung.");

1238

      return FALSE;

1239

1240

1241

978

  return TRUE;

1242

1243

1244

static void

1245

991

set_timeout (AtspiApplication *app)

1246

1247

  struct timeval tv;

1248

  int diff;

1249

1250

991

  if (app && app_startup_time > 0)

1251

1252

991

      gettimeofday (&tv, NULL);

1253

991

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

1254

991

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

1255

1256

  else

1257

    dbind_set_timeout (method_call_timeout);

1258

991

1259

1260

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

1261

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

1262

 * and returns an int).

1263

*/

1264

dbus_bool_t

1265

137

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

1266

1267

  va_list args;

1268

  dbus_bool_t retval;

1269

  DBusError err;

1270

137

  AtspiObject *aobj = ATSPI_OBJECT (obj);

1271

1272

137

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

1273

    return FALSE;

1274

1275

137

  va_start (args, type);

1276

137

  dbus_error_init (&err);

1277

137

  set_timeout (aobj->app);

1278

137

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

1279

137

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

1280

                                           type, args);

1281

137

  va_end (args);

1282

137

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

1283

137

  process_deferred_messages ();

1284

137

  if (dbus_error_is_set (&err))

1285

1286

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

1287

      dbus_error_free (&err);

1288

1289

137

  return retval;

1290

1291

1292

static DBusMessage *

1293

466

_atspi_dbus_call_partial_va (gpointer obj,

1294

                             const char *interface,

1295

                             const char *method,

1296

                             GError **error,

1297

                             const char *type,

1298

                             va_list args)

1299

1300

466

  AtspiObject *aobj = ATSPI_OBJECT (obj);

1301

  DBusError err;

1302

466

  DBusMessage *msg = NULL, *reply = NULL;

1303

  DBusMessageIter iter;

1304

  const char *p;

1305

1306

466

  dbus_error_init (&err);

1307

1308

466

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

1309

    goto out;

1310

1311

466

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

1312

466

  if (!msg)

1313

    goto out;

1314

1315

466

  p = type;

1316

466

  dbus_message_iter_init_append (msg, &iter);

1317

466

  dbind_any_marshal_va (&iter, &p, args);

1318

1319

466

  set_timeout (aobj->app);

1320

466

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

1321

466

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

1322

466

out:

1323

466

  if (msg)

1324

466

    dbus_message_unref (msg);

1325

466

  process_deferred_messages ();

1326

466

  if (dbus_error_is_set (&err))

1327

1328

      /* TODO: Set gerror */

1329

      dbus_error_free (&err);

1330

1331

1332

466

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

1333

1334

      const char *err_str = NULL;

1335

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

1336

      if (err_str)

1337

        g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_IPC, err_str);

1338

      dbus_message_unref (reply);

1339

      return NULL;

1340

1341

1342

466

  return reply;

1343

1344

1345

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

1346

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

1347

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

1348

*/

1349

DBusMessage *

1350

466

_atspi_dbus_call_partial (gpointer obj,

1351

                          const char *interface,

1352

                          const char *method,

1353

                          GError **error,

1354

                          const char *type,

1355

                          ...)

1356

1357

  DBusMessage *ret;

1358

  va_list args;

1359

1360

466

  va_start (args, type);

1361

466

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

1362

466

  va_end (args);

1363

1364

466

  return ret;

1365

1366

1367

dbus_bool_t

1368

375

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

1369

1370

  DBusMessage *message, *reply;

1371

  DBusMessageIter iter, iter_variant;

1372

  DBusError err;

1373

375

  dbus_bool_t retval = FALSE;

1374

375

  AtspiObject *aobj = ATSPI_OBJECT (obj);

1375

375

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

1376

1377

375

  if (!aobj)

1378

    return FALSE;

1379

1380

375

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

1381

    return FALSE;

1382

1383

375

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

1384

375

                                          aobj->path,

1385

                                          "org.freedesktop.DBus.Properties",

1386

                                          "Get");

1387

375

  if (!message)

1388

1389

      // TODO: throw exception

1390

      return FALSE;

1391

1392

375

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

1393

375

  dbus_error_init (&err);

1394

375

  set_timeout (aobj->app);

1395

375

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

1396

375

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

1397

375

  dbus_message_unref (message);

1398

375

  process_deferred_messages ();

1399

375

  if (!reply)

1400

1401

      /* TODO: throw exception */

1402

      goto done;

1403

1404

1405

375

  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)

1406

1407

      const char *err_str = NULL;

1408

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

1409

      if (err_str)

1410

        g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_IPC, err_str);

1411

      goto done;

1412

1413

1414

375

  dbus_message_iter_init (reply, &iter);

1415

375

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

1416

1417

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

1418

      goto done;

1419

1420

375

  dbus_message_iter_recurse (&iter, &iter_variant);

1421

375

  if (dbus_message_iter_get_arg_type (&iter_variant) != expected_type)

1422

1423

      g_warning ("atspi_dbus_get_property: Wrong type: expected %s, got %c\n", type, dbus_message_iter_get_arg_type (&iter_variant));

1424

      goto done;

1425

1426

375

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

1427

1428

3

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

1429

1430

  else

1431

1432

372

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

1433

1434

174

          *(char **) data = NULL;

1435

1436

1437

372

      dbus_message_iter_get_basic (&iter_variant, data);

1438

372

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

1439

348

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

1440

1441

375

  retval = TRUE;

1442

375

done:

1443

375

  dbus_error_free (&err);

1444

375

  if (reply)

1445

375

    dbus_message_unref (reply);

1446

375

  return retval;

1447

1448

1449

DBusMessage *

1450

13

_atspi_dbus_send_with_reply_and_block (DBusMessage *message, GError **error)

1451

1452

  DBusMessage *reply;

1453

  DBusError err;

1454

  AtspiApplication *app;

1455

  DBusConnection *bus;

1456

1457

13

  app = get_application (dbus_message_get_destination (message));

1458

1459

13

  if (app && !app->bus)

1460

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

1461

1462

13

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

1463

13

  dbus_error_init (&err);

1464

13

  set_timeout (app);

1465

13

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

1466

13

  process_deferred_messages ();

1467

13

  dbus_message_unref (message);

1468

13

  if (dbus_error_is_set (&err))

1469

1470

      if (error)

1471

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

1472

      dbus_error_free (&err);

1473

1474

13

  return reply;

1475

1476

1477

GHashTable *

1478

3

_atspi_dbus_return_hash_from_message (DBusMessage *message)

1479

1480

  DBusMessageIter iter;

1481

  GHashTable *ret;

1482

1483

3

  if (!message)

1484

    return NULL;

1485

1486

3

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

1487

1488

3

  dbus_message_iter_init (message, &iter);

1489

3

  ret = _atspi_dbus_hash_from_iter (&iter);

1490

3

  dbus_message_unref (message);

1491

3

  return ret;

1492

1493

1494

GHashTable *

1495

5

_atspi_dbus_hash_from_iter (DBusMessageIter *iter)

1496

1497

5

  GHashTable *hash = g_hash_table_new_full (g_str_hash, g_str_equal,

1498

                                            (GDestroyNotify) g_free,

1499

                                            (GDestroyNotify) g_free);

1500

  DBusMessageIter iter_array, iter_dict;

1501

1502

5

  dbus_message_iter_recurse (iter, &iter_array);

1503

16

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

1504

1505

      const char *name, *value;

1506

11

      dbus_message_iter_recurse (&iter_array, &iter_dict);

1507

11

      dbus_message_iter_get_basic (&iter_dict, &name);

1508

11

      dbus_message_iter_next (&iter_dict);

1509

11

      dbus_message_iter_get_basic (&iter_dict, &value);

1510

22

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

1511

11

      dbus_message_iter_next (&iter_array);

1512

1513

5

  return hash;

1514

1515

1516

GArray *

1517

1

_atspi_dbus_return_attribute_array_from_message (DBusMessage *message)

1518

1519

  DBusMessageIter iter;

1520

  GArray *ret;

1521

1522

1

  if (!message)

1523

    return NULL;

1524

1525

1

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

1526

1527

1

  dbus_message_iter_init (message, &iter);

1528

1529

1

  ret = _atspi_dbus_attribute_array_from_iter (&iter);

1530

1

  dbus_message_unref (message);

1531

1

  return ret;

1532

1533

1534

GArray *

1535

1

_atspi_dbus_attribute_array_from_iter (DBusMessageIter *iter)

1536

1537

  DBusMessageIter iter_array, iter_dict;

1538

1

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

1539

1540

1

  dbus_message_iter_recurse (iter, &iter_array);

1541

3

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

1542

1543

      const char *name, *value;

1544

      gchar *str;

1545

2

      dbus_message_iter_recurse (&iter_array, &iter_dict);

1546

2

      dbus_message_iter_get_basic (&iter_dict, &name);

1547

2

      dbus_message_iter_next (&iter_dict);

1548

2

      dbus_message_iter_get_basic (&iter_dict, &value);

1549

2

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

1550

2

      array = g_array_append_val (array, str);

1551

2

      dbus_message_iter_next (&iter_array);

1552

1553

1554

1

  return array;

1555

1556

1557

typedef enum

1558

1559

  DEMARSHAL_STATUS_SUCCESS,

1560

  DEMARSHAL_STATUS_INVALID_SIGNATURE,

1561

  DEMARSHAL_STATUS_INVALID_VALUE,

1562

} DemarshalStatus;

1563

1564

typedef struct

1565

1566

  /* array of (char *) */

1567

  GPtrArray *names;

1568

} InterfaceNames;

1569

1570

static DemarshalStatus

1571

1541

interface_names_demarshal (DBusMessageIter *iter, InterfaceNames **out_interfaces)

1572

1573

1541

  char *sig = dbus_message_iter_get_signature (iter);

1574

1541

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

1575

1541

  dbus_free (sig);

1576

1577

1541

  *out_interfaces = NULL;

1578

1579

1541

  GPtrArray *names = g_ptr_array_new_with_free_func (g_free);

1580

1581

1541

  if (!matches)

1582

1583

      return DEMARSHAL_STATUS_INVALID_SIGNATURE;

1584

1585

1586

  DBusMessageIter iter_array;

1587

1541

  dbus_message_iter_recurse (iter, &iter_array);

1588

5307

  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)

1589

1590

      const char *iface;

1591

3766

      dbus_message_iter_get_basic (&iter_array, &iface);

1592

7532

      g_ptr_array_add (names, g_strdup (iface));

1593

3766

      dbus_message_iter_next (&iter_array);

1594

1595

1596

1541

  InterfaceNames *ifaces = g_new0 (InterfaceNames, 1);

1597

1541

  ifaces->names = names;

1598

1541

  *out_interfaces = ifaces;

1599

1541

  return DEMARSHAL_STATUS_SUCCESS;

1600

1601

1602

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

1603

static gint

1604

1541

interface_names_to_bitmask (const InterfaceNames *ifaces)

1605

1606

1541

  gint val = 0;

1607

  guint i;

1608

1609

1541

  g_assert (ifaces->names != NULL);

1610

1611

5307

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

1612

1613

3766

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

1614

3766

      gint iface_num = _atspi_get_iface_num (name);

1615

3766

      if (iface_num == -1)

1616

1617

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

1618

1619

      else

1620

1621

3766

          val |= (1 << iface_num);

1622

1623

1624

1625

1541

  return val;

1626

1627

1628

static void

1629

1541

interface_names_free (InterfaceNames *ifaces)

1630

1631

1541

  g_ptr_array_free (ifaces->names, TRUE);

1632

1541

  g_free (ifaces);

1633

1541

1634

1635

void

1636

1541

_atspi_dbus_set_interfaces (AtspiAccessible *accessible, DBusMessageIter *iter)

1637

1638

  InterfaceNames *ifaces;

1639

1640

1541

  accessible->interfaces = 0;

1641

1642

1541

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

1643

1644

      g_warning ("Passed iterator with invalid signature");

1645

      return;

1646

1647

1648

1541

  accessible->interfaces = interface_names_to_bitmask (ifaces);

1649

1541

  interface_names_free (ifaces);

1650

1651

1541

  _atspi_accessible_add_cache (accessible, ATSPI_CACHE_INTERFACES);

1652

1653

1654

void

1655

1430

_atspi_dbus_set_state (AtspiAccessible *accessible, DBusMessageIter *iter)

1656

1657

  DBusMessageIter iter_array;

1658

  gint count;

1659

  dbus_uint32_t *states;

1660

1661

1430

  dbus_message_iter_recurse (iter, &iter_array);

1662

1430

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

1663

1430

  if (count != 2)

1664

1665

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

1666

      if (!accessible->states)

1667

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

1668

1669

  else

1670

1671

1430

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

1672

1430

      val += states[0];

1673

1430

      if (!accessible->states)

1674

1419

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

1675

      else

1676

11

        accessible->states->states = val;

1677

1678

1430

  _atspi_accessible_add_cache (accessible, ATSPI_CACHE_STATES);

1679

1430

1680

1681

GQuark

1682

_atspi_error_quark (void)

1683

1684

  return g_quark_from_static_string ("atspi_error");

1685

1686

1687

/*

1688

 * Gets the IOR from the XDisplay.

1689

*/

1690

#ifdef HAVE_X11

1691

/*

1692

 * Returns a 'canonicalized' value for DISPLAY,

1693

 * with the screen number stripped off if present.

1694

1695

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

1696

*/

1697

static gchar *

1698

191

spi_display_name (void)

1699

1700

191

  char *canonical_display_name = NULL;

1701

191

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

1702

1703

191

  if (!display_env)

1704

1705

191

      display_env = g_getenv ("DISPLAY");

1706

191

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

1707

        return NULL;

1708

      else

1709

1710

          gchar *display_p, *screen_p;

1711

191

          canonical_display_name = g_strdup (display_env);

1712

191

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

1713

191

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

1714

191

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

1715

1716

              *screen_p = '\0';

1717

1718

1719

1720

  else

1721

1722

      canonical_display_name = g_strdup (display_env);

1723

1724

1725

191

  return canonical_display_name;

1726

1727

1728

static char *

1729

191

get_accessibility_bus_address_x11 (void)

1730

1731

  Atom AT_SPI_BUS;

1732

  Atom actual_type;

1733

191

  Display *bridge_display = NULL;

1734

  int actual_format;

1735

  char *data;

1736

191

  unsigned char *data_x11 = NULL;

1737

  unsigned long nitems;

1738

  unsigned long leftover;

1739

  char *display_name;

1740

1741

191

  display_name = spi_display_name ();

1742

191

  if (!display_name)

1743

    return NULL;

1744

1745

191

  bridge_display = XOpenDisplay (display_name);

1746

191

  g_free (display_name);

1747

1748

191

  if (!bridge_display)

1749

1750

      g_warning ("Could not open X display");

1751

      return NULL;

1752

1753

1754

191

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

1755

191

  XGetWindowProperty (bridge_display,

1756

                      XDefaultRootWindow (bridge_display),

1757

                      AT_SPI_BUS, 0L,

1758

                      (long) BUFSIZ, False,

1759

                      (Atom) 31, &actual_type, &actual_format,

1760

                      &nitems, &leftover, &data_x11);

1761

191

  XCloseDisplay (bridge_display);

1762

1763

191

  data = g_strdup ((gchar *) data_x11);

1764

191

  XFree (data_x11);

1765

191

  return data;

1766

1767

#endif

1768

1769

static char *

1770

191

get_accessibility_bus_address_dbus (void)

1771

1772

191

  DBusConnection *session_bus = NULL;

1773

  DBusMessage *message;

1774

  DBusMessage *reply;

1775

  DBusError error;

1776

191

  char *address = NULL;

1777

1778

191

  session_bus = dbus_bus_get (DBUS_BUS_SESSION, NULL);

1779

191

  if (!session_bus)

1780

    return NULL;

1781

1782

191

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

1783

                                          "/org/a11y/bus",

1784

                                          "org.a11y.Bus",

1785

                                          "GetAddress");

1786

1787

191

  dbus_error_init (&error);

1788

191

  reply = dbus_connection_send_with_reply_and_block (session_bus,

1789

                                                     message,

1790

-1,

1791

                                                     &error);

1792

191

  dbus_message_unref (message);

1793

1794

191

  if (!reply)

1795

1796

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

1797

                 error.name, error.message);

1798

      dbus_error_free (&error);

1799

      goto out;

1800

1801

1802

1803

    const char *tmp_address;

1804

191

    if (!dbus_message_get_args (reply,

1805

                                NULL,

1806

                                DBUS_TYPE_STRING,

1807

                                &tmp_address,

1808

                                DBUS_TYPE_INVALID))

1809

1810

        dbus_message_unref (reply);

1811

        goto out;

1812

1813

191

    address = g_strdup (tmp_address);

1814

191

    dbus_message_unref (reply);

1815

1816

1817

191

out:

1818

191

  dbus_connection_unref (session_bus);

1819

191

  return address;

1820

1821

1822

static DBusConnection *a11y_bus;

1823

static dbus_int32_t a11y_dbus_slot = -1;

1824

1825

static void

1826

190

a11y_bus_free (void *data)

1827

1828

190

  if (data == a11y_bus)

1829

1830

190

      a11y_bus = NULL;

1831

190

      dbus_connection_free_data_slot (&a11y_dbus_slot);

1832

1833

190

1834

1835

/**

1836

 * atspi_get_a11y_bus: (skip)

1837

*/

1838

DBusConnection *

1839

191

atspi_get_a11y_bus (void)

1840

1841

  DBusError error;

1842

191

  char *address = NULL;

1843

191

  const char *address_env = NULL;

1844

1845

191

  if (a11y_bus && dbus_connection_get_is_connected (a11y_bus))

1846

    return a11y_bus;

1847

1848

191

  if (a11y_dbus_slot == -1)

1849

191

    if (!dbus_connection_allocate_data_slot (&a11y_dbus_slot))

1850

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

1851

1852

191

  address_env = g_getenv ("AT_SPI_BUS_ADDRESS");

1853

191

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

1854

    address = g_strdup (address_env);

1855

#ifdef HAVE_X11

1856

382

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

1857

191

      g_getenv ("WAYLAND_DISPLAY") == NULL)

1858

191

    address = get_accessibility_bus_address_x11 ();

1859

#endif

1860

191

  if (!address)

1861

191

    address = get_accessibility_bus_address_dbus ();

1862

191

  if (!address)

1863

    return NULL;

1864

1865

191

  dbus_error_init (&error);

1866

191

  a11y_bus = dbus_connection_open_private (address, &error);

1867

191

  g_free (address);

1868

1869

191

  if (!a11y_bus)

1870

1871

      if (!g_getenv ("SSH_CONNECTION"))

1872

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

1873

      dbus_error_free (&error);

1874

      return NULL;

1875

1876

  else

1877

1878

191

      if (!dbus_bus_register (a11y_bus, &error))

1879

1880

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

1881

          dbus_error_free (&error);

1882

          dbus_connection_close (a11y_bus);

1883

          dbus_connection_unref (a11y_bus);

1884

          a11y_bus = NULL;

1885

          return NULL;

1886

1887

1888

1889

  /* Simulate a weak ref on the bus */

1890

191

  dbus_connection_set_data (a11y_bus, a11y_dbus_slot, a11y_bus, a11y_bus_free);

1891

1892

191

  return a11y_bus;

1893

1894

1895

/**

1896

 * atspi_set_timeout:

1897

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

1898

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

1899

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

1900

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

1901

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

1902

 * behavior.

1903

1904

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

1905

 * a default of 800 ms is used.

1906

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

1907

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

1908

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

1909

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

1910

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

1911

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

1912

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

1913

 * larger than 3 seconds.

1914

1915

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

1916

 * timeout is set to 15 seconds.

1917

*/

1918

void

1919

atspi_set_timeout (gint val, gint startup_time)

1920

1921

  method_call_timeout = val;

1922

  app_startup_time = startup_time;

1923

1924

1925

/**

1926

 * atspi_set_main_context:

1927

 * @cnx: The #GMainContext to use.

1928

1929

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

1930

 * setting an idle callback.

1931

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

1932

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

1933

*/

1934

void

1935

atspi_set_main_context (GMainContext *cnx)

1936

1937

  if (atspi_main_context == cnx)

1938

    return;

1939

  if (process_deferred_messages_source != NULL)

1940

1941

      g_source_destroy (process_deferred_messages_source);

1942

      process_deferred_messages_source = g_idle_source_new ();

1943

      g_source_set_callback (process_deferred_messages_source,

1944

                             process_deferred_messages_callback, NULL, NULL);

1945

      g_source_attach (process_deferred_messages_source, cnx);

1946

      g_source_unref (process_deferred_messages_source);

1947

1948

  atspi_main_context = cnx;

1949

  atspi_dbus_connection_setup_with_g_main (atspi_get_a11y_bus (), cnx);

1950

1951

  if (desktop)

1952

1953

      gint i;

1954

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

1955

1956

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

1957

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

1958

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

1959

1960

1961

1962

1963

#ifdef DEBUG_REF_COUNTS

1964

static void

1965

print_disposed (gpointer key, gpointer value, gpointer data)

1966

1967

  AtspiAccessible *accessible = key;

1968

  if (accessible->parent.app)

1969

    return;

1970

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

1971

1972

1973

void

1974

debug_disposed ()

1975

1976

  g_hash_table_foreach (live_refs, print_disposed, NULL);

1977

1978

#endif

1979

1980

gchar *

1981

2

_atspi_name_compat (gchar *name)

1982

1983

2

  gchar *p = name;

1984

1985

36

  while (*p)

1986

1987

34

      if (*p == '-')

1988

2

        *p = ' ';

1989

34

      p++;

1990

1991

2

  return name;

1992

1993

1994

/**

1995

 * atspi_role_get_name:

1996

 * @role: an #AtspiRole object to query.

1997

1998

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

1999

2000

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

2001

**/

2002

gchar *

2003

2

atspi_role_get_name (AtspiRole role)

2004

2005

2

  gchar *retval = NULL;

2006

  GTypeClass *type_class;

2007

  GEnumValue *value;

2008

2009

2

  type_class = g_type_class_ref (ATSPI_TYPE_ROLE);

2010

2

  g_return_val_if_fail (G_IS_ENUM_CLASS (type_class), NULL);

2011

2012

2

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

2013

2014

2

  if (value)

2015

2016

4

      retval = g_strdup (value->value_nick);

2017

2018

2019

2

  g_type_class_unref (type_class);

2020

2021

2

  if (retval)

2022

2

    return _atspi_name_compat (retval);

2023

2024

  return NULL;

2025

2026

2027

/**

2028

 * atspi_role_get_localized_name:

2029

 * @role: an #AtspiRole object to query.

2030

2031

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

2032

2033

 * Returns: the localized string describing the AtspiRole

2034

**/

2035

gchar *

2036

1

atspi_role_get_localized_name (AtspiRole role)

2037

2038

1

  gchar *raw_name = NULL;

2039

  const char *translated_name;

2040

2041

1

  _gettext_initialization ();

2042

2043

1

  raw_name = atspi_role_get_name (role);

2044

1

  translated_name = dgettext (GETTEXT_PACKAGE, raw_name);

2045

1

  if (translated_name != raw_name)

2046

2047

      g_free (raw_name);

2048

      return g_strdup (translated_name);

2049

2050

  else

2051

1

    return raw_name;

2052

2053

2054

GHashTable *

2055

323

_atspi_dbus_update_cache_from_dict (AtspiAccessible *accessible, DBusMessageIter *iter)

2056

2057

323

  GHashTable *cache = _atspi_accessible_ref_cache (accessible);

2058

  DBusMessageIter iter_dict, iter_dict_entry, iter_struct, iter_variant;

2059

2060

323

  dbus_message_iter_recurse (iter, &iter_dict);

2061

323

  while (dbus_message_iter_get_arg_type (&iter_dict) != DBUS_TYPE_INVALID)

2062

2063

      const char *key;

2064

      GValue *val = NULL;

2065

      dbus_message_iter_recurse (&iter_dict, &iter_dict_entry);

2066

      dbus_message_iter_get_basic (&iter_dict_entry, &key);

2067

      dbus_message_iter_next (&iter_dict_entry);

2068

      dbus_message_iter_recurse (&iter_dict_entry, &iter_variant);

2069

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

2070

2071

          _atspi_dbus_set_interfaces (accessible, &iter_variant);

2072

2073

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

2074

2075

          char *iter_sig = dbus_message_iter_get_signature (&iter_variant);

2076

          val = g_new0 (GValue, 1);

2077

2078

          g_value_init (val, G_TYPE_HASH_TABLE);

2079

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

2080

2081

              dbus_free (iter_sig);

2082

              break;

2083

2084

          dbus_free (iter_sig);

2085

          g_value_take_boxed (val, _atspi_dbus_hash_from_iter (&iter_variant));

2086

2087

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

2088

2089

          dbus_int32_t d_int;

2090

          AtspiRect extents;

2091

          char *iter_sig = dbus_message_iter_get_signature (&iter_variant);

2092

          val = g_new0 (GValue, 1);

2093

2094

          g_value_init (val, ATSPI_TYPE_RECT);

2095

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

2096

2097

              dbus_free (iter_sig);

2098

              break;

2099

2100

          dbus_free (iter_sig);

2101

          dbus_message_iter_recurse (&iter_variant, &iter_struct);

2102

          dbus_message_iter_get_basic (&iter_struct, &d_int);

2103

          extents.x = d_int;

2104

          dbus_message_iter_next (&iter_struct);

2105

          dbus_message_iter_get_basic (&iter_struct, &d_int);

2106

          extents.y = d_int;

2107

          dbus_message_iter_next (&iter_struct);

2108

          dbus_message_iter_get_basic (&iter_struct, &d_int);

2109

          extents.width = d_int;

2110

          dbus_message_iter_next (&iter_struct);

2111

          dbus_message_iter_get_basic (&iter_struct, &d_int);

2112

          extents.height = d_int;

2113

          g_value_set_boxed (val, &extents);

2114

2115

      if (val)

2116

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

2117

      dbus_message_iter_next (&iter_dict);

2118

2119

2120

323

  return cache;

2121

2122

2123

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

2124

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

2125

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

2126

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

2127

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

2128

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

2129

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

2130

                                      "    </signal>\n"

2131

                                      "  </interface>\n"

2132

                                      "</node>";

2133

2134

static DBusHandlerResult

2135

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

2136

2137

  if (dbus_message_is_method_call (message, DBUS_INTERFACE_INTROSPECTABLE,

2138

                                   "Introspect"))

2139

2140

      DBusMessage *reply = dbus_message_new_method_return (message);

2141

      dbus_message_append_args (reply, DBUS_TYPE_STRING, &sr_introspection,

2142

                                DBUS_TYPE_INVALID);

2143

      dbus_connection_send (bus, reply, NULL);

2144

      dbus_message_unref (reply);

2145

      return DBUS_HANDLER_RESULT_HANDLED;

2146

2147

  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

2148

2149

2150

gboolean

2151

_atspi_prepare_screen_reader_interface ()

2152

2153

  static gint initialized = 0;

2154

  DBusConnection *a11y_bus = _atspi_bus ();

2155

2156

  if (initialized)

2157

    return (initialized > 0);

2158

2159

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

2160

2161

      initialized = -1;

2162

      return FALSE;

2163

2164

2165

  initialized = 1;

2166

  dbus_connection_add_filter (a11y_bus, screen_reader_filter, NULL, NULL);

2167

  return TRUE;

2168

2169

2170

gchar *

2171

3540

_atspi_strdup_and_adjust_for_dbus (const char *s)

2172

2173

3540

  gchar *d = g_strdup (s);

2174

  gchar *p;

2175

3540

  int parts = 0;

2176

2177

3540

  if (!d)

2178

    return NULL;

2179

2180

71775

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

2181

2182

71773

      if (*p == '-')

2183

2184

3540

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

2185

3540

          *p = toupper (*p);

2186

2187

68233

      else if (*p == ':')

2188

2189

7078

          parts++;

2190

7078

          if (parts == 2)

2191

3538

            break;

2192

3540

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

2193

2194

2195

2196

3540

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

2197

3540

  return d;

2198

2199

2200

/**

2201

 * atspi_get_version:

2202

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

2203

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

2204

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

2205

2206

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

2207

2208

* Since: 2.50

2209

*/

2210

void

2211

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

2212

2213

  if (major)

2214

    *major = ATSPI_MAJOR_VERSION;

2215

  if (minor)

2216

    *minor = ATSPI_MINOR_VERSION;

2217

  if (micro)

2218

    *micro = ATSPI_MICRO_VERSION;

2219

2220

2221

gboolean

2222

_atspi_key_is_on_keypad (gint keycode)

2223

2224

  switch (keycode)

2225

2226

    case 106: /* / */

2227

    case 63:  /* * */

2228

    case 82:  /* - */

2229

    case 79:  /* 7 */

2230

    case 80:  /* 8 */

2231

    case 91:  /* 9 */

2232

    case 86:  /* + */

2233

    case 83:  /* 4 */

2234

    case 84:  /* 5 */

2235

    case 85:  /* 6 */

2236

    case 87:  /* 1 */

2237

    case 88:  /* 2 */

2238

    case 89:  /* 3 */

2239

    case 104: /* enter */

2240

    case 90:  /* 0 */

2241

    case 81:  /* . */

2242

      return TRUE;

2243

    default:

2244

      return FALSE;

2245

2246