~ubuntu-branches/ubuntu/maverick/awn-extras-applets/maverick

static DBusHandlerResult _dbus_wnck_sync_matcher_register_desktop_file_for_pid (WnckSyncMatcher* self, DBusConnection* connection, DBusMessage* message);

255

static DBusHandlerResult _dbus_wnck_sync_matcher_xids_for_desktop_file (WnckSyncMatcher* self, DBusConnection* connection, DBusMessage* message);

256

GType wnck_sync_matcher_dbus_proxy_get_type (void) G_GNUC_CONST;

257

DBusHandlerResult wnck_sync_matcher_dbus_proxy_filter (DBusConnection* connection, DBusMessage* message, void* user_data);

258

enum {

259

WNCK_SYNC_MATCHER_DBUS_PROXY_DUMMY_PROPERTY

260

};

261

static char* wnck_sync_matcher_dbus_proxy_desktop_file_for_xid (WnckSyncMatcher* self, guint32 xid, GError** error);

262

static gboolean wnck_sync_matcher_dbus_proxy_window_match_is_ready (WnckSyncMatcher* self, guint32 xid, GError** error);

263

static void wnck_sync_matcher_dbus_proxy_register_desktop_file_for_pid (WnckSyncMatcher* self, const char* filename, gint32 pid, GError** error);

264

static guint32* wnck_sync_matcher_dbus_proxy_xids_for_desktop_file (WnckSyncMatcher* self, const char* filename, int* result_length1, GError** error);

265

static void wnck_sync_matcher_dbus_proxy_wnck_sync_matcher__interface_init (WnckSyncMatcherIface* iface);

266

static void wnck_sync_matcher_dbus_proxy_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);

267

static void wnck_sync_matcher_dbus_proxy_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);

268

GType desktop_file_info_get_type (void) G_GNUC_CONST;

269

DesktopFileInfo* desktop_file_info_dup (const DesktopFileInfo* self);

270

void desktop_file_info_free (DesktopFileInfo* self);

271

void desktop_file_info_copy (const DesktopFileInfo* self, DesktopFileInfo* dest);

272

void desktop_file_info_destroy (DesktopFileInfo* self);

273

static char** _vala_array_dup1 (char** self, int length);

274

GType related_applet_get_type (void) G_GNUC_CONST;

275

#define RELATED_APPLET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_RELATED_APPLET, RelatedAppletPrivate))

276

enum {

277

RELATED_APPLET_DUMMY_PROPERTY

278

};

279

RelatedApplet* related_applet_new (const char* canonical_name, const char* uid, gint panel_id);

280

RelatedApplet* related_applet_construct (GType object_type, const char* canonical_name, const char* uid, gint panel_id);

281

static void related_applet_window_opened (RelatedApplet* self, WnckWindow* window);

282

static void _related_applet_window_opened_wnck_screen_window_opened (WnckScreen* _sender, WnckWindow* window, gpointer self);

283

static void related_applet_window_changed (RelatedApplet* self, WnckWindow* old_window);

284

static void _related_applet_window_changed_wnck_screen_active_window_changed (WnckScreen* _sender, WnckWindow* previous_window, gpointer self);

285

static void related_applet_on_clicked (RelatedApplet* self);

286

static void _related_applet_on_clicked_awn_applet_simple_clicked (AwnAppletSimple* _sender, gpointer self);

287

static void related_applet_update_star (RelatedApplet* self, const char* desktop_file, GAsyncReadyCallback _callback_, gpointer _user_data_);

288

static void related_applet_update_star_finish (RelatedApplet* self, GAsyncResult* _res_);

289

static void related_applet_update_star_data_free (gpointer _data);

290

static void related_applet_update_star_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);

291

static gboolean related_applet_update_star_co (RelatedAppletUpdateStarData* data);

292

static void _g_list_free_g_object_unref (GList* self);

293

static void related_applet_get_recent_by_mimetype_data_free (gpointer _data);

294

static char** _vala_array_dup2 (char** self, int length);

295

static void related_applet_get_recent_by_mimetype_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);

296

static void related_applet_get_recent_by_mimetype (RelatedApplet* self, char** mimetypes, int mimetypes_length1, GAsyncReadyCallback _callback_, gpointer _user_data_);

297

static gboolean related_applet_get_recent_by_mimetype_finish (RelatedApplet* self, GAsyncResult* _res_);

298

static gboolean related_applet_get_recent_by_mimetype_co (RelatedAppletGetRecentByMimetypeData* data);

299

static gboolean related_applet_push_result (RelatedApplet* self, ZeitgeistEvent* event, ZeitgeistSubject* subject);

300

static void related_applet_get_events_for_actor_data_free (gpointer _data);

301

static void related_applet_get_events_for_actor_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);

302

static void related_applet_get_events_for_actor (RelatedApplet* self, const char* actor, GAsyncReadyCallback _callback_, gpointer _user_data_);

303

static gboolean related_applet_get_events_for_actor_finish (RelatedApplet* self, GAsyncResult* _res_);

304

static gboolean related_applet_get_events_for_actor_co (RelatedAppletGetEventsForActorData* data);

305

static void related_applet_build_dialog_data_free (gpointer _data);

306

static void related_applet_build_dialog_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);

307

static void related_applet_build_dialog (RelatedApplet* self, const char* desktop_file, GAsyncReadyCallback _callback_, gpointer _user_data_);

308

static void related_applet_build_dialog_finish (RelatedApplet* self, GAsyncResult* _res_);

309

static gboolean related_applet_build_dialog_co (RelatedAppletBuildDialogData* data);

310

static void _lambda0_ (Block1Data* _data1_);

311

static void _g_list_free_g_free (GList* self);

312

static void __lambda0__gtk_button_clicked (GtkButton* _sender, gpointer self);

313

static Block1Data* block1_data_ref (Block1Data* _data1_);

314

static void block1_data_unref (Block1Data* _data1_);

315

static GObject * related_applet_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);

316

static void related_applet_finalize (GObject* obj);

317

AwnApplet* awn_applet_factory_initp (const char* canonical_name, const char* uid, gint panel_id);

318

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);

319

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);

320

static int _vala_strcmp0 (const char * str1, const char * str2);

321

322

static const DBusObjectPathVTable _wnck_sync_matcher_dbus_path_vtable = {_wnck_sync_matcher_dbus_unregister, wnck_sync_matcher_dbus_message};

323

static const _DBusObjectVTable _wnck_sync_matcher_dbus_vtable = {wnck_sync_matcher_dbus_register_object};

324

325

326

char* wnck_sync_matcher_desktop_file_for_xid (WnckSyncMatcher* self, guint32 xid, GError** error) {

327

return WNCK_SYNC_MATCHER_GET_INTERFACE (self)->desktop_file_for_xid (self, xid, error);

328

}

329

330

331

gboolean wnck_sync_matcher_window_match_is_ready (WnckSyncMatcher* self, guint32 xid, GError** error) {

332

return WNCK_SYNC_MATCHER_GET_INTERFACE (self)->window_match_is_ready (self, xid, error);

333

}

334

335

336

void wnck_sync_matcher_register_desktop_file_for_pid (WnckSyncMatcher* self, const char* filename, gint32 pid, GError** error) {

337

WNCK_SYNC_MATCHER_GET_INTERFACE (self)->register_desktop_file_for_pid (self, filename, pid, error);

338

}

339

340

341

guint32* wnck_sync_matcher_xids_for_desktop_file (WnckSyncMatcher* self, const char* filename, int* result_length1, GError** error) {

342

return WNCK_SYNC_MATCHER_GET_INTERFACE (self)->xids_for_desktop_file (self, filename, result_length1, error);

343

}

344

345

346

static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object) {

347

const _DBusObjectVTable * vtable;

348

vtable = g_type_get_qdata (G_TYPE_FROM_INSTANCE (object), g_quark_from_static_string ("DBusObjectVTable"));

349

if (vtable) {

350

vtable->register_object (connection, path, object);

351

} else {

352

g_warning ("Object does not implement any D-Bus interface");

353

}

354

}

355

356

357

static void _vala_dbus_unregister_object (gpointer connection, GObject* object) {

358

char* path;

359

path = g_object_steal_data ((GObject*) object, "dbus_object_path");

360

dbus_connection_unregister_object_path (connection, path);

361

g_free (path);

362

}

363

364

365

void _wnck_sync_matcher_dbus_unregister (DBusConnection* connection, void* _user_data_) {

366

}

367

368

369

static DBusHandlerResult _dbus_wnck_sync_matcher_introspect (WnckSyncMatcher* self, DBusConnection* connection, DBusMessage* message) {

370

DBusMessage* reply;

371

DBusMessageIter iter;

372

GString* xml_data;

373

char** children;

374

int i;

375

reply = dbus_message_new_method_return (message);

376

dbus_message_iter_init_append (reply, &iter);

377

xml_data = g_string_new ("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n");

378

g_string_append (xml_data, "<node>\n<interface name=\"org.freedesktop.DBus.Introspectable\">\n <method name=\"Introspect\">\n <arg name=\"data\" direction=\"out\" type=\"s\"/>\n </method>\n</interface>\n<interface name=\"org.freedesktop.DBus.Properties\">\n <method name=\"Get\">\n <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n <arg name=\"value\" direction=\"out\" type=\"v\"/>\n </method>\n <method name=\"Set\">\n <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n <arg name=\"value\" direction=\"in\" type=\"v\"/>\n </method>\n <method name=\"GetAll\">\n <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n <arg name=\"props\" direction=\"out\" type=\"a{sv}\"/>\n </method>\n</interface>\n<interface name=\"org.wncksync.Matcher\">\n <method name=\"DesktopFileForXid\">\n <arg name=\"xid\" type=\"u\" direction=\"in\"/>\n <arg name=\"result\" type=\"s\" direction=\"out\"/>\n </method>\n <method name=\"WindowMatchIsReady\">\n <arg name=\"xid\" type=\"u\" direction=\"in\"/>\n <arg name=\"result\" type=\"b\" direction=\"out\"/>\n </method>\n <method name=\"RegisterDesktopFileForPid\">\n <arg name=\"filename\" type=\"s\" direction=\"in\"/>\n <arg name=\"pid\" type=\"i\" direction=\"in\"/>\n </method>\n <method name=\"XidsForDesktopFile\">\n <arg name=\"filename\" type=\"s\" direction=\"in\"/>\n <arg name=\"result\" type=\"au\" direction=\"out\"/>\n </method>\n</interface>\n");

379

dbus_connection_list_registered (connection, g_object_get_data ((GObject *) self, "dbus_object_path"), &children);

380

for (i = 0; children[i]; i++) {

381

g_string_append_printf (xml_data, "<node name=\"%s\"/>\n", children[i]);

382

}

383

dbus_free_string_array (children);

384

g_string_append (xml_data, "</node>\n");

385

dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &xml_data->str);

386

g_string_free (xml_data, TRUE);

387

if (reply) {

388

dbus_connection_send (connection, reply, NULL);

389

dbus_message_unref (reply);

390

return DBUS_HANDLER_RESULT_HANDLED;

391

} else {

392

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

393

}

394

}

395

396

397

static DBusHandlerResult _dbus_wnck_sync_matcher_property_get_all (WnckSyncMatcher* self, DBusConnection* connection, DBusMessage* message) {

398

DBusMessage* reply;

399

DBusMessageIter iter, reply_iter, subiter;

400

char* interface_name;

401

const char* _tmp0_;

402

if (strcmp (dbus_message_get_signature (message), "s")) {

403

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

404

}

405

dbus_message_iter_init (message, &iter);

406

reply = dbus_message_new_method_return (message);

407

dbus_message_iter_init_append (reply, &reply_iter);

408

dbus_message_iter_get_basic (&iter, &_tmp0_);

409

dbus_message_iter_next (&iter);

410

interface_name = g_strdup (_tmp0_);

411

if (strcmp (interface_name, "org.wncksync.Matcher") == 0) {

412

dbus_message_iter_open_container (&reply_iter, DBUS_TYPE_ARRAY, "{sv}", &subiter);

413

dbus_message_iter_close_container (&reply_iter, &subiter);

414

} else {

415

dbus_message_unref (reply);

416

reply = NULL;

417

}

418

g_free (interface_name);

419

if (reply) {

420

dbus_connection_send (connection, reply, NULL);

421

dbus_message_unref (reply);

422

return DBUS_HANDLER_RESULT_HANDLED;

423

} else {

424

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

425

}

426

}

427

428

429

static DBusHandlerResult _dbus_wnck_sync_matcher_desktop_file_for_xid (WnckSyncMatcher* self, DBusConnection* connection, DBusMessage* message) {

430

DBusMessageIter iter;

431

GError* error;

432

guint32 xid = 0U;

433

dbus_uint32_t _tmp1_;

434

char* result;

435

DBusMessage* reply;

436

const char* _tmp2_;

437

error = NULL;

438

if (strcmp (dbus_message_get_signature (message), "u")) {

439

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

440

}

441

dbus_message_iter_init (message, &iter);

442

dbus_message_iter_get_basic (&iter, &_tmp1_);

443

dbus_message_iter_next (&iter);

444

xid = _tmp1_;

445

result = wnck_sync_matcher_desktop_file_for_xid (self, xid, &error);

446

if (error) {

447

if (error->domain == DBUS_GERROR) {

448

switch (error->code) {

449

case DBUS_GERROR_FAILED:

450

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);

451

break;

452

case DBUS_GERROR_NO_MEMORY:

453

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);

454

break;

455

case DBUS_GERROR_SERVICE_UNKNOWN:

456

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);

457

break;

458

case DBUS_GERROR_NAME_HAS_NO_OWNER:

459

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);

460

break;

461

case DBUS_GERROR_NO_REPLY:

462

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);

463

break;

464

case DBUS_GERROR_IO_ERROR:

465

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);

466

break;

467

case DBUS_GERROR_BAD_ADDRESS:

468

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);

469

break;

470

case DBUS_GERROR_NOT_SUPPORTED:

471

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);

472

break;

473

case DBUS_GERROR_LIMITS_EXCEEDED:

474

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);

475

break;

476

case DBUS_GERROR_ACCESS_DENIED:

477

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);

478

break;

479

case DBUS_GERROR_AUTH_FAILED:

480

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);

481

break;

482

case DBUS_GERROR_NO_SERVER:

483

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);

484

break;

485

case DBUS_GERROR_TIMEOUT:

486

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);

487

break;

488

case DBUS_GERROR_NO_NETWORK:

489

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);

490

break;

491

case DBUS_GERROR_ADDRESS_IN_USE:

492

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);

493

break;

494

case DBUS_GERROR_DISCONNECTED:

495

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);

496

break;

497

case DBUS_GERROR_INVALID_ARGS:

498

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);

499

break;

500

case DBUS_GERROR_FILE_NOT_FOUND:

501

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);

502

break;

503

case DBUS_GERROR_FILE_EXISTS:

504

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);

505

break;

506

case DBUS_GERROR_UNKNOWN_METHOD:

507

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);

508

break;

509

case DBUS_GERROR_TIMED_OUT:

510

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);

511

break;

512

case DBUS_GERROR_MATCH_RULE_NOT_FOUND:

513

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);

514

break;

515

case DBUS_GERROR_MATCH_RULE_INVALID:

516

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);

517

break;

518

case DBUS_GERROR_SPAWN_EXEC_FAILED:

519

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);

520

break;

521

case DBUS_GERROR_SPAWN_FORK_FAILED:

522

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);

523

break;

524

case DBUS_GERROR_SPAWN_CHILD_EXITED:

525

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);

526

break;

527

case DBUS_GERROR_SPAWN_CHILD_SIGNALED:

528

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);

529

break;

530

case DBUS_GERROR_SPAWN_FAILED:

531

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);

532

break;

533

case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:

534

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);

535

break;

536

case DBUS_GERROR_INVALID_SIGNATURE:

537

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);

538

break;

539

case DBUS_GERROR_INVALID_FILE_CONTENT:

540

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);

541

break;

542

case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:

543

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);

544

break;

545

case DBUS_GERROR_REMOTE_EXCEPTION:

546

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);

547

break;

548

}

549

}

550

dbus_connection_send (connection, reply, NULL);

551

dbus_message_unref (reply);

552

return DBUS_HANDLER_RESULT_HANDLED;

553

}

554

reply = dbus_message_new_method_return (message);

555

dbus_message_iter_init_append (reply, &iter);

556

_tmp2_ = result;

557

dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &_tmp2_);

558

_g_free0 (result);

559

if (reply) {

560

dbus_connection_send (connection, reply, NULL);

561

dbus_message_unref (reply);

562

return DBUS_HANDLER_RESULT_HANDLED;

563

} else {

564

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

565

}

566

}

567

568

569

static DBusHandlerResult _dbus_wnck_sync_matcher_window_match_is_ready (WnckSyncMatcher* self, DBusConnection* connection, DBusMessage* message) {

570

DBusMessageIter iter;

571

GError* error;

572

guint32 xid = 0U;

573

dbus_uint32_t _tmp3_;

574

gboolean result;

575

DBusMessage* reply;

576

dbus_bool_t _tmp4_;

577

error = NULL;

578

if (strcmp (dbus_message_get_signature (message), "u")) {

579

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

580

}

581

dbus_message_iter_init (message, &iter);

582

dbus_message_iter_get_basic (&iter, &_tmp3_);

583

dbus_message_iter_next (&iter);

584

xid = _tmp3_;

585

result = wnck_sync_matcher_window_match_is_ready (self, xid, &error);

586

if (error) {

587

if (error->domain == DBUS_GERROR) {

588

switch (error->code) {

589

case DBUS_GERROR_FAILED:

590

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);

591

break;

592

case DBUS_GERROR_NO_MEMORY:

593

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);

594

break;

595

case DBUS_GERROR_SERVICE_UNKNOWN:

596

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);

597

break;

598

case DBUS_GERROR_NAME_HAS_NO_OWNER:

599

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);

600

break;

601

case DBUS_GERROR_NO_REPLY:

602

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);

603

break;

604

case DBUS_GERROR_IO_ERROR:

605

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);

606

break;

607

case DBUS_GERROR_BAD_ADDRESS:

608

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);

609

break;

610

case DBUS_GERROR_NOT_SUPPORTED:

611

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);

612

break;

613

case DBUS_GERROR_LIMITS_EXCEEDED:

614

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);

615

break;

616

case DBUS_GERROR_ACCESS_DENIED:

617

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);

618

break;

619

case DBUS_GERROR_AUTH_FAILED:

620

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);

621

break;

622

case DBUS_GERROR_NO_SERVER:

623

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);

624

break;

625

case DBUS_GERROR_TIMEOUT:

626

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);

627

break;

628

case DBUS_GERROR_NO_NETWORK:

629

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);

630

break;

631

case DBUS_GERROR_ADDRESS_IN_USE:

632

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);

633

break;

634

case DBUS_GERROR_DISCONNECTED:

635

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);

636

break;

637

case DBUS_GERROR_INVALID_ARGS:

638

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);

639

break;

640

case DBUS_GERROR_FILE_NOT_FOUND:

641

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);

642

break;

643

case DBUS_GERROR_FILE_EXISTS:

644

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);

645

break;

646

case DBUS_GERROR_UNKNOWN_METHOD:

647

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);

648

break;

649

case DBUS_GERROR_TIMED_OUT:

650

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);

651

break;

652

case DBUS_GERROR_MATCH_RULE_NOT_FOUND:

653

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);

654

break;

655

case DBUS_GERROR_MATCH_RULE_INVALID:

656

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);

657

break;

658

case DBUS_GERROR_SPAWN_EXEC_FAILED:

659

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);

660

break;

661

case DBUS_GERROR_SPAWN_FORK_FAILED:

662

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);

663

break;

664

case DBUS_GERROR_SPAWN_CHILD_EXITED:

665

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);

666

break;

667

case DBUS_GERROR_SPAWN_CHILD_SIGNALED:

668

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);

669

break;

670

case DBUS_GERROR_SPAWN_FAILED:

671

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);

672

break;

673

case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:

674

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);

675

break;

676

case DBUS_GERROR_INVALID_SIGNATURE:

677

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);

678

break;

679

case DBUS_GERROR_INVALID_FILE_CONTENT:

680

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);

681

break;

682

case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:

683

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);

684

break;

685

case DBUS_GERROR_REMOTE_EXCEPTION:

686

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);

687

break;

688

}

689

}

690

dbus_connection_send (connection, reply, NULL);

691

dbus_message_unref (reply);

692

return DBUS_HANDLER_RESULT_HANDLED;

693

}

694

reply = dbus_message_new_method_return (message);

695

dbus_message_iter_init_append (reply, &iter);

696

_tmp4_ = result;

697

dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &_tmp4_);

698

if (reply) {

699

dbus_connection_send (connection, reply, NULL);

700

dbus_message_unref (reply);

701

return DBUS_HANDLER_RESULT_HANDLED;

702

} else {

703

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

704

}

705

}

706

707

708

static DBusHandlerResult _dbus_wnck_sync_matcher_register_desktop_file_for_pid (WnckSyncMatcher* self, DBusConnection* connection, DBusMessage* message) {

709

DBusMessageIter iter;

710

GError* error;

711

char* filename = NULL;

712

const char* _tmp5_;

713

gint32 pid = 0;

714

dbus_int32_t _tmp6_;

715

DBusMessage* reply;

716

error = NULL;

717

if (strcmp (dbus_message_get_signature (message), "si")) {

718

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

719

}

720

dbus_message_iter_init (message, &iter);

721

dbus_message_iter_get_basic (&iter, &_tmp5_);

722

dbus_message_iter_next (&iter);

723

filename = g_strdup (_tmp5_);

724

dbus_message_iter_get_basic (&iter, &_tmp6_);

725

dbus_message_iter_next (&iter);

726

pid = _tmp6_;

727

wnck_sync_matcher_register_desktop_file_for_pid (self, filename, pid, &error);

728

if (error) {

729

if (error->domain == DBUS_GERROR) {

730

switch (error->code) {

731

case DBUS_GERROR_FAILED:

732

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);

733

break;

734

case DBUS_GERROR_NO_MEMORY:

735

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);

736

break;

737

case DBUS_GERROR_SERVICE_UNKNOWN:

738

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);

739

break;

740

case DBUS_GERROR_NAME_HAS_NO_OWNER:

741

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);

742

break;

743

case DBUS_GERROR_NO_REPLY:

744

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);

745

break;

746

case DBUS_GERROR_IO_ERROR:

747

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);

748

break;

749

case DBUS_GERROR_BAD_ADDRESS:

750

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);

751

break;

752

case DBUS_GERROR_NOT_SUPPORTED:

753

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);

754

break;

755

case DBUS_GERROR_LIMITS_EXCEEDED:

756

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);

757

break;

758

case DBUS_GERROR_ACCESS_DENIED:

759

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);

760

break;

761

case DBUS_GERROR_AUTH_FAILED:

762

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);

763

break;

764

case DBUS_GERROR_NO_SERVER:

765

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);

766

break;

767

case DBUS_GERROR_TIMEOUT:

768

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);

769

break;

770

case DBUS_GERROR_NO_NETWORK:

771

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);

772

break;

773

case DBUS_GERROR_ADDRESS_IN_USE:

774

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);

775

break;

776

case DBUS_GERROR_DISCONNECTED:

777

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);

778

break;

779

case DBUS_GERROR_INVALID_ARGS:

780

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);

781

break;

782

case DBUS_GERROR_FILE_NOT_FOUND:

783

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);

784

break;

785

case DBUS_GERROR_FILE_EXISTS:

786

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);

787

break;

788

case DBUS_GERROR_UNKNOWN_METHOD:

789

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);

790

break;

791

case DBUS_GERROR_TIMED_OUT:

792

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);

793

break;

794

case DBUS_GERROR_MATCH_RULE_NOT_FOUND:

795

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);

796

break;

797

case DBUS_GERROR_MATCH_RULE_INVALID:

798

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);

799

break;

800

case DBUS_GERROR_SPAWN_EXEC_FAILED:

801

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);

802

break;

803

case DBUS_GERROR_SPAWN_FORK_FAILED:

804

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);

805

break;

806

case DBUS_GERROR_SPAWN_CHILD_EXITED:

807

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);

808

break;

809

case DBUS_GERROR_SPAWN_CHILD_SIGNALED:

810

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);

811

break;

812

case DBUS_GERROR_SPAWN_FAILED:

813

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);

814

break;

815

case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:

816

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);

817

break;

818

case DBUS_GERROR_INVALID_SIGNATURE:

819

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);

820

break;

821

case DBUS_GERROR_INVALID_FILE_CONTENT:

822

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);

823

break;

824

case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:

825

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);

826

break;

827

case DBUS_GERROR_REMOTE_EXCEPTION:

828

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);

829

break;

830

}

831

}

832

dbus_connection_send (connection, reply, NULL);

833

dbus_message_unref (reply);

834

return DBUS_HANDLER_RESULT_HANDLED;

835

}

836

reply = dbus_message_new_method_return (message);

837

dbus_message_iter_init_append (reply, &iter);

838

_g_free0 (filename);

839

if (reply) {

840

dbus_connection_send (connection, reply, NULL);

841

dbus_message_unref (reply);

842

return DBUS_HANDLER_RESULT_HANDLED;

843

} else {

844

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

845

}

846

}

847

848

849

static DBusHandlerResult _dbus_wnck_sync_matcher_xids_for_desktop_file (WnckSyncMatcher* self, DBusConnection* connection, DBusMessage* message) {

850

DBusMessageIter iter;

851

GError* error;

852

char* filename = NULL;

853

const char* _tmp7_;

854

guint32* result;

855

int result_length1;

856

DBusMessage* reply;

857

guint32* _tmp8_;

858

DBusMessageIter _tmp9_;

859

int _tmp10_;

860

error = NULL;

861

if (strcmp (dbus_message_get_signature (message), "s")) {

862

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

863

}

864

dbus_message_iter_init (message, &iter);

865

dbus_message_iter_get_basic (&iter, &_tmp7_);

866

dbus_message_iter_next (&iter);

867

filename = g_strdup (_tmp7_);

868

result_length1 = 0;

869

result = wnck_sync_matcher_xids_for_desktop_file (self, filename, &result_length1, &error);

870

if (error) {

871

if (error->domain == DBUS_GERROR) {

872

switch (error->code) {

873

case DBUS_GERROR_FAILED:

874

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);

875

break;

876

case DBUS_GERROR_NO_MEMORY:

877

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);

878

break;

879

case DBUS_GERROR_SERVICE_UNKNOWN:

880

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);

881

break;

882

case DBUS_GERROR_NAME_HAS_NO_OWNER:

883

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);

884

break;

885

case DBUS_GERROR_NO_REPLY:

886

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);

887

break;

888

case DBUS_GERROR_IO_ERROR:

889

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);

890

break;

891

case DBUS_GERROR_BAD_ADDRESS:

892

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);

893

break;

894

case DBUS_GERROR_NOT_SUPPORTED:

895

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);

896

break;

897

case DBUS_GERROR_LIMITS_EXCEEDED:

898

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);

899

break;

900

case DBUS_GERROR_ACCESS_DENIED:

901

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);

902

break;

903

case DBUS_GERROR_AUTH_FAILED:

904

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);

905

break;

906

case DBUS_GERROR_NO_SERVER:

907

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);

908

break;

909

case DBUS_GERROR_TIMEOUT:

910

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);

911

break;

912

case DBUS_GERROR_NO_NETWORK:

913

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);

914

break;

915

case DBUS_GERROR_ADDRESS_IN_USE:

916

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);

917

break;

918

case DBUS_GERROR_DISCONNECTED:

919

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);

920

break;

921

case DBUS_GERROR_INVALID_ARGS:

922

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);

923

break;

924

case DBUS_GERROR_FILE_NOT_FOUND:

925

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);

926

break;

927

case DBUS_GERROR_FILE_EXISTS:

928

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);

929

break;

930

case DBUS_GERROR_UNKNOWN_METHOD:

931

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);

932

break;

933

case DBUS_GERROR_TIMED_OUT:

934

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);

935

break;

936

case DBUS_GERROR_MATCH_RULE_NOT_FOUND:

937

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);

938

break;

939

case DBUS_GERROR_MATCH_RULE_INVALID:

940

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);

941

break;

942

case DBUS_GERROR_SPAWN_EXEC_FAILED:

943

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);

944

break;

945

case DBUS_GERROR_SPAWN_FORK_FAILED:

946

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);

947

break;

948

case DBUS_GERROR_SPAWN_CHILD_EXITED:

949

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);

950

break;

951

case DBUS_GERROR_SPAWN_CHILD_SIGNALED:

952

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);

953

break;

954

case DBUS_GERROR_SPAWN_FAILED:

955

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);

956

break;

957

case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:

958

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);

959

break;

960

case DBUS_GERROR_INVALID_SIGNATURE:

961

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);

962

break;

963

case DBUS_GERROR_INVALID_FILE_CONTENT:

964

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);

965

break;

966

case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:

967

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);

968

break;

969

case DBUS_GERROR_REMOTE_EXCEPTION:

970

reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);

971

break;

972

}

973

}

974

dbus_connection_send (connection, reply, NULL);

975

dbus_message_unref (reply);

976

return DBUS_HANDLER_RESULT_HANDLED;

977

}

978

reply = dbus_message_new_method_return (message);

979

dbus_message_iter_init_append (reply, &iter);

980

_g_free0 (filename);

981

_tmp8_ = result;

982

dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "u", &_tmp9_);

983

for (_tmp10_ = 0; _tmp10_ < result_length1; _tmp10_++) {

984

dbus_uint32_t _tmp11_;

985

_tmp11_ = *_tmp8_;

986

dbus_message_iter_append_basic (&_tmp9_, DBUS_TYPE_UINT32, &_tmp11_);

987

_tmp8_++;

988

}

989

dbus_message_iter_close_container (&iter, &_tmp9_);

990

result = (g_free (result), NULL);

991

if (reply) {

992

dbus_connection_send (connection, reply, NULL);

993

dbus_message_unref (reply);

994

return DBUS_HANDLER_RESULT_HANDLED;

995

} else {

996

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

997

}

998

}

999

1000

1001

DBusHandlerResult wnck_sync_matcher_dbus_message (DBusConnection* connection, DBusMessage* message, void* object) {

1002

DBusHandlerResult result;

1003

result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1004

if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {

1005

result = _dbus_wnck_sync_matcher_introspect (object, connection, message);

1006

} else if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Properties", "GetAll")) {

1007

result = _dbus_wnck_sync_matcher_property_get_all (object, connection, message);

1008

} else if (dbus_message_is_method_call (message, "org.wncksync.Matcher", "DesktopFileForXid")) {

1009

result = _dbus_wnck_sync_matcher_desktop_file_for_xid (object, connection, message);

1010

} else if (dbus_message_is_method_call (message, "org.wncksync.Matcher", "WindowMatchIsReady")) {

1011

result = _dbus_wnck_sync_matcher_window_match_is_ready (object, connection, message);

1012

} else if (dbus_message_is_method_call (message, "org.wncksync.Matcher", "RegisterDesktopFileForPid")) {

1013

result = _dbus_wnck_sync_matcher_register_desktop_file_for_pid (object, connection, message);

1014

} else if (dbus_message_is_method_call (message, "org.wncksync.Matcher", "XidsForDesktopFile")) {

1015

result = _dbus_wnck_sync_matcher_xids_for_desktop_file (object, connection, message);

1016

}

1017

if (result == DBUS_HANDLER_RESULT_HANDLED) {

1018

return result;

1019

} else {

1020

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1021

}

1022

}

1023

1024

1025

void wnck_sync_matcher_dbus_register_object (DBusConnection* connection, const char* path, void* object) {

1026

if (!g_object_get_data (object, "dbus_object_path")) {

1027

g_object_set_data (object, "dbus_object_path", g_strdup (path));

1028

dbus_connection_register_object_path (connection, path, &_wnck_sync_matcher_dbus_path_vtable, object);

1029

g_object_weak_ref (object, _vala_dbus_unregister_object, connection);

1030

}

1031

}

1032

1033

1034

static void wnck_sync_matcher_base_init (WnckSyncMatcherIface * iface) {

1035

static gboolean initialized = FALSE;

1036

if (!initialized) {

1037

initialized = TRUE;

1038

g_type_set_qdata (TYPE_WNCK_SYNC_MATCHER, g_quark_from_static_string ("DBusObjectVTable"), (void*) (&_wnck_sync_matcher_dbus_vtable));

1039

}

1040

}

1041

1042

1043

GType wnck_sync_matcher_get_type (void) {

1044

static volatile gsize wnck_sync_matcher_type_id__volatile = 0;

1045

if (g_once_init_enter (&wnck_sync_matcher_type_id__volatile)) {

1046

static const GTypeInfo g_define_type_info = { sizeof (WnckSyncMatcherIface), (GBaseInitFunc) wnck_sync_matcher_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };

1047

GType wnck_sync_matcher_type_id;

1048

wnck_sync_matcher_type_id = g_type_register_static (G_TYPE_INTERFACE, "WnckSyncMatcher", &g_define_type_info, 0);

1049

g_type_interface_add_prerequisite (wnck_sync_matcher_type_id, G_TYPE_OBJECT);

1050

g_type_set_qdata (wnck_sync_matcher_type_id, g_quark_from_string ("ValaDBusInterfaceProxyType"), &wnck_sync_matcher_dbus_proxy_get_type);

1051

g_once_init_leave (&wnck_sync_matcher_type_id__volatile, wnck_sync_matcher_type_id);

1052

}

1053

return wnck_sync_matcher_type_id__volatile;

1054

}

1055

1056

1057

G_DEFINE_TYPE_EXTENDED (WnckSyncMatcherDBusProxy, wnck_sync_matcher_dbus_proxy, DBUS_TYPE_G_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_WNCK_SYNC_MATCHER, wnck_sync_matcher_dbus_proxy_wnck_sync_matcher__interface_init) );

1058

WnckSyncMatcher* wnck_sync_matcher_dbus_proxy_new (DBusGConnection* connection, const char* name, const char* path) {

1059

WnckSyncMatcher* self;

1060

self = g_object_new (wnck_sync_matcher_dbus_proxy_get_type (), "connection", connection, "name", name, "path", path, "interface", "org.wncksync.Matcher", NULL);

1061

return self;

1062

}

1063

1064

1065

static GObject* wnck_sync_matcher_dbus_proxy_construct (GType gtype, guint n_properties, GObjectConstructParam* properties) {

1066

GObject* self;

1067

DBusGConnection *connection;

1068

char* path;

1069

char* filter;

1070

self = G_OBJECT_CLASS (wnck_sync_matcher_dbus_proxy_parent_class)->constructor (gtype, n_properties, properties);

1071

g_object_get (self, "connection", &connection, NULL);

1072

g_object_get (self, "path", &path, NULL);

1073

dbus_connection_add_filter (dbus_g_connection_get_connection (connection), wnck_sync_matcher_dbus_proxy_filter, self, NULL);

1074

filter = g_strdup_printf ("type='signal',path='%s'", path);

1075

dbus_bus_add_match (dbus_g_connection_get_connection (connection), filter, NULL);

1076

dbus_g_connection_unref (connection);

1077

g_free (path);

1078

g_free (filter);

1079

return self;

1080

}

1081

1082

1083

DBusHandlerResult wnck_sync_matcher_dbus_proxy_filter (DBusConnection* connection, DBusMessage* message, void* user_data) {

1084

if (dbus_message_has_path (message, dbus_g_proxy_get_path (user_data))) {

1085

}

1086

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

1087

}

1088

1089

1090

static void wnck_sync_matcher_dbus_proxy_dispose (GObject* self) {

1091

DBusGConnection *connection;

1092

if (((WnckSyncMatcherDBusProxy*) self)->disposed) {

1093

return;

1094

}

1095

((WnckSyncMatcherDBusProxy*) self)->disposed = TRUE;

1096

g_object_get (self, "connection", &connection, NULL);

1097

dbus_connection_remove_filter (dbus_g_connection_get_connection (connection), wnck_sync_matcher_dbus_proxy_filter, self);

1098

G_OBJECT_CLASS (wnck_sync_matcher_dbus_proxy_parent_class)->dispose (self);

1099

}

1100

1101

1102

static void wnck_sync_matcher_dbus_proxy_class_init (WnckSyncMatcherDBusProxyClass* klass) {

1103

G_OBJECT_CLASS (klass)->constructor = wnck_sync_matcher_dbus_proxy_construct;

1104

G_OBJECT_CLASS (klass)->dispose = wnck_sync_matcher_dbus_proxy_dispose;

1105

G_OBJECT_CLASS (klass)->get_property = wnck_sync_matcher_dbus_proxy_get_property;

1106

G_OBJECT_CLASS (klass)->set_property = wnck_sync_matcher_dbus_proxy_set_property;

1107

}

1108

1109

1110

static void wnck_sync_matcher_dbus_proxy_init (WnckSyncMatcherDBusProxy* self) {

1111

}

1112

1113

1114

static char* wnck_sync_matcher_dbus_proxy_desktop_file_for_xid (WnckSyncMatcher* self, guint32 xid, GError** error) {

1115

DBusError _dbus_error;

1116

DBusGConnection *_connection;

1117

DBusMessage *_message, *_reply;

1118

DBusMessageIter _iter;

1119

dbus_uint32_t _tmp0_;

1120

char* _result;

1121

const char* _tmp1_;

1122

if (((WnckSyncMatcherDBusProxy*) self)->disposed) {

1123

g_set_error (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "%s", "Connection is closed");

1124

return NULL;

1125

}

1126

_message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.wncksync.Matcher", "DesktopFileForXid");

1127

dbus_message_iter_init_append (_message, &_iter);

1128

_tmp0_ = xid;

1129

dbus_message_iter_append_basic (&_iter, DBUS_TYPE_UINT32, &_tmp0_);

1130

g_object_get (self, "connection", &_connection, NULL);

1131

dbus_error_init (&_dbus_error);

1132

_reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);

1133

dbus_g_connection_unref (_connection);

1134

dbus_message_unref (_message);

1135

if (dbus_error_is_set (&_dbus_error)) {

1136

GQuark _edomain;

1137

gint _ecode;

1138

if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {

1139

const char* _tmp2_;

1140

_edomain = DBUS_GERROR;

1141

_tmp2_ = _dbus_error.name + 27;

1142

if (strcmp (_tmp2_, "Failed") == 0) {

1143

_ecode = DBUS_GERROR_FAILED;

1144

} else if (strcmp (_tmp2_, "NoMemory") == 0) {

1145

_ecode = DBUS_GERROR_NO_MEMORY;

1146

} else if (strcmp (_tmp2_, "ServiceUnknown") == 0) {

1147

_ecode = DBUS_GERROR_SERVICE_UNKNOWN;

1148

} else if (strcmp (_tmp2_, "NameHasNoOwner") == 0) {

1149

_ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;

1150

} else if (strcmp (_tmp2_, "NoReply") == 0) {

1151

_ecode = DBUS_GERROR_NO_REPLY;

1152

} else if (strcmp (_tmp2_, "IOError") == 0) {

1153

_ecode = DBUS_GERROR_IO_ERROR;

1154

} else if (strcmp (_tmp2_, "BadAddress") == 0) {

1155

_ecode = DBUS_GERROR_BAD_ADDRESS;

1156

} else if (strcmp (_tmp2_, "NotSupported") == 0) {

1157

_ecode = DBUS_GERROR_NOT_SUPPORTED;

1158

} else if (strcmp (_tmp2_, "LimitsExceeded") == 0) {

1159

_ecode = DBUS_GERROR_LIMITS_EXCEEDED;

1160

} else if (strcmp (_tmp2_, "AccessDenied") == 0) {

1161

_ecode = DBUS_GERROR_ACCESS_DENIED;

1162

} else if (strcmp (_tmp2_, "AuthFailed") == 0) {

1163

_ecode = DBUS_GERROR_AUTH_FAILED;

1164

} else if (strcmp (_tmp2_, "NoServer") == 0) {

1165

_ecode = DBUS_GERROR_NO_SERVER;

1166

} else if (strcmp (_tmp2_, "Timeout") == 0) {

1167

_ecode = DBUS_GERROR_TIMEOUT;

1168

} else if (strcmp (_tmp2_, "NoNetwork") == 0) {

1169

_ecode = DBUS_GERROR_NO_NETWORK;

1170

} else if (strcmp (_tmp2_, "AddressInUse") == 0) {

1171

_ecode = DBUS_GERROR_ADDRESS_IN_USE;

1172

} else if (strcmp (_tmp2_, "Disconnected") == 0) {

1173

_ecode = DBUS_GERROR_DISCONNECTED;

1174

} else if (strcmp (_tmp2_, "InvalidArgs") == 0) {

1175

_ecode = DBUS_GERROR_INVALID_ARGS;

1176

} else if (strcmp (_tmp2_, "FileNotFound") == 0) {

1177

_ecode = DBUS_GERROR_FILE_NOT_FOUND;

1178

} else if (strcmp (_tmp2_, "FileExists") == 0) {

1179

_ecode = DBUS_GERROR_FILE_EXISTS;

1180

} else if (strcmp (_tmp2_, "UnknownMethod") == 0) {

1181

_ecode = DBUS_GERROR_UNKNOWN_METHOD;

1182

} else if (strcmp (_tmp2_, "TimedOut") == 0) {

1183

_ecode = DBUS_GERROR_TIMED_OUT;

1184

} else if (strcmp (_tmp2_, "MatchRuleNotFound") == 0) {

1185

_ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;

1186

} else if (strcmp (_tmp2_, "MatchRuleInvalid") == 0) {

1187

_ecode = DBUS_GERROR_MATCH_RULE_INVALID;

1188

} else if (strcmp (_tmp2_, "Spawn.ExecFailed") == 0) {

1189

_ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;

1190

} else if (strcmp (_tmp2_, "Spawn.ForkFailed") == 0) {

1191

_ecode = DBUS_GERROR_SPAWN_FORK_FAILED;

1192

} else if (strcmp (_tmp2_, "Spawn.ChildExited") == 0) {

1193

_ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;

1194

} else if (strcmp (_tmp2_, "Spawn.ChildSignaled") == 0) {

1195

_ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;

1196

} else if (strcmp (_tmp2_, "Spawn.Failed") == 0) {

1197

_ecode = DBUS_GERROR_SPAWN_FAILED;

1198

} else if (strcmp (_tmp2_, "UnixProcessIdUnknown") == 0) {

1199

_ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;

1200

} else if (strcmp (_tmp2_, "InvalidSignature") == 0) {

1201

_ecode = DBUS_GERROR_INVALID_SIGNATURE;

1202

} else if (strcmp (_tmp2_, "InvalidFileContent") == 0) {

1203

_ecode = DBUS_GERROR_INVALID_FILE_CONTENT;

1204

} else if (strcmp (_tmp2_, "SELinuxSecurityContextUnknown") == 0) {

1205

_ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;

1206

} else if (strcmp (_tmp2_, "RemoteException") == 0) {

1207

_ecode = DBUS_GERROR_REMOTE_EXCEPTION;

1208

}

1209

}

1210

g_set_error (error, _edomain, _ecode, "%s", _dbus_error.message);

1211

dbus_error_free (&_dbus_error);

1212

return NULL;

1213

}

1214

if (strcmp (dbus_message_get_signature (_reply), "s")) {

1215

g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "s", dbus_message_get_signature (_reply));

1216

dbus_message_unref (_reply);

1217

return NULL;

1218

}

1219

dbus_message_iter_init (_reply, &_iter);

1220

dbus_message_iter_get_basic (&_iter, &_tmp1_);

1221

dbus_message_iter_next (&_iter);

1222

_result = g_strdup (_tmp1_);

1223

dbus_message_unref (_reply);

1224

return _result;

1225

}

1226

1227

1228

static gboolean wnck_sync_matcher_dbus_proxy_window_match_is_ready (WnckSyncMatcher* self, guint32 xid, GError** error) {

1229

DBusError _dbus_error;

1230

DBusGConnection *_connection;

1231

DBusMessage *_message, *_reply;

1232

DBusMessageIter _iter;

1233

dbus_uint32_t _tmp3_;

1234

gboolean _result;

1235

dbus_bool_t _tmp4_;

1236

if (((WnckSyncMatcherDBusProxy*) self)->disposed) {

1237

g_set_error (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "%s", "Connection is closed");

1238

return FALSE;

1239

}

1240

_message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.wncksync.Matcher", "WindowMatchIsReady");

1241

dbus_message_iter_init_append (_message, &_iter);

1242

_tmp3_ = xid;

1243

dbus_message_iter_append_basic (&_iter, DBUS_TYPE_UINT32, &_tmp3_);

1244

g_object_get (self, "connection", &_connection, NULL);

1245

dbus_error_init (&_dbus_error);

1246

_reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);

1247

dbus_g_connection_unref (_connection);

1248

dbus_message_unref (_message);

1249

if (dbus_error_is_set (&_dbus_error)) {

1250

GQuark _edomain;

1251

gint _ecode;

1252

if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {

1253

const char* _tmp5_;

1254

_edomain = DBUS_GERROR;

1255

_tmp5_ = _dbus_error.name + 27;

1256

if (strcmp (_tmp5_, "Failed") == 0) {

1257

_ecode = DBUS_GERROR_FAILED;

1258

} else if (strcmp (_tmp5_, "NoMemory") == 0) {

1259

_ecode = DBUS_GERROR_NO_MEMORY;

1260

} else if (strcmp (_tmp5_, "ServiceUnknown") == 0) {

1261

_ecode = DBUS_GERROR_SERVICE_UNKNOWN;

1262

} else if (strcmp (_tmp5_, "NameHasNoOwner") == 0) {

1263

_ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;

1264

} else if (strcmp (_tmp5_, "NoReply") == 0) {

1265

_ecode = DBUS_GERROR_NO_REPLY;

1266

} else if (strcmp (_tmp5_, "IOError") == 0) {

1267

_ecode = DBUS_GERROR_IO_ERROR;

1268

} else if (strcmp (_tmp5_, "BadAddress") == 0) {

1269

_ecode = DBUS_GERROR_BAD_ADDRESS;

1270

} else if (strcmp (_tmp5_, "NotSupported") == 0) {

1271

_ecode = DBUS_GERROR_NOT_SUPPORTED;

1272

} else if (strcmp (_tmp5_, "LimitsExceeded") == 0) {

1273

_ecode = DBUS_GERROR_LIMITS_EXCEEDED;

1274

} else if (strcmp (_tmp5_, "AccessDenied") == 0) {

1275

_ecode = DBUS_GERROR_ACCESS_DENIED;

1276

} else if (strcmp (_tmp5_, "AuthFailed") == 0) {

1277

_ecode = DBUS_GERROR_AUTH_FAILED;

1278

} else if (strcmp (_tmp5_, "NoServer") == 0) {

1279

_ecode = DBUS_GERROR_NO_SERVER;

1280

} else if (strcmp (_tmp5_, "Timeout") == 0) {

1281

_ecode = DBUS_GERROR_TIMEOUT;

1282

} else if (strcmp (_tmp5_, "NoNetwork") == 0) {

1283

_ecode = DBUS_GERROR_NO_NETWORK;

1284

} else if (strcmp (_tmp5_, "AddressInUse") == 0) {

1285

_ecode = DBUS_GERROR_ADDRESS_IN_USE;

1286

} else if (strcmp (_tmp5_, "Disconnected") == 0) {

1287

_ecode = DBUS_GERROR_DISCONNECTED;

1288

} else if (strcmp (_tmp5_, "InvalidArgs") == 0) {

1289

_ecode = DBUS_GERROR_INVALID_ARGS;

1290

} else if (strcmp (_tmp5_, "FileNotFound") == 0) {

1291

_ecode = DBUS_GERROR_FILE_NOT_FOUND;

1292

} else if (strcmp (_tmp5_, "FileExists") == 0) {

1293

_ecode = DBUS_GERROR_FILE_EXISTS;

1294

} else if (strcmp (_tmp5_, "UnknownMethod") == 0) {

1295

_ecode = DBUS_GERROR_UNKNOWN_METHOD;

1296

} else if (strcmp (_tmp5_, "TimedOut") == 0) {

1297

_ecode = DBUS_GERROR_TIMED_OUT;

1298

} else if (strcmp (_tmp5_, "MatchRuleNotFound") == 0) {

1299

_ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;

1300

} else if (strcmp (_tmp5_, "MatchRuleInvalid") == 0) {

1301

_ecode = DBUS_GERROR_MATCH_RULE_INVALID;

1302

} else if (strcmp (_tmp5_, "Spawn.ExecFailed") == 0) {

1303

_ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;

1304

} else if (strcmp (_tmp5_, "Spawn.ForkFailed") == 0) {

1305

_ecode = DBUS_GERROR_SPAWN_FORK_FAILED;

1306

} else if (strcmp (_tmp5_, "Spawn.ChildExited") == 0) {

1307

_ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;

1308

} else if (strcmp (_tmp5_, "Spawn.ChildSignaled") == 0) {

1309

_ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;

1310

} else if (strcmp (_tmp5_, "Spawn.Failed") == 0) {

1311

_ecode = DBUS_GERROR_SPAWN_FAILED;

1312

} else if (strcmp (_tmp5_, "UnixProcessIdUnknown") == 0) {

1313

_ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;

1314

} else if (strcmp (_tmp5_, "InvalidSignature") == 0) {

1315

_ecode = DBUS_GERROR_INVALID_SIGNATURE;

1316

} else if (strcmp (_tmp5_, "InvalidFileContent") == 0) {

1317

_ecode = DBUS_GERROR_INVALID_FILE_CONTENT;

1318

} else if (strcmp (_tmp5_, "SELinuxSecurityContextUnknown") == 0) {

1319

_ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;

1320

} else if (strcmp (_tmp5_, "RemoteException") == 0) {

1321

_ecode = DBUS_GERROR_REMOTE_EXCEPTION;

1322

}

1323

}

1324

g_set_error (error, _edomain, _ecode, "%s", _dbus_error.message);

1325

dbus_error_free (&_dbus_error);

1326

return FALSE;

1327

}

1328

if (strcmp (dbus_message_get_signature (_reply), "b")) {

1329

g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "b", dbus_message_get_signature (_reply));

1330

dbus_message_unref (_reply);

1331

return FALSE;

1332

}

1333

dbus_message_iter_init (_reply, &_iter);

1334

dbus_message_iter_get_basic (&_iter, &_tmp4_);

1335

dbus_message_iter_next (&_iter);

1336

_result = _tmp4_;

1337

dbus_message_unref (_reply);

1338

return _result;

1339

}

1340

1341

1342

static void wnck_sync_matcher_dbus_proxy_register_desktop_file_for_pid (WnckSyncMatcher* self, const char* filename, gint32 pid, GError** error) {

1343

DBusError _dbus_error;

1344

DBusGConnection *_connection;

1345

DBusMessage *_message, *_reply;

1346

DBusMessageIter _iter;

1347

const char* _tmp6_;

1348

dbus_int32_t _tmp7_;

1349

if (((WnckSyncMatcherDBusProxy*) self)->disposed) {

1350

g_set_error (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "%s", "Connection is closed");

1351

return;

1352

}

1353

_message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.wncksync.Matcher", "RegisterDesktopFileForPid");

1354

dbus_message_iter_init_append (_message, &_iter);

1355

_tmp6_ = filename;

1356

dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp6_);

1357

_tmp7_ = pid;

1358

dbus_message_iter_append_basic (&_iter, DBUS_TYPE_INT32, &_tmp7_);

1359

g_object_get (self, "connection", &_connection, NULL);

1360

dbus_error_init (&_dbus_error);

1361

_reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);

1362

dbus_g_connection_unref (_connection);

1363

dbus_message_unref (_message);

1364

if (dbus_error_is_set (&_dbus_error)) {

1365

GQuark _edomain;

1366

gint _ecode;

1367

if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {

1368

const char* _tmp8_;

1369

_edomain = DBUS_GERROR;

1370

_tmp8_ = _dbus_error.name + 27;

1371

if (strcmp (_tmp8_, "Failed") == 0) {

1372

_ecode = DBUS_GERROR_FAILED;

1373

} else if (strcmp (_tmp8_, "NoMemory") == 0) {

1374

_ecode = DBUS_GERROR_NO_MEMORY;

1375

} else if (strcmp (_tmp8_, "ServiceUnknown") == 0) {

1376

_ecode = DBUS_GERROR_SERVICE_UNKNOWN;

1377

} else if (strcmp (_tmp8_, "NameHasNoOwner") == 0) {

1378

_ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;

1379

} else if (strcmp (_tmp8_, "NoReply") == 0) {

1380

_ecode = DBUS_GERROR_NO_REPLY;

1381

} else if (strcmp (_tmp8_, "IOError") == 0) {

1382

_ecode = DBUS_GERROR_IO_ERROR;

1383

} else if (strcmp (_tmp8_, "BadAddress") == 0) {

1384

_ecode = DBUS_GERROR_BAD_ADDRESS;

1385

} else if (strcmp (_tmp8_, "NotSupported") == 0) {

1386

_ecode = DBUS_GERROR_NOT_SUPPORTED;

1387

} else if (strcmp (_tmp8_, "LimitsExceeded") == 0) {

1388

_ecode = DBUS_GERROR_LIMITS_EXCEEDED;

1389

} else if (strcmp (_tmp8_, "AccessDenied") == 0) {

1390

_ecode = DBUS_GERROR_ACCESS_DENIED;

1391

} else if (strcmp (_tmp8_, "AuthFailed") == 0) {

1392

_ecode = DBUS_GERROR_AUTH_FAILED;

1393

} else if (strcmp (_tmp8_, "NoServer") == 0) {

1394

_ecode = DBUS_GERROR_NO_SERVER;

1395

} else if (strcmp (_tmp8_, "Timeout") == 0) {

1396

_ecode = DBUS_GERROR_TIMEOUT;

1397

} else if (strcmp (_tmp8_, "NoNetwork") == 0) {

1398

_ecode = DBUS_GERROR_NO_NETWORK;

1399

} else if (strcmp (_tmp8_, "AddressInUse") == 0) {

1400

_ecode = DBUS_GERROR_ADDRESS_IN_USE;

1401

} else if (strcmp (_tmp8_, "Disconnected") == 0) {

1402

_ecode = DBUS_GERROR_DISCONNECTED;

1403

} else if (strcmp (_tmp8_, "InvalidArgs") == 0) {

1404

_ecode = DBUS_GERROR_INVALID_ARGS;

1405

} else if (strcmp (_tmp8_, "FileNotFound") == 0) {

1406

_ecode = DBUS_GERROR_FILE_NOT_FOUND;

1407

} else if (strcmp (_tmp8_, "FileExists") == 0) {

1408

_ecode = DBUS_GERROR_FILE_EXISTS;

1409

} else if (strcmp (_tmp8_, "UnknownMethod") == 0) {

1410

_ecode = DBUS_GERROR_UNKNOWN_METHOD;

1411

} else if (strcmp (_tmp8_, "TimedOut") == 0) {

1412

_ecode = DBUS_GERROR_TIMED_OUT;

1413

} else if (strcmp (_tmp8_, "MatchRuleNotFound") == 0) {

1414

_ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;

1415

} else if (strcmp (_tmp8_, "MatchRuleInvalid") == 0) {

1416

_ecode = DBUS_GERROR_MATCH_RULE_INVALID;

1417

} else if (strcmp (_tmp8_, "Spawn.ExecFailed") == 0) {

1418

_ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;

1419

} else if (strcmp (_tmp8_, "Spawn.ForkFailed") == 0) {

1420

_ecode = DBUS_GERROR_SPAWN_FORK_FAILED;

1421

} else if (strcmp (_tmp8_, "Spawn.ChildExited") == 0) {

1422

_ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;

1423

} else if (strcmp (_tmp8_, "Spawn.ChildSignaled") == 0) {

1424

_ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;

1425

} else if (strcmp (_tmp8_, "Spawn.Failed") == 0) {

1426

_ecode = DBUS_GERROR_SPAWN_FAILED;

1427

} else if (strcmp (_tmp8_, "UnixProcessIdUnknown") == 0) {

1428

_ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;

1429

} else if (strcmp (_tmp8_, "InvalidSignature") == 0) {

1430

_ecode = DBUS_GERROR_INVALID_SIGNATURE;

1431

} else if (strcmp (_tmp8_, "InvalidFileContent") == 0) {

1432

_ecode = DBUS_GERROR_INVALID_FILE_CONTENT;

1433

} else if (strcmp (_tmp8_, "SELinuxSecurityContextUnknown") == 0) {

1434

_ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;

1435

} else if (strcmp (_tmp8_, "RemoteException") == 0) {

1436

_ecode = DBUS_GERROR_REMOTE_EXCEPTION;

1437

}

1438

}

1439

g_set_error (error, _edomain, _ecode, "%s", _dbus_error.message);

1440

dbus_error_free (&_dbus_error);

1441

return;

1442

}

1443

if (strcmp (dbus_message_get_signature (_reply), "")) {

1444

g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "", dbus_message_get_signature (_reply));

1445

dbus_message_unref (_reply);

1446

return;

1447

}

1448

dbus_message_iter_init (_reply, &_iter);

1449

dbus_message_unref (_reply);

1450

}

1451

1452

1453

static guint32* wnck_sync_matcher_dbus_proxy_xids_for_desktop_file (WnckSyncMatcher* self, const char* filename, int* result_length1, GError** error) {

1454

DBusError _dbus_error;

1455

DBusGConnection *_connection;

1456

DBusMessage *_message, *_reply;

1457

DBusMessageIter _iter;

1458

const char* _tmp9_;

1459

guint32* _result;

1460

int _result_length1;

1461

guint32* _tmp10_;

1462

int _tmp10__length;

1463

int _tmp10__size;

1464

int _tmp10__length1;

1465

DBusMessageIter _tmp11_;

1466

if (((WnckSyncMatcherDBusProxy*) self)->disposed) {

1467

g_set_error (error, DBUS_GERROR, DBUS_GERROR_DISCONNECTED, "%s", "Connection is closed");

1468

return NULL;

1469

}

1470

_message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.wncksync.Matcher", "XidsForDesktopFile");

1471

dbus_message_iter_init_append (_message, &_iter);

1472

_tmp9_ = filename;

1473

dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp9_);

1474

g_object_get (self, "connection", &_connection, NULL);

1475

dbus_error_init (&_dbus_error);

1476

_reply = dbus_connection_send_with_reply_and_block (dbus_g_connection_get_connection (_connection), _message, -1, &_dbus_error);

1477

dbus_g_connection_unref (_connection);

1478

dbus_message_unref (_message);

1479

if (dbus_error_is_set (&_dbus_error)) {

1480

GQuark _edomain;

1481

gint _ecode;

1482

if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {

1483

const char* _tmp13_;

1484

_edomain = DBUS_GERROR;

1485

_tmp13_ = _dbus_error.name + 27;

1486

if (strcmp (_tmp13_, "Failed") == 0) {

1487

_ecode = DBUS_GERROR_FAILED;

1488

} else if (strcmp (_tmp13_, "NoMemory") == 0) {

1489

_ecode = DBUS_GERROR_NO_MEMORY;

1490

} else if (strcmp (_tmp13_, "ServiceUnknown") == 0) {

1491

_ecode = DBUS_GERROR_SERVICE_UNKNOWN;

1492

} else if (strcmp (_tmp13_, "NameHasNoOwner") == 0) {

1493

_ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;

1494

} else if (strcmp (_tmp13_, "NoReply") == 0) {

1495

_ecode = DBUS_GERROR_NO_REPLY;

1496

} else if (strcmp (_tmp13_, "IOError") == 0) {

1497

_ecode = DBUS_GERROR_IO_ERROR;

1498

} else if (strcmp (_tmp13_, "BadAddress") == 0) {

1499

_ecode = DBUS_GERROR_BAD_ADDRESS;

1500

} else if (strcmp (_tmp13_, "NotSupported") == 0) {

1501

_ecode = DBUS_GERROR_NOT_SUPPORTED;

1502

} else if (strcmp (_tmp13_, "LimitsExceeded") == 0) {

1503

_ecode = DBUS_GERROR_LIMITS_EXCEEDED;

1504

} else if (strcmp (_tmp13_, "AccessDenied") == 0) {

1505

_ecode = DBUS_GERROR_ACCESS_DENIED;

1506

} else if (strcmp (_tmp13_, "AuthFailed") == 0) {

1507

_ecode = DBUS_GERROR_AUTH_FAILED;

1508

} else if (strcmp (_tmp13_, "NoServer") == 0) {

1509

_ecode = DBUS_GERROR_NO_SERVER;

1510

} else if (strcmp (_tmp13_, "Timeout") == 0) {

1511

_ecode = DBUS_GERROR_TIMEOUT;

1512

} else if (strcmp (_tmp13_, "NoNetwork") == 0) {

1513

_ecode = DBUS_GERROR_NO_NETWORK;

1514

} else if (strcmp (_tmp13_, "AddressInUse") == 0) {

1515

_ecode = DBUS_GERROR_ADDRESS_IN_USE;

1516

} else if (strcmp (_tmp13_, "Disconnected") == 0) {

1517

_ecode = DBUS_GERROR_DISCONNECTED;

1518

} else if (strcmp (_tmp13_, "InvalidArgs") == 0) {

1519

_ecode = DBUS_GERROR_INVALID_ARGS;

1520

} else if (strcmp (_tmp13_, "FileNotFound") == 0) {

1521

_ecode = DBUS_GERROR_FILE_NOT_FOUND;

1522

} else if (strcmp (_tmp13_, "FileExists") == 0) {

1523

_ecode = DBUS_GERROR_FILE_EXISTS;

1524

} else if (strcmp (_tmp13_, "UnknownMethod") == 0) {

1525

_ecode = DBUS_GERROR_UNKNOWN_METHOD;

1526

} else if (strcmp (_tmp13_, "TimedOut") == 0) {

1527

_ecode = DBUS_GERROR_TIMED_OUT;

1528

} else if (strcmp (_tmp13_, "MatchRuleNotFound") == 0) {

1529

_ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;

1530

} else if (strcmp (_tmp13_, "MatchRuleInvalid") == 0) {

1531

_ecode = DBUS_GERROR_MATCH_RULE_INVALID;

1532

} else if (strcmp (_tmp13_, "Spawn.ExecFailed") == 0) {

1533

_ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;

1534

} else if (strcmp (_tmp13_, "Spawn.ForkFailed") == 0) {

1535

_ecode = DBUS_GERROR_SPAWN_FORK_FAILED;

1536

} else if (strcmp (_tmp13_, "Spawn.ChildExited") == 0) {

1537

_ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;

1538

} else if (strcmp (_tmp13_, "Spawn.ChildSignaled") == 0) {

1539

_ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;

1540

} else if (strcmp (_tmp13_, "Spawn.Failed") == 0) {

1541

_ecode = DBUS_GERROR_SPAWN_FAILED;

1542

} else if (strcmp (_tmp13_, "UnixProcessIdUnknown") == 0) {

1543

_ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;

1544

} else if (strcmp (_tmp13_, "InvalidSignature") == 0) {

1545

_ecode = DBUS_GERROR_INVALID_SIGNATURE;

1546

} else if (strcmp (_tmp13_, "InvalidFileContent") == 0) {

1547

_ecode = DBUS_GERROR_INVALID_FILE_CONTENT;

1548

} else if (strcmp (_tmp13_, "SELinuxSecurityContextUnknown") == 0) {

1549

_ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;

1550

} else if (strcmp (_tmp13_, "RemoteException") == 0) {

1551

_ecode = DBUS_GERROR_REMOTE_EXCEPTION;

1552

}

1553

}

1554

g_set_error (error, _edomain, _ecode, "%s", _dbus_error.message);

1555

dbus_error_free (&_dbus_error);

1556

return NULL;

1557

}

1558

if (strcmp (dbus_message_get_signature (_reply), "au")) {

1559

g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "au", dbus_message_get_signature (_reply));

1560

dbus_message_unref (_reply);

1561

return NULL;

1562

}

1563

dbus_message_iter_init (_reply, &_iter);

1564

_result_length1 = 0;

1565

_tmp10_ = g_new (guint32, 5);

1566

_tmp10__length = 0;

1567

_tmp10__size = 4;

1568

_tmp10__length1 = 0;

1569

dbus_message_iter_recurse (&_iter, &_tmp11_);

1570

for (; dbus_message_iter_get_arg_type (&_tmp11_); _tmp10__length1++) {

1571

dbus_uint32_t _tmp12_;

1572

if (_tmp10__size == _tmp10__length) {

1573

_tmp10__size = 2 * _tmp10__size;

1574

_tmp10_ = g_renew (guint32, _tmp10_, _tmp10__size + 1);

1575

}

1576

dbus_message_iter_get_basic (&_tmp11_, &_tmp12_);

1577

dbus_message_iter_next (&_tmp11_);

1578

_tmp10_[_tmp10__length++] = _tmp12_;

1579

}

1580

_result_length1 = _tmp10__length1;

1581

dbus_message_iter_next (&_iter);

1582

_result = _tmp10_;

1583

*result_length1 = _result_length1;

1584

dbus_message_unref (_reply);

1585

return _result;

1586

}

1587

1588

1589

static void wnck_sync_matcher_dbus_proxy_wnck_sync_matcher__interface_init (WnckSyncMatcherIface* iface) {

1590

iface->desktop_file_for_xid = wnck_sync_matcher_dbus_proxy_desktop_file_for_xid;

1591

iface->window_match_is_ready = wnck_sync_matcher_dbus_proxy_window_match_is_ready;

1592

iface->register_desktop_file_for_pid = wnck_sync_matcher_dbus_proxy_register_desktop_file_for_pid;

1593

iface->xids_for_desktop_file = wnck_sync_matcher_dbus_proxy_xids_for_desktop_file;

1594

}

1595

1596

1597

static void wnck_sync_matcher_dbus_proxy_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {

1598

}

1599

1600

1601

static void wnck_sync_matcher_dbus_proxy_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {

1602

}

1603

1604

1605

static char** _vala_array_dup1 (char** self, int length) {

1606

char** result;

1607

int i;

1608

result = g_new0 (char*, length + 1);

1609

for (i = 0; i < length; i++) {

1610

result[i] = g_strdup (self[i]);

1611

}

1612

return result;

1613

}

1614

1615

1616

void desktop_file_info_copy (const DesktopFileInfo* self, DesktopFileInfo* dest) {

1617

char** _tmp0_;

1618

dest->name = g_strdup (self->name);

1619

dest->mimetypes = (_tmp0_ = self->mimetypes, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup1 (_tmp0_, (*self).mimetypes_length1));

1620

dest->mimetypes_length1 = self->mimetypes_length1;

1621

}

1622

1623

1624

void desktop_file_info_destroy (DesktopFileInfo* self) {

1625

_g_free0 (self->name);

1626

self->mimetypes = (_vala_array_free (self->mimetypes, (*self).mimetypes_length1, (GDestroyNotify) g_free), NULL);

1627

}

1628

1629

1630

DesktopFileInfo* desktop_file_info_dup (const DesktopFileInfo* self) {

1631

DesktopFileInfo* dup;

1632

dup = g_new0 (DesktopFileInfo, 1);

1633

desktop_file_info_copy (self, dup);

1634

return dup;

1635

}

1636

1637

1638

void desktop_file_info_free (DesktopFileInfo* self) {

1639

desktop_file_info_destroy (self);

1640

g_free (self);

1641

}

1642

1643

1644

GType desktop_file_info_get_type (void) {

1645

static volatile gsize desktop_file_info_type_id__volatile = 0;

1646

if (g_once_init_enter (&desktop_file_info_type_id__volatile)) {

1647

GType desktop_file_info_type_id;

1648

desktop_file_info_type_id = g_boxed_type_register_static ("DesktopFileInfo", (GBoxedCopyFunc) desktop_file_info_dup, (GBoxedFreeFunc) desktop_file_info_free);

1649

g_once_init_leave (&desktop_file_info_type_id__volatile, desktop_file_info_type_id);

1650

}

1651

return desktop_file_info_type_id__volatile;

1652

}

1653

1654

1655

static void _related_applet_window_opened_wnck_screen_window_opened (WnckScreen* _sender, WnckWindow* window, gpointer self) {

1656

related_applet_window_opened (self, window);

1657

}

1658

1659

1660

static void _related_applet_window_changed_wnck_screen_active_window_changed (WnckScreen* _sender, WnckWindow* previous_window, gpointer self) {

1661

related_applet_window_changed (self, previous_window);

1662

}

1663

1664

1665

static void _related_applet_on_clicked_awn_applet_simple_clicked (AwnAppletSimple* _sender, gpointer self) {

1666

related_applet_on_clicked (self);

1667

}

1668

1669

1670

RelatedApplet* related_applet_construct (GType object_type, const char* canonical_name, const char* uid, gint panel_id) {

1671

RelatedApplet * self;

1672

GHashTable* _tmp0_;

1673

AwnDialog* _tmp1_;

1674

g_return_val_if_fail (canonical_name != NULL, NULL);

1675

g_return_val_if_fail (uid != NULL, NULL);

1676

self = (RelatedApplet*) g_object_new (object_type, "canonical-name", canonical_name, "uid", uid, "panel-id", panel_id, NULL);

1677

self->priv->desktop_file_info = (_tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, desktop_file_info_free), _g_hash_table_unref0 (self->priv->desktop_file_info), _tmp0_);

1678

self->priv->wnck_screen = wnck_screen_get_default ();

1679

wnck_set_client_type (WNCK_CLIENT_TYPE_PAGER);

1680

g_signal_connect_object (self->priv->wnck_screen, "window-opened", (GCallback) _related_applet_window_opened_wnck_screen_window_opened, self, 0);

1681

g_signal_connect_object (self->priv->wnck_screen, "active-window-changed", (GCallback) _related_applet_window_changed_wnck_screen_active_window_changed, self, 0);

1682

awn_overlayable_add_overlay ((AwnOverlayable*) self, self->priv->throbber);

1683

awn_overlayable_add_overlay ((AwnOverlayable*) self, self->priv->star_overlay);

1684

awn_applet_simple_set_icon_name ((AwnAppletSimple*) self, "zeitgeist-logo");

1685

g_signal_connect_object ((AwnAppletSimple*) self, "clicked", (GCallback) _related_applet_on_clicked_awn_applet_simple_clicked, self, 0);

1686

self->priv->dialog = (_tmp1_ = g_object_ref_sink ((AwnDialog*) awn_dialog_new_for_widget ((GtkWidget*) self)), _g_object_unref0 (self->priv->dialog), _tmp1_);

1687

return self;

1688

}

1689

1690

1691

RelatedApplet* related_applet_new (const char* canonical_name, const char* uid, gint panel_id) {

1692

return related_applet_construct (TYPE_RELATED_APPLET, canonical_name, uid, panel_id);

1693

}

1694

1695

1696

static gpointer _desktop_file_info_dup0 (gpointer self) {

1697

return self ? desktop_file_info_dup (self) : NULL;

1698

}

1699

1700

1701

static void related_applet_window_opened (RelatedApplet* self, WnckWindow* window) {

1702

char* desktop_file;

1703

GError * _inner_error_ = NULL;

1704

g_return_if_fail (self != NULL);

1705

g_return_if_fail (window != NULL);

1706

desktop_file = g_strdup (awn_desktop_lookup_search_by_wnck_window (self->priv->lookup, window));

1707

if (desktop_file == NULL) {

1708

{

1709

DBusGConnection* con;

1710

WnckSyncMatcher* matcher;

1711

char* df;

1712

gboolean _tmp0_ = FALSE;

1713

con = dbus_g_bus_get (DBUS_BUS_SESSION, &_inner_error_);

1714

if (_inner_error_ != NULL) {

1715

goto __catch0_g_error;

1716

}

1717

matcher = wnck_sync_matcher_dbus_proxy_new (con, "org.wncksync.Matcher", "/org/wncksync/Matcher");

1718

df = wnck_sync_matcher_desktop_file_for_xid (matcher, (guint32) wnck_window_get_xid (window), &_inner_error_);

1719

if (_inner_error_ != NULL) {

1720

_g_object_unref0 (matcher);

1721

_dbus_g_connection_unref0 (con);

1722

goto __catch0_g_error;

1723

}

1724

if (df != NULL) {

1725

_tmp0_ = _vala_strcmp0 (df, "") != 0;

1726

} else {

1727

_tmp0_ = FALSE;

1728

}

1729

if (_tmp0_) {

1730

char* _tmp1_;

1731

g_debug ("related-applet.vala:107: wncksync found match: %s", df);

1732

desktop_file = (_tmp1_ = g_strdup (df), _g_free0 (desktop_file), _tmp1_);

1733

}

1734

_g_free0 (df);

1735

_g_object_unref0 (matcher);

1736

_dbus_g_connection_unref0 (con);

1737

}

1738

goto __finally0;

1739

__catch0_g_error:

1740

{

1741

GError * err;

1742

err = _inner_error_;

1743

_inner_error_ = NULL;

1744

{

1745

_g_error_free0 (err);

1746

}

1747

}

1748

__finally0:

1749

if (_inner_error_ != NULL) {

1750

_g_free0 (desktop_file);

1751

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

1752

g_clear_error (&_inner_error_);

1753

return;

1754

}

1755

}

1756

if (desktop_file != NULL) {

1757

DesktopFileInfo* df_data = NULL;

1758

df_data = (DesktopFileInfo*) g_hash_table_lookup (self->priv->desktop_file_info, desktop_file);

1759

if (df_data == NULL) {

1760

GKeyFile* keyfile;

1761

gint mimetypes_length1;

1762

gint _mimetypes_size_;

1763

char** _tmp3_;

1764

char** _tmp2_ = NULL;

1765

char** mimetypes;

1766

char* app_name;

1767

DesktopFileInfo w = {0};

1768

char* _tmp10_;

1769

char* _tmp11_;

1770

char** _tmp12_;

1771

char** _tmp13_;

1772

keyfile = g_key_file_new ();

1773

mimetypes = (_tmp3_ = (_tmp2_ = g_new0 (char*, 0 + 1), _tmp2_), mimetypes_length1 = 0, _mimetypes_size_ = mimetypes_length1, _tmp3_);

1774

app_name = g_strdup ("");

1775

{

1776

char* _tmp4_;

1777

char* _tmp5_;

1778

gint _tmp7__length1;

1779

gint __tmp7__size_;

1780

char** _tmp8_;

1781

gsize _tmp6_;

1782

char** _tmp7_;

1783

char** _tmp9_;

1784

g_key_file_load_from_file (keyfile, desktop_file, G_KEY_FILE_NONE, &_inner_error_);

1785

if (_inner_error_ != NULL) {

1786

goto __catch1_g_error;

1787

}

1788

_tmp4_ = g_key_file_get_locale_string (keyfile, "Desktop Entry", "Name", NULL, &_inner_error_);

1789

if (_inner_error_ != NULL) {

1790

goto __catch1_g_error;

1791

}

1792

app_name = (_tmp5_ = _tmp4_, _g_free0 (app_name), _tmp5_);

1793

_tmp7_ = (_tmp8_ = g_key_file_get_string_list (keyfile, "Desktop Entry", "MimeType", &_tmp6_, &_inner_error_), _tmp7__length1 = _tmp6_, __tmp7__size_ = _tmp7__length1, _tmp8_);

1794

if (_inner_error_ != NULL) {

1795

goto __catch1_g_error;

1796

}

1797

mimetypes = (_tmp9_ = _tmp7_, mimetypes = (_vala_array_free (mimetypes, mimetypes_length1, (GDestroyNotify) g_free), NULL), mimetypes_length1 = _tmp7__length1, _mimetypes_size_ = mimetypes_length1, _tmp9_);

1798

}

1799

goto __finally1;

1800

__catch1_g_error:

1801

{

1802

GError * err;

1803

err = _inner_error_;

1804

_inner_error_ = NULL;

1805

{

1806

_g_error_free0 (err);

1807

}

1808

}

1809

__finally1:

1810

if (_inner_error_ != NULL) {

1811

_g_free0 (app_name);

1812

mimetypes = (_vala_array_free (mimetypes, mimetypes_length1, (GDestroyNotify) g_free), NULL);

1813

_g_key_file_free0 (keyfile);

1814

_g_free0 (desktop_file);

1815

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

1816

g_clear_error (&_inner_error_);

1817

return;

1818

}

1819

memset (&w, 0, sizeof (DesktopFileInfo));

1820

w.name = (_tmp11_ = (_tmp10_ = app_name, app_name = NULL, _tmp10_), _g_free0 (w.name), _tmp11_);

1821

w.mimetypes = (_tmp13_ = (_tmp12_ = mimetypes, mimetypes = NULL, _tmp12_), w.mimetypes = (_vala_array_free (w.mimetypes, w.mimetypes_length1, (GDestroyNotify) g_free), NULL), w.mimetypes_length1 = mimetypes_length1, w._mimetypes_size_ = w.mimetypes_length1, _tmp13_);

1822

g_hash_table_insert (self->priv->desktop_file_info, g_strdup (desktop_file), _desktop_file_info_dup0 (&w));

1823

desktop_file_info_destroy (&w);

1824

_g_free0 (app_name);

1825

mimetypes = (_vala_array_free (mimetypes, mimetypes_length1, (GDestroyNotify) g_free), NULL);

1826

_g_key_file_free0 (keyfile);

1827

}

1828

}

1829

g_object_set_data_full ((GObject*) window, "desktop-file-path", g_strdup (desktop_file), g_free);

1830

_g_free0 (desktop_file);

1831

}

1832

1833

1834

static gpointer _g_object_ref0 (gpointer self) {

1835

return self ? g_object_ref (self) : NULL;

1836

}

1837

1838

1839

static void related_applet_window_changed (RelatedApplet* self, WnckWindow* old_window) {

1840

WnckWindow* active;

1841

g_return_if_fail (self != NULL);

1842

active = _g_object_ref0 (wnck_screen_get_active_window (self->priv->wnck_screen));

1843

if (active != NULL) {

1844

char* desktop_file;

1845

desktop_file = g_strdup ((const char*) g_object_get_data ((GObject*) active, "desktop-file-path"));

1846

if (desktop_file != NULL) {

1847

related_applet_update_star (self, desktop_file, NULL, NULL);

1848

} else {

1849

g_object_set (self->priv->star_overlay, "active", FALSE, NULL);

1850

}

1851

_g_free0 (desktop_file);

1852

}

1853

_g_object_unref0 (active);

1854

}

1855

1856

1857

static void related_applet_update_star_data_free (gpointer _data) {

1858

RelatedAppletUpdateStarData* data;

1859

data = _data;

1860

_g_free0 (data->desktop_file);

1861

g_object_unref (data->self);

1862

g_slice_free (RelatedAppletUpdateStarData, data);

1863

}

1864

1865

1866

static void related_applet_update_star (RelatedApplet* self, const char* desktop_file, GAsyncReadyCallback _callback_, gpointer _user_data_) {

1867

RelatedAppletUpdateStarData* _data_;

1868

_data_ = g_slice_new0 (RelatedAppletUpdateStarData);

1869

_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, related_applet_update_star);

1870

g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, related_applet_update_star_data_free);

1871

_data_->self = g_object_ref (self);

1872

_data_->desktop_file = g_strdup (desktop_file);

1873

related_applet_update_star_co (_data_);

1874

}

1875

1876

1877

static void related_applet_update_star_finish (RelatedApplet* self, GAsyncResult* _res_) {

1878

RelatedAppletUpdateStarData* _data_;

1879

_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));

1880

}

1881

1882

1883

static void related_applet_update_star_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {

1884

RelatedAppletUpdateStarData* data;

1885

data = _user_data_;

1886

data->_res_ = _res_;

1887

related_applet_update_star_co (data);

1888

}

1889

1890

1891

static void _g_list_free_g_object_unref (GList* self) {

1892

g_list_foreach (self, (GFunc) g_object_unref, NULL);

1893

g_list_free (self);

1894

}

1895

1896

1897

static gboolean related_applet_update_star_co (RelatedAppletUpdateStarData* data) {

1898

switch (data->_state_) {

1899

case 0:

1900

goto _state_0;

1901

default:

1902

g_assert_not_reached ();

1903

case 1:

1904

goto _state_1;

1905

}

1906

_state_0:

1907

data->ptr_array = g_ptr_array_new ();

1908

data->actor = g_utf8_offset_to_pointer (g_utf8_strrchr (data->desktop_file, (gssize) (-1), (gunichar) '/'), (glong) 1);

1909

data->event = g_object_ref_sink (zeitgeist_event_new ());

1910

data->helper_event_list = NULL;

1911

zeitgeist_event_set_actor (data->event, data->_tmp0_ = g_strconcat ("application://", data->actor, NULL));

1912

_g_free0 (data->_tmp0_);

1913

g_ptr_array_add (data->ptr_array, data->event);

1914

data->df_data = (DesktopFileInfo*) g_hash_table_lookup (data->self->priv->desktop_file_info, data->desktop_file);

1915

if (data->df_data != NULL) {

1916

data->_tmp1_ = (*data->df_data).mimetypes_length1 > 0;

1917

} else {

1918

data->_tmp1_ = FALSE;

1919

}

1920

if (data->_tmp1_) {

1921

{

1922

data->mimetype_collection = (*data->df_data).mimetypes;

1923

data->mimetype_collection_length1 = (*data->df_data).mimetypes_length1;

1924

for (data->mimetype_it = 0; data->mimetype_it < (*data->df_data).mimetypes_length1; data->mimetype_it = data->mimetype_it + 1) {

1925

data->mimetype = data->mimetype_collection[data->mimetype_it];

1926

{

1927

data->mime_event = g_object_ref_sink (zeitgeist_event_new ());

1928

data->subject = g_object_ref_sink (zeitgeist_subject_new ());

1929

zeitgeist_subject_set_mimetype (data->subject, data->mimetype);

1930

zeitgeist_event_add_subject (data->mime_event, data->subject);

1931

data->helper_event_list = g_list_prepend (data->helper_event_list, _g_object_ref0 (data->mime_event));

1932

g_ptr_array_add (data->ptr_array, data->mime_event);

1933

_g_object_unref0 (data->subject);

1934

_g_object_unref0 (data->mime_event);

1935

}

1936

}

1937

}

1938

}

1939

data->_state_ = 1;

1940

zeitgeist_log_find_event_ids (data->self->priv->zg_log, data->_tmp2_ = g_object_ref_sink (zeitgeist_time_range_new_to_now ()), (data->_tmp3_ = data->ptr_array, data->ptr_array = NULL, data->_tmp3_), ZEITGEIST_STORAGE_STATE_ANY, (guint32) 1, ZEITGEIST_RESULT_TYPE_MOST_RECENT_EVENTS, NULL, related_applet_update_star_ready, data);

1941

return FALSE;

1942

_state_1:

1943

data->events = (data->_tmp4_ = zeitgeist_log_find_event_ids_finish (data->self->priv->zg_log, data->_res_, &data->_inner_error_), _g_object_unref0 (data->_tmp2_), data->_tmp4_);

1944

if (data->_inner_error_ != NULL) {

1945

__g_list_free_g_object_unref0 (data->helper_event_list);

1946

_g_object_unref0 (data->event);

1947

_g_ptr_array_free0 (data->ptr_array);

1948

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);

1949

g_clear_error (&data->_inner_error_);

1950

return FALSE;

1951

}

1952

g_object_set (data->self->priv->star_overlay, "active", data->events->len > 0, NULL);

1953

if (data->events->len > 0) {

1954

data->_tmp5_ = (data->_tmp6_ = g_strdup_printf ("Show items related to %s", (*data->df_data).name), _g_free0 (data->_tmp5_), data->_tmp6_);

1955

} else {

1956

data->_tmp5_ = (data->_tmp7_ = NULL, _g_free0 (data->_tmp5_), data->_tmp7_);

1957

}

1958

awn_applet_simple_set_tooltip_text ((AwnAppletSimple*) data->self, data->_tmp5_);

1959

_g_free0 (data->_tmp5_);

1960

_g_array_free0 (data->events);

1961

__g_list_free_g_object_unref0 (data->helper_event_list);

1962

_g_object_unref0 (data->event);

1963

_g_ptr_array_free0 (data->ptr_array);

1964

{

1965

if (data->_state_ == 0) {

1966

g_simple_async_result_complete_in_idle (data->_async_result);

1967

} else {

1968

g_simple_async_result_complete (data->_async_result);

1969

}

1970

g_object_unref (data->_async_result);

1971

return FALSE;

1972

}

1973

}

1974

1975

1976

static void related_applet_get_recent_by_mimetype_data_free (gpointer _data) {

1977

RelatedAppletGetRecentByMimetypeData* data;

1978

data = _data;

1979

data->mimetypes = (_vala_array_free (data->mimetypes, data->mimetypes_length1, (GDestroyNotify) g_free), NULL);

1980

g_object_unref (data->self);

1981

g_slice_free (RelatedAppletGetRecentByMimetypeData, data);

1982

}

1983

1984

1985

static char** _vala_array_dup2 (char** self, int length) {

1986

char** result;

1987

int i;

1988

result = g_new0 (char*, length + 1);

1989

for (i = 0; i < length; i++) {

1990

result[i] = g_strdup (self[i]);

1991

}

1992

return result;

1993

}

1994

1995

1996

static void related_applet_get_recent_by_mimetype (RelatedApplet* self, char** mimetypes, int mimetypes_length1, GAsyncReadyCallback _callback_, gpointer _user_data_) {

1997

RelatedAppletGetRecentByMimetypeData* _data_;

1998

char** _tmp0_;

1999

_data_ = g_slice_new0 (RelatedAppletGetRecentByMimetypeData);

2000

_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, related_applet_get_recent_by_mimetype);

2001

g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, related_applet_get_recent_by_mimetype_data_free);

2002

_data_->self = g_object_ref (self);

2003

_data_->mimetypes = (_tmp0_ = mimetypes, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup2 (_tmp0_, mimetypes_length1));

2004

_data_->mimetypes_length1 = mimetypes_length1;

2005

related_applet_get_recent_by_mimetype_co (_data_);

2006

}

2007

2008

2009

static gboolean related_applet_get_recent_by_mimetype_finish (RelatedApplet* self, GAsyncResult* _res_) {

2010

gboolean result;

2011

RelatedAppletGetRecentByMimetypeData* _data_;

2012

_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));

2013

result = _data_->result;

2014

return result;

2015

}

2016

2017

2018

static void related_applet_get_recent_by_mimetype_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {

2019

RelatedAppletGetRecentByMimetypeData* data;

2020

data = _user_data_;

2021

data->_res_ = _res_;

2022

related_applet_get_recent_by_mimetype_co (data);

2023

}

2024

2025

2026

static gboolean related_applet_get_recent_by_mimetype_co (RelatedAppletGetRecentByMimetypeData* data) {

2027

switch (data->_state_) {

2028

case 0:

2029

goto _state_0;

2030

default:

2031

g_assert_not_reached ();

2032

case 2:

2033

goto _state_2;

2034

}

2035

_state_0:

2036

data->helper_event_list = NULL;

2037

data->ptr_array = g_ptr_array_new ();

2038

{

2039

data->mimetype_collection = data->mimetypes;

2040

data->mimetype_collection_length1 = data->mimetypes_length1;

2041

for (data->mimetype_it = 0; data->mimetype_it < data->mimetypes_length1; data->mimetype_it = data->mimetype_it + 1) {

2042

data->mimetype = data->mimetype_collection[data->mimetype_it];

2043

{

2044

data->event = g_object_ref_sink (zeitgeist_event_new ());

2045

data->subject = g_object_ref_sink (zeitgeist_subject_new ());

2046

zeitgeist_subject_set_mimetype (data->subject, data->mimetype);

2047

zeitgeist_event_add_subject (data->event, data->subject);

2048

data->helper_event_list = g_list_prepend (data->helper_event_list, _g_object_ref0 (data->event));

2049

g_ptr_array_add (data->ptr_array, data->event);

2050

_g_object_unref0 (data->subject);

2051

_g_object_unref0 (data->event);

2052

}

2053

}

2054

}

2055

data->_state_ = 2;

2056

zeitgeist_log_find_events (data->self->priv->zg_log, data->_tmp0_ = g_object_ref_sink (zeitgeist_time_range_new_to_now ()), (data->_tmp1_ = data->ptr_array, data->ptr_array = NULL, data->_tmp1_), ZEITGEIST_STORAGE_STATE_ANY, (guint32) 16, ZEITGEIST_RESULT_TYPE_MOST_RECENT_SUBJECTS, NULL, related_applet_get_recent_by_mimetype_ready, data);

2057

return FALSE;

2058

_state_2:

2059

data->events = (data->_tmp2_ = zeitgeist_log_find_events_finish (data->self->priv->zg_log, data->_res_, &data->_inner_error_), _g_object_unref0 (data->_tmp0_), data->_tmp2_);

2060

if (data->_inner_error_ != NULL) {

2061

_g_ptr_array_free0 (data->ptr_array);

2062

__g_list_free_g_object_unref0 (data->helper_event_list);

2063

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);

2064

g_clear_error (&data->_inner_error_);

2065

return FALSE;

2066

}

2067

data->results_pushed = 0;

2068

{

2069

data->_e_it = _vala_zeitgeist_result_set_iterator (data->events);

2070

while (TRUE) {

2071

if (!((data->e = _vala_zeitgeist_result_set_next_value (data->_e_it)) != NULL)) {

2072

break;

2073

}

2074

if (zeitgeist_event_num_subjects (data->e) > 0) {

2075

data->s = _g_object_ref0 (zeitgeist_event_get_subject (data->e, 0));

2076

if (data->results_pushed < 3) {

2077

data->_tmp3_ = related_applet_push_result (data->self, data->e, data->s);

2078

} else {

2079

data->_tmp3_ = FALSE;

2080

}

2081

if (data->_tmp3_) {

2082

data->results_pushed++;

2083

}

2084

_g_object_unref0 (data->s);

2085

}

2086

}

2087

_g_object_unref0 (data->_e_it);

2088

}

2089

data->result = zeitgeist_result_set_size (data->events) > 0;

2090

_g_object_unref0 (data->events);

2091

_g_ptr_array_free0 (data->ptr_array);

2092

__g_list_free_g_object_unref0 (data->helper_event_list);

2093

{

2094

if (data->_state_ == 0) {

2095

g_simple_async_result_complete_in_idle (data->_async_result);

2096

} else {

2097

g_simple_async_result_complete (data->_async_result);

2098

}

2099

g_object_unref (data->_async_result);

2100

return FALSE;

2101

}

2102

_g_object_unref0 (data->events);

2103

_g_ptr_array_free0 (data->ptr_array);

2104

__g_list_free_g_object_unref0 (data->helper_event_list);

2105

{

2106

if (data->_state_ == 0) {

2107

g_simple_async_result_complete_in_idle (data->_async_result);

2108

} else {

2109

g_simple_async_result_complete (data->_async_result);

2110

}

2111

g_object_unref (data->_async_result);

2112

return FALSE;

2113

}

2114

}

2115

2116

2117

static void related_applet_get_events_for_actor_data_free (gpointer _data) {

2118

RelatedAppletGetEventsForActorData* data;

2119

data = _data;

2120

_g_free0 (data->actor);

2121

g_object_unref (data->self);

2122

g_slice_free (RelatedAppletGetEventsForActorData, data);

2123

}

2124

2125

2126

static void related_applet_get_events_for_actor (RelatedApplet* self, const char* actor, GAsyncReadyCallback _callback_, gpointer _user_data_) {

2127

RelatedAppletGetEventsForActorData* _data_;

2128

_data_ = g_slice_new0 (RelatedAppletGetEventsForActorData);

2129

_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, related_applet_get_events_for_actor);

2130

g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, related_applet_get_events_for_actor_data_free);

2131

_data_->self = g_object_ref (self);

2132

_data_->actor = g_strdup (actor);

2133

related_applet_get_events_for_actor_co (_data_);

2134

}

2135

2136

2137

static gboolean related_applet_get_events_for_actor_finish (RelatedApplet* self, GAsyncResult* _res_) {

2138

gboolean result;

2139

RelatedAppletGetEventsForActorData* _data_;

2140

_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));

2141

result = _data_->result;

2142

return result;

2143

}

2144

2145

2146

static void related_applet_get_events_for_actor_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {

2147

RelatedAppletGetEventsForActorData* data;

2148

data = _user_data_;

2149

data->_res_ = _res_;

2150

related_applet_get_events_for_actor_co (data);

2151

}

2152

2153

2154

static gboolean related_applet_get_events_for_actor_co (RelatedAppletGetEventsForActorData* data) {

2155

switch (data->_state_) {

2156

case 0:

2157

goto _state_0;

2158

default:

2159

g_assert_not_reached ();

2160

case 3:

2161

goto _state_3;

2162

}

2163

_state_0:

2164

data->ptr_array = g_ptr_array_new ();

2165

data->event = g_object_ref_sink (zeitgeist_event_new ());

2166

if (data->actor != NULL) {

2167

zeitgeist_event_set_actor (data->event, data->_tmp0_ = g_strconcat ("application://", data->actor, NULL));

2168

_g_free0 (data->_tmp0_);

2169

}

2170

g_ptr_array_add (data->ptr_array, data->event);

2171

data->_state_ = 3;

2172

zeitgeist_log_find_events (data->self->priv->zg_log, data->_tmp1_ = g_object_ref_sink (zeitgeist_time_range_new_to_now ()), (data->_tmp2_ = data->ptr_array, data->ptr_array = NULL, data->_tmp2_), ZEITGEIST_STORAGE_STATE_ANY, (guint32) 16, ZEITGEIST_RESULT_TYPE_MOST_POPULAR_SUBJECTS, NULL, related_applet_get_events_for_actor_ready, data);

2173

return FALSE;

2174

_state_3:

2175

data->events = (data->_tmp3_ = zeitgeist_log_find_events_finish (data->self->priv->zg_log, data->_res_, &data->_inner_error_), _g_object_unref0 (data->_tmp1_), data->_tmp3_);

2176

if (data->_inner_error_ != NULL) {

2177

_g_object_unref0 (data->event);

2178

_g_ptr_array_free0 (data->ptr_array);

2179

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);

2180

g_clear_error (&data->_inner_error_);

2181

return FALSE;

2182

}

2183

data->results_pushed = 0;

2184

{

2185

data->_e_it = _vala_zeitgeist_result_set_iterator (data->events);

2186

while (TRUE) {

2187

if (!((data->e = _vala_zeitgeist_result_set_next_value (data->_e_it)) != NULL)) {

2188

break;

2189

}

2190

if (zeitgeist_event_num_subjects (data->e) > 0) {

2191

data->s = _g_object_ref0 (zeitgeist_event_get_subject (data->e, 0));

2192

if (data->results_pushed < 4) {

2193

data->_tmp4_ = related_applet_push_result (data->self, data->e, data->s);

2194

} else {

2195

data->_tmp4_ = FALSE;

2196

}

2197

if (data->_tmp4_) {

2198

data->results_pushed++;

2199

}

2200

_g_object_unref0 (data->s);

2201

}

2202

}

2203

_g_object_unref0 (data->_e_it);

2204

}

2205

data->result = zeitgeist_result_set_size (data->events) > 0;

2206

_g_object_unref0 (data->events);

2207

_g_object_unref0 (data->event);

2208

_g_ptr_array_free0 (data->ptr_array);

2209

{

2210

if (data->_state_ == 0) {

2211

g_simple_async_result_complete_in_idle (data->_async_result);

2212

} else {

2213

g_simple_async_result_complete (data->_async_result);

2214

}

2215

g_object_unref (data->_async_result);

2216

return FALSE;

2217

}

2218

_g_object_unref0 (data->events);

2219

_g_object_unref0 (data->event);

2220

_g_ptr_array_free0 (data->ptr_array);

2221

{

2222

if (data->_state_ == 0) {

2223

g_simple_async_result_complete_in_idle (data->_async_result);

2224

} else {

2225

g_simple_async_result_complete (data->_async_result);

2226

}

2227

g_object_unref (data->_async_result);

2228

return FALSE;

2229

}

2230

}

2231

2232

2233

static void related_applet_build_dialog_data_free (gpointer _data) {

2234

RelatedAppletBuildDialogData* data;

2235

data = _data;

2236

_g_free0 (data->desktop_file);

2237

g_object_unref (data->self);

2238

g_slice_free (RelatedAppletBuildDialogData, data);

2239

}

2240

2241

2242

static void related_applet_build_dialog (RelatedApplet* self, const char* desktop_file, GAsyncReadyCallback _callback_, gpointer _user_data_) {

2243

RelatedAppletBuildDialogData* _data_;

2244

_data_ = g_slice_new0 (RelatedAppletBuildDialogData);

2245

_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, related_applet_build_dialog);

2246

g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, related_applet_build_dialog_data_free);

2247

_data_->self = g_object_ref (self);

2248

_data_->desktop_file = g_strdup (desktop_file);

2249

related_applet_build_dialog_co (_data_);

2250

}

2251

2252

2253

static void related_applet_build_dialog_finish (RelatedApplet* self, GAsyncResult* _res_) {

2254

RelatedAppletBuildDialogData* _data_;

2255

_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));

2256

}

2257

2258

2259

static void related_applet_build_dialog_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {

2260

RelatedAppletBuildDialogData* data;

2261

data = _user_data_;

2262

data->_res_ = _res_;

2263

related_applet_build_dialog_co (data);

2264

}

2265

2266

2267

static gboolean related_applet_build_dialog_co (RelatedAppletBuildDialogData* data) {

2268

switch (data->_state_) {

2269

case 0:

2270

goto _state_0;

2271

default:

2272

g_assert_not_reached ();

2273

case 4:

2274

goto _state_4;

2275

case 5:

2276

goto _state_5;

2277

case 6:

2278

goto _state_6;

2279

}

2280

_state_0:

2281

if (data->self->priv->vbox != NULL) {

2282

gtk_object_destroy ((GtkObject*) data->self->priv->vbox);

2283

}

2284

data->self->priv->vbox = (data->_tmp0_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 3)), _g_object_unref0 (data->self->priv->vbox), data->_tmp0_);

2285

gtk_container_add ((GtkContainer*) data->self->priv->dialog, (GtkWidget*) data->self->priv->vbox);

2286

data->found1 = FALSE;

2287

data->found2 = FALSE;

2288

data->self->priv->current_desktop_file_path = (data->_tmp1_ = g_strdup (data->desktop_file), _g_free0 (data->self->priv->current_desktop_file_path), data->_tmp1_);

2289

g_object_set (data->self->priv->throbber, "active", TRUE, NULL);

2290

if (data->desktop_file != NULL) {

2291

data->df_data = (DesktopFileInfo*) g_hash_table_lookup (data->self->priv->desktop_file_info, data->desktop_file);

2292

if (data->df_data != NULL) {

2293

data->_tmp2_ = (*data->df_data).mimetypes_length1 > 0;

2294

} else {

2295

data->_tmp2_ = FALSE;

2296

}

2297

if (data->_tmp2_) {

2298

data->_state_ = 4;

2299

related_applet_get_recent_by_mimetype (data->self, (*data->df_data).mimetypes, (*data->df_data).mimetypes_length1, related_applet_build_dialog_ready, data);

2300

return FALSE;

2301

_state_4:

2302

data->found1 = related_applet_get_recent_by_mimetype_finish (data->self, data->_res_);

2303

}

2304

} else {

2305

data->_tmp3_ = NULL;

2306

data->_state_ = 5;

2307

related_applet_get_recent_by_mimetype (data->self, (data->_tmp4_ = (data->_tmp3_ = g_new0 (char*, 0 + 1), data->_tmp3_), data->_tmp4__length1 = 0, data->_tmp4_), 0, related_applet_build_dialog_ready, data);

2308

return FALSE;

2309

_state_5:

2310

data->found1 = related_applet_get_recent_by_mimetype_finish (data->self, data->_res_);

2311

data->_tmp4_ = (_vala_array_free (data->_tmp4_, data->_tmp4__length1, (GDestroyNotify) g_free), NULL);

2312

}

2313

if (data->found1) {

2314

gtk_container_add ((GtkContainer*) data->self->priv->vbox, (GtkWidget*) (data->_tmp5_ = g_object_ref_sink ((GtkHSeparator*) gtk_hseparator_new ())));

2315

_g_object_unref0 (data->_tmp5_);

2316

}

2317

data->actor = NULL;

2318

if (data->desktop_file != NULL) {

2319

data->actor = g_utf8_offset_to_pointer (g_utf8_strrchr (data->desktop_file, (gssize) (-1), (gunichar) '/'), (glong) 1);

2320

}

2321

data->_state_ = 6;

2322

related_applet_get_events_for_actor (data->self, data->actor, related_applet_build_dialog_ready, data);

2323

return FALSE;

2324

_state_6:

2325

data->found2 = related_applet_get_events_for_actor_finish (data->self, data->_res_);

2326

if (data->desktop_file != NULL) {

2327

data->_tmp7_ = !data->found1;

2328

} else {

2329

data->_tmp7_ = FALSE;

2330

}

2331

if (data->_tmp7_) {

2332

data->_tmp6_ = !data->found2;

2333

} else {

2334

data->_tmp6_ = FALSE;

2335

}

2336

if (data->_tmp6_) {

2337

related_applet_build_dialog (data->self, NULL, NULL, NULL);

2338

{

2339

if (data->_state_ == 0) {

2340

g_simple_async_result_complete_in_idle (data->_async_result);

2341

} else {

2342

g_simple_async_result_complete (data->_async_result);

2343

}

2344

g_object_unref (data->_async_result);

2345

return FALSE;

2346

}

2347

}

2348

g_object_set (data->self->priv->throbber, "active", FALSE, NULL);

2349

if (!data->found1) {

2350

data->_tmp8_ = !data->found2;

2351

} else {

2352

data->_tmp8_ = FALSE;

2353

}

2354

if (data->_tmp8_) {

2355

data->l = g_object_ref_sink ((GtkLabel*) gtk_label_new ("There are no items to display..."));

2356

gtk_container_add ((GtkContainer*) data->self->priv->vbox, (GtkWidget*) data->l);

2357

_g_object_unref0 (data->l);

2358

}

2359

gtk_widget_show_all ((GtkWidget*) data->self->priv->dialog);

2360

{

2361

if (data->_state_ == 0) {

2362

g_simple_async_result_complete_in_idle (data->_async_result);

2363

} else {

2364

g_simple_async_result_complete (data->_async_result);

2365

}

2366

g_object_unref (data->_async_result);

2367

return FALSE;

2368

}

2369

}

2370

2371

2372

static void related_applet_on_clicked (RelatedApplet* self) {

2373

GtkWidgetFlags dialog_flags;

2374

WnckWindow* active;

2375

char* desktop_file;

2376

g_return_if_fail (self != NULL);

2377

dialog_flags = GTK_WIDGET_FLAGS ((GtkWidget*) self->priv->dialog) & GTK_VISIBLE;

2378

if (dialog_flags != 0) {

2379

gtk_widget_hide ((GtkWidget*) self->priv->dialog);

2380

return;

2381

}

2382

g_object_set (self->priv->dialog, "hide-on-unfocus", TRUE, NULL);

2383

active = _g_object_ref0 (wnck_screen_get_active_window (self->priv->wnck_screen));

2384

desktop_file = g_strdup ((const char*) g_object_get_data ((GObject*) active, "desktop-file-path"));

2385

related_applet_build_dialog (self, desktop_file, NULL, NULL);

2386

_g_free0 (desktop_file);

2387

_g_object_unref0 (active);

2388

}

2389

2390

2391

static void _g_list_free_g_free (GList* self) {

2392

g_list_foreach (self, (GFunc) g_free, NULL);

2393

g_list_free (self);

2394

}

2395

2396

2397

static void _lambda0_ (Block1Data* _data1_) {

2398

RelatedApplet * self;

2399

GAppLaunchContext* context;

2400

GError * _inner_error_ = NULL;

2401

self = _data1_->self;

2402

context = g_app_launch_context_new ();

2403

if (_data1_->desktop_file == NULL) {

2404

char* _tmp0_;

2405

g_app_info_launch_default_for_uri (_tmp0_ = g_file_get_uri (_data1_->f), context, &_inner_error_);

2406

_g_free0 (_tmp0_);

2407

if (_inner_error_ != NULL) {

2408

_g_object_unref0 (context);

2409

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

2410

g_clear_error (&_inner_error_);

2411

return;

2412

}

2413

} else {

2414

GDesktopAppInfo* app_info;

2415

app_info = g_desktop_app_info_new_from_filename (_data1_->desktop_file);

2416

if (g_app_info_supports_uris ((GAppInfo*) app_info)) {

2417

GList* l;

2418

l = NULL;

2419

l = g_list_append (l, g_file_get_uri (_data1_->f));

2420

g_app_info_launch_uris ((GAppInfo*) app_info, l, context, &_inner_error_);

2421

if (_inner_error_ != NULL) {

2422

__g_list_free_g_free0 (l);

2423

_g_object_unref0 (app_info);

2424

_g_object_unref0 (context);

2425

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

2426

g_clear_error (&_inner_error_);

2427

return;

2428

}

2429

__g_list_free_g_free0 (l);

2430

} else {

2431

GList* l;

2432

l = NULL;

2433

l = g_list_append (l, _g_object_ref0 (_data1_->f));

2434

g_app_info_launch ((GAppInfo*) app_info, l, context, &_inner_error_);

2435

if (_inner_error_ != NULL) {

2436

__g_list_free_g_object_unref0 (l);

2437

_g_object_unref0 (app_info);

2438

_g_object_unref0 (context);

2439

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

2440

g_clear_error (&_inner_error_);

2441

return;

2442

}

2443

__g_list_free_g_object_unref0 (l);

2444

}

2445

_g_object_unref0 (app_info);

2446

}

2447

gtk_widget_hide ((GtkWidget*) self->priv->dialog);

2448

_g_object_unref0 (context);

2449

}

2450

2451

2452

static void __lambda0__gtk_button_clicked (GtkButton* _sender, gpointer self) {

2453

_lambda0_ (self);

2454

}

2455

2456

2457

static Block1Data* block1_data_ref (Block1Data* _data1_) {

2458

g_atomic_int_inc (&_data1_->_ref_count_);

2459

return _data1_;

2460

}

2461

2462

2463

static void block1_data_unref (Block1Data* _data1_) {

2464

if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {

2465

_g_object_unref0 (_data1_->self);

2466

_g_free0 (_data1_->desktop_file);

2467

_g_object_unref0 (_data1_->f);

2468

g_slice_free (Block1Data, _data1_);

2469

}

2470

}

2471

2472

2473

static gboolean related_applet_push_result (RelatedApplet* self, ZeitgeistEvent* event, ZeitgeistSubject* subject) {

2474

gboolean result = FALSE;

2475

Block1Data* _data1_;

2476

gboolean _tmp0_ = FALSE;

2477

char* text;

2478

GIcon* icon;

2479

GtkButton* button;

2480

GtkHBox* hbox;

2481

GtkImage* image;

2482

GtkLabel* label;

2483

char* _tmp4_;

2484

GError * _inner_error_ = NULL;

2485

g_return_val_if_fail (self != NULL, FALSE);

2486

g_return_val_if_fail (event != NULL, FALSE);

2487

g_return_val_if_fail (subject != NULL, FALSE);

2488

_data1_ = g_slice_new0 (Block1Data);

2489

_data1_->_ref_count_ = 1;

2490

_data1_->self = g_object_ref (self);

2491

_data1_->f = g_file_new_for_uri (zeitgeist_subject_get_uri (subject));

2492

if (g_file_is_native (_data1_->f)) {

2493

_tmp0_ = !g_file_query_exists (_data1_->f, NULL);

2494

} else {

2495

_tmp0_ = FALSE;

2496

}

2497

if (_tmp0_) {

2498

result = FALSE;

2499

block1_data_unref (_data1_);

2500

return result;

2501

}

2502

text = g_strdup (zeitgeist_subject_get_text (subject));

2503

if (text == NULL) {

2504

char* _tmp1_;

2505

text = (_tmp1_ = g_file_get_basename (_data1_->f), _g_free0 (text), _tmp1_);

2506

}

2507

icon = NULL;

2508

if (g_file_is_native (_data1_->f)) {

2509

GFileInfo* fi;

2510

GIcon* _tmp2_;

2511

fi = g_file_query_info (_data1_->f, G_FILE_ATTRIBUTE_STANDARD_ICON, 0, NULL, &_inner_error_);

2512

if (_inner_error_ != NULL) {

2513

_g_object_unref0 (icon);

2514

_g_free0 (text);

2515

block1_data_unref (_data1_);

2516

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

2517

g_clear_error (&_inner_error_);

2518

return FALSE;

2519

}

2520

icon = (_tmp2_ = _g_object_ref0 (g_file_info_get_icon (fi)), _g_object_unref0 (icon), _tmp2_);

2521

_g_object_unref0 (fi);

2522

} else {

2523

GIcon* _tmp3_;

2524

icon = (_tmp3_ = g_content_type_get_icon (zeitgeist_subject_get_mimetype (subject)), _g_object_unref0 (icon), _tmp3_);

2525

}

2526

button = g_object_ref_sink ((GtkButton*) gtk_button_new ());

2527

hbox = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 6));

2528

image = g_object_ref_sink ((GtkImage*) gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_BUTTON));

2529

label = g_object_ref_sink ((GtkLabel*) gtk_label_new (text));

2530

gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_MIDDLE);

2531

gtk_label_set_max_width_chars (label, 35);

2532

g_object_set ((GtkMisc*) label, "xalign", 0.0f, NULL);

2533

gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) image, FALSE, TRUE, (guint) 0);

2534

gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) label, TRUE, TRUE, (guint) 0);

2535

gtk_button_set_relief (button, GTK_RELIEF_NONE);

2536

gtk_button_set_focus_on_click (button, FALSE);

2537

gtk_container_add ((GtkContainer*) button, (GtkWidget*) hbox);

2538

_tmp4_ = NULL;

2539

if (g_file_is_native (_data1_->f)) {

2540

char* _tmp5_;

2541

_tmp4_ = (_tmp5_ = g_file_get_path (_data1_->f), _g_free0 (_tmp4_), _tmp5_);

2542

} else {

2543

char* _tmp6_;

2544

_tmp4_ = (_tmp6_ = g_file_get_uri (_data1_->f), _g_free0 (_tmp4_), _tmp6_);

2545

}

2546

gtk_widget_set_tooltip_text ((GtkWidget*) button, _tmp4_);

2547

_data1_->desktop_file = g_strdup (self->priv->current_desktop_file_path);

2548

g_signal_connect_data (button, "clicked", (GCallback) __lambda0__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);

2549

gtk_container_add ((GtkContainer*) self->priv->vbox, (GtkWidget*) button);

2550

result = TRUE;

2551

_g_free0 (_tmp4_);

2552

_g_object_unref0 (label);

2553

_g_object_unref0 (image);

2554

_g_object_unref0 (hbox);

2555

_g_object_unref0 (button);

2556

_g_object_unref0 (icon);

2557

_g_free0 (text);

2558

block1_data_unref (_data1_);

2559

return result;

2560

}

2561

2562

2563

static GObject * related_applet_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {

2564

GObject * obj;

2565

GObjectClass * parent_class;

2566

RelatedApplet * self;

2567

parent_class = G_OBJECT_CLASS (related_applet_parent_class);

2568

obj = parent_class->constructor (type, n_construct_properties, construct_properties);

2569

self = RELATED_APPLET (obj);

2570

{

2571

AwnOverlay* _tmp1_;

2572

AwnOverlay* _tmp2_;

2573

g_object_set (self->priv->star_overlay, "active", FALSE, NULL);

2574

g_object_set (self->priv->star_overlay, "gravity", GDK_GRAVITY_SOUTH_EAST, NULL);

2575

g_object_set ((_tmp1_ = self->priv->star_overlay, AWN_IS_OVERLAY_THEMED_ICON (_tmp1_) ? ((AwnOverlayThemedIcon*) _tmp1_) : NULL), "scale", 0.3, NULL);

2576

g_object_set (self->priv->throbber, "gravity", GDK_GRAVITY_SOUTH_WEST, NULL);

2577

g_object_set ((_tmp2_ = self->priv->throbber, AWN_IS_OVERLAY_THROBBER (_tmp2_) ? ((AwnOverlayThrobber*) _tmp2_) : NULL), "scale", 0.3, NULL);

2578

}

2579

return obj;

2580

}

2581

2582

2583

static void related_applet_class_init (RelatedAppletClass * klass) {

2584

related_applet_parent_class = g_type_class_peek_parent (klass);

2585

g_type_class_add_private (klass, sizeof (RelatedAppletPrivate));

2586

G_OBJECT_CLASS (klass)->constructor = related_applet_constructor;

2587

G_OBJECT_CLASS (klass)->finalize = related_applet_finalize;

2588

}

2589

2590

2591

static void related_applet_instance_init (RelatedApplet * self) {

2592

self->priv = RELATED_APPLET_GET_PRIVATE (self);

2593

self->priv->lookup = awn_desktop_lookup_cached_new ();

2594

self->priv->zg_log = zeitgeist_log_new ();

2595

self->priv->throbber = (AwnOverlay*) g_object_ref_sink ((AwnOverlayThrobber*) awn_overlay_throbber_new ());

2596

self->priv->star_overlay = (AwnOverlay*) g_object_ref_sink (awn_overlay_themed_icon_new (GTK_STOCK_ABOUT));

2597

}

2598

2599

2600

static void related_applet_finalize (GObject* obj) {

2601

RelatedApplet * self;

2602

self = RELATED_APPLET (obj);

2603

_g_object_unref0 (self->priv->lookup);

2604

_g_object_unref0 (self->priv->zg_log);

2605

_g_object_unref0 (self->priv->throbber);

2606

_g_object_unref0 (self->priv->star_overlay);

2607

_g_hash_table_unref0 (self->priv->desktop_file_info);

2608

_g_object_unref0 (self->priv->dialog);

2609

_g_object_unref0 (self->priv->vbox);

2610

_g_free0 (self->priv->current_desktop_file_path);

2611

G_OBJECT_CLASS (related_applet_parent_class)->finalize (obj);

2612

}

2613

2614

2615

GType related_applet_get_type (void) {

2616

static volatile gsize related_applet_type_id__volatile = 0;

2617

if (g_once_init_enter (&related_applet_type_id__volatile)) {

2618

static const GTypeInfo g_define_type_info = { sizeof (RelatedAppletClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) related_applet_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RelatedApplet), 0, (GInstanceInitFunc) related_applet_instance_init, NULL };

2619

GType related_applet_type_id;

2620

related_applet_type_id = g_type_register_static (AWN_TYPE_APPLET_SIMPLE, "RelatedApplet", &g_define_type_info, 0);

2621

g_once_init_leave (&related_applet_type_id__volatile, related_applet_type_id);

2622

}

2623

return related_applet_type_id__volatile;

2624

}

2625

2626

2627

AwnApplet* awn_applet_factory_initp (const char* canonical_name, const char* uid, gint panel_id) {

2628

AwnApplet* result = NULL;

2629

g_return_val_if_fail (canonical_name != NULL, NULL);

2630

g_return_val_if_fail (uid != NULL, NULL);

2631

result = (AwnApplet*) g_object_ref_sink (related_applet_new (canonical_name, uid, panel_id));

2632

return result;

2633

}

2634

2635

2636

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {

2637

if ((array != NULL) && (destroy_func != NULL)) {

2638

int i;

2639

for (i = 0; i < array_length; i = i + 1) {

2640

if (((gpointer*) array)[i] != NULL) {

2641

destroy_func (((gpointer*) array)[i]);

2642

}

2643

}

2644

}

2645

}

2646

2647

2648

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {

2649

_vala_array_destroy (array, array_length, destroy_func);

2650

g_free (array);

2651

}

2652

2653

2654

static int _vala_strcmp0 (const char * str1, const char * str2) {

2655

if (str1 == NULL) {

2656

return -(str1 != str2);

2657

}

2658

if (str2 == NULL) {

2659

return str1 != str2;

2660

}

2661

return strcmp (str1, str2);

2662

}

2663

2664

2665

2666

Older »