src/opimd/frameworkd-glib-opimd-messages.c

   1 /*
   2  *  Copyright (C) 2009
   3  *      Authors (alphabetical) :
   4  *              mrmoku (Klaus Kurzmann, mok@fluxnetz.de)
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU Public License as published by
   8  *  the Free Software Foundation; version 2 of the license.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU Lesser Public License for more details.
  14  */
  15
  16
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19
  20 #include <dbus/dbus-glib.h>
  21 #include <dbus/dbus-glib-bindings.h>
  22 #include "frameworkd-glib-opimd-messages.h"
  23 #include "frameworkd-glib-opimd-dbus.h"
  24 #include "dbus/messages.h"
  25
  26
  27 DBusGProxy *opimdMessagesBus = NULL;
  28
  29 /* === PIM.Messages Interface ====================================================== */
  30
  31 /* --- Add ------------------------------------------------------------------------- */
  32
  33 typedef struct {
  34         void (*callback) (GError *, char *, gpointer);
  35         gpointer userdata;
  36 } opimd_messages_add_data_t;
  37
  38 void
  39 opimd_messages_add_callback(DBusGProxy * proxy, char *message_path,
  40                             GError * dbus_error, gpointer userdata)
  41 {
  42         (void)proxy;
  43         opimd_messages_add_data_t *data = userdata;
  44         GError *error = NULL;
  45
  46         if (data->callback != NULL) {
  47                 if (dbus_error != NULL)
  48                         error = dbus_handle_errors(dbus_error);
  49                 data->callback(error, message_path, data->userdata);
  50                 if (error != NULL)
  51                         g_error_free(error);
  52         }
  53         if (dbus_error != NULL)
  54                 g_error_free(dbus_error);
  55
  56         g_free(data);
  57 }
  58
  59 void
  60 opimd_messages_add(const GHashTable * message_data,
  61                    void (*callback) (GError *, char *, gpointer),
  62                    gpointer userdata)
  63 {
  64         dbus_connect_to_opimd_messages();
  65         opimd_messages_add_data_t *data =
  66                 g_malloc(sizeof(opimd_messages_add_data_t));
  67         data->callback = callback;
  68         data->userdata = userdata;
  69         org_freesmartphone_PIM_Messages_add_async(opimdMessagesBus,
  70                                                   message_data,
  71                                                   opimd_messages_add_callback,
  72                                                   data);
  73 }
  74
  75
  76 /* --- GetSingleEntrySingleField ------------------------------------------------- */
  77
  78 typedef struct {
  79         void (*callback) (GError *, char *, gpointer);
  80         gpointer userdata;
  81 } opimd_messages_get_single_entry_single_field_data_t;
  82
  83 void
  84 opimd_messages_get_single_entry_single_field_callback(DBusGProxy * bus,
  85                                                       char *value,
  86                                                       GError * dbus_error,
  87                                                       gpointer userdata)
  88 {
  89         (void)bus;
  90         opimd_messages_get_single_entry_single_field_data_t *data = userdata;
  91         GError *error = NULL;
  92
  93         if (data->callback != NULL) {
  94                 if (dbus_error != NULL)
  95                         error = dbus_handle_errors(dbus_error);
  96
  97                 data->callback(error, value, data->userdata);
  98                 if (error != NULL)
  99                         g_error_free(error);
 100         }
 101         if (dbus_error != NULL)
 102                 g_error_free(dbus_error);
 103
 104         g_free(data);
 105 }
 106
 107 void
 108 opimd_messages_get_single_entry_single_field(const GHashTable * query,
 109                                              const char *field,
 110                                              void (*callback) (GError *, char *,
 111                                                                gpointer),
 112                                              gpointer userdata)
 113 {
 114         dbus_connect_to_opimd_messages();
 115         opimd_messages_get_single_entry_single_field_data_t *data =
 116                 g_malloc(sizeof
 117                          (opimd_messages_get_single_entry_single_field_data_t));
 118         data->callback = callback;
 119         data->userdata = userdata;
 120         org_freesmartphone_PIM_Messages_get_single_entry_single_field_async
 121                 (opimdMessagesBus, query, field,
 122                  opimd_messages_get_single_entry_single_field_callback, data);
 123 }
 124
 125
 126 /* --- Query ----------------------------------------------------------------------- */
 127
 128 typedef struct {
 129         void (*callback) (GError *, char *, gpointer);
 130         gpointer userdata;
 131 } opimd_messages_query_data_t;
 132
 133 void
 134 opimd_messages_query_callback(DBusGProxy * proxy, char *query_path,
 135                               GError * dbus_error, gpointer userdata)
 136 {
 137         (void)proxy;
 138         opimd_messages_query_data_t *data = userdata;
 139         GError *error = NULL;
 140
 141         if (data->callback != NULL) {
 142                 if (dbus_error != NULL)
 143                         error = dbus_handle_errors(dbus_error);
 144                 data->callback(error, query_path, data->userdata);
 145                 if (error != NULL)
 146                         g_error_free(error);
 147         }
 148         if (dbus_error != NULL)
 149                 g_error_free(dbus_error);
 150
 151         g_free(data);
 152 }
 153
 154 void
 155 opimd_messages_query(const GHashTable * query,
 156                      void (*callback) (GError *, char *, gpointer),
 157                      gpointer userdata)
 158 {
 159         dbus_connect_to_opimd_messages();
 160         opimd_messages_query_data_t *data =
 161                 g_malloc(sizeof(opimd_messages_query_data_t));
 162         data->callback = callback;
 163         data->userdata = userdata;
 164         org_freesmartphone_PIM_Messages_query_async(opimdMessagesBus, query,
 165                                                     opimd_messages_query_callback,
 166                                                     data);
 167 }
 168
 169
 170 /* --- GetFolderNames -------------------------------------------------------------- */
 171
 172 typedef struct {
 173         void (*callback) (GError *, char **, gpointer);
 174         gpointer userdata;
 175 } opimd_messages_get_folder_names_data_t;
 176
 177 void
 178 opimd_messages_get_folder_names_callback(DBusGProxy * proxy,
 179                                          char **folder_names,
 180                                          GError * dbus_error, gpointer userdata)
 181 {
 182         (void)proxy;
 183         opimd_messages_get_folder_names_data_t *data = userdata;
 184         GError *error = NULL;
 185
 186         if (data->callback != NULL) {
 187                 if (dbus_error != NULL)
 188                         error = dbus_handle_errors(dbus_error);
 189                 data->callback(error, folder_names, data->userdata);
 190                 if (error != NULL)
 191                         g_error_free(error);
 192         }
 193         if (dbus_error != NULL)
 194                 g_error_free(dbus_error);
 195
 196         g_free(data);
 197 }
 198
 199 void
 200 opimd_messages_get_folder_names(void (*callback) (GError *, char **, gpointer),
 201                                 gpointer userdata)
 202 {
 203         dbus_connect_to_opimd_messages();
 204         opimd_messages_get_folder_names_data_t *data =
 205                 g_malloc(sizeof(opimd_messages_get_folder_names_data_t));
 206         data->callback = callback;
 207         data->userdata = userdata;
 208         org_freesmartphone_PIM_Messages_get_folder_names_async(opimdMessagesBus,
 209                                                                opimd_messages_get_folder_names_callback,
 210                                                                data);
 211 }
 212
 213
 214 /* --- GetFolderURIFromName -------------------------------------------------------- */
 215
 216 typedef struct {
 217         void (*callback) (GError *, char *, gpointer);
 218         gpointer userdata;
 219 } opimd_messages_get_folder_path_from_name_data_t;
 220
 221 void
 222 opimd_messages_get_folder_path_from_name_callback(DBusGProxy * proxy,
 223                                                   char *folder_path,
 224                                                   GError * dbus_error,
 225                                                   gpointer userdata)
 226 {
 227         (void)proxy;
 228         opimd_messages_get_folder_path_from_name_data_t *data = userdata;
 229         GError *error = NULL;
 230
 231         if (data->callback != NULL) {
 232                 if (dbus_error != NULL)
 233                         error = dbus_handle_errors(dbus_error);
 234                 data->callback(error, folder_path, data->userdata);
 235                 if (error != NULL)
 236                         g_error_free(error);
 237         }
 238         if (dbus_error != NULL)
 239                 g_error_free(dbus_error);
 240
 241         g_free(data);
 242 }
 243
 244 void
 245 opimd_messages_get_folder_path_from_name(const char *folder_name,
 246                                          void (*callback) (GError *, char *,
 247                                                            gpointer),
 248                                          gpointer userdata)
 249 {
 250         dbus_connect_to_opimd_messages();
 251         opimd_messages_get_folder_path_from_name_data_t *data =
 252                 g_malloc(sizeof
 253                          (opimd_messages_get_folder_path_from_name_data_t));
 254         data->callback = callback;
 255         data->userdata = userdata;
 256         org_freesmartphone_PIM_Messages_get_folder_path_from_name_async
 257                 (opimdMessagesBus, folder_name,
 258                  opimd_messages_get_folder_path_from_name_callback, data);
 259 }
 260
 261
 262 /* --- GetUnreadMessages ----------------------------------------------------------- */
 263
 264 typedef struct {
 265         void (*callback)(GError *, const int, gpointer);
 266         gpointer userdata;
 267 } opimd_messages_get_unread_messages_data_t;
 268
 269 void
 270 opimd_messages_get_unread_messages_callback(DBusGProxy *proxy,
 271                 const int amount, GError *dbus_error, gpointer userdata)
 272 {
 273         (void)proxy;
 274         opimd_messages_get_unread_messages_data_t *data = userdata;
 275         GError *error = NULL;
 276
 277         if (data->callback != NULL) {
 278                 if (dbus_error != NULL)
 279                         error = dbus_handle_errors(dbus_error);
 280                 data->callback(error, amount, data->userdata);
 281                 if (error != NULL)
 282                         g_error_free(error);
 283         }
 284         if (dbus_error != NULL)
 285                 g_error_free(dbus_error);
 286
 287         g_free(data);
 288 }
 289
 290 void
 291 opimd_messages_get_unread_messages(
 292                 void (*callback) (GError *, const int, gpointer),
 293                 gpointer userdata)
 294 {
 295         dbus_connect_to_opimd_messages();
 296         opimd_messages_get_unread_messages_data_t *data =
 297                 g_malloc(sizeof
 298                          (opimd_messages_get_unread_messages_data_t));
 299         data->callback = callback;
 300         data->userdata = userdata;
 301         org_freesmartphone_PIM_Messages_get_unread_messages_async
 302                 (opimdMessagesBus,
 303                  opimd_messages_get_unread_messages_callback, data);
 304 }
 305
 306 /* --- (signal) NewMessage --------------------------------------------------------- */
 307
 308 void
 309 opimd_messages_new_message_handler(DBusGProxy * proxy, const char *message_path,
 310                                    gpointer userdata)
 311 {
 312         (void)proxy;
 313         void (*callback) (const char *) = NULL;
 314
 315         callback = userdata;
 316
 317         if (callback != NULL)
 318                 (*callback) (message_path);
 319 }
 320
 321
 322 /* --- (signal) IncomingMessage ---------------------------------------------------- */
 323
 324 void
 325 opimd_messages_incoming_message_handler(DBusGProxy * proxy, const char *message_path,
 326                                         gpointer userdata)
 327 {
 328         (void)proxy;
 329         void (*callback) (const char *) = NULL;
 330
 331         callback = userdata;
 332
 333         if (callback != NULL)
 334                 (*callback) (message_path);
 335 }
 336
 337
 338 /* --- (signal) UnreadMessages -------------------------------------------------- */
 339
 340 void
 341 opimd_messages_unread_messages_handler(DBusGProxy *proxy,
 342                 int amount, gpointer userdata)
 343 {
 344         (void)proxy;
 345         void (*callback) (int) = NULL;
 346
 347         callback = userdata;
 348
 349         if (callback != NULL)
 350                 (*callback) (amount);
 351 }
 352
 353
 354 /* --- (signal) UpdatedMessage -------------------------------------------------- */
 355
 356 void
 357 opimd_messages_updated_message_handler(DBusGProxy *proxy,
 358                 const char *message_path, GHashTable *message_data,
 359                 gpointer userdata)
 360 {
 361         (void)proxy;
 362         void (*callback) (const char *, GHashTable *) = NULL;
 363
 364         callback = userdata;
 365
 366         if (callback != NULL)
 367                 (*callback) (message_path, message_data);
 368 }
 369
 370
 371 /* --- (signal) DeletedMessage -------------------------------------------------- */
 372
 373 void
 374 opimd_messages_deleted_message_handler(DBusGProxy *proxy,
 375                 const char *message_path, gpointer userdata)
 376 {
 377         (void)proxy;
 378         void (*callback) (const char *) = NULL;
 379
 380         callback = userdata;
 381
 382         if (callback != NULL)
 383                 (*callback) (message_path);
 384 }
 385
 386
 387
 388 /* === PIM.Message Interface ======================================================= */
 389
 390 /* --- GetContent ------------------------------------------------------------------ */
 391
 392 typedef struct {
 393         void (*callback) (GError *, GHashTable *, gpointer);
 394         gpointer userdata;
 395 } opimd_message_get_content_data_t;
 396
 397 void
 398 opimd_message_get_content_callback(DBusGProxy * proxy, GHashTable * content,
 399                                    GError * dbus_error, gpointer userdata)
 400 {
 401         (void)proxy;
 402         opimd_message_get_content_data_t *data = userdata;
 403         GError *error = NULL;
 404
 405         if (data->callback != NULL) {
 406                 if (dbus_error != NULL)
 407                         error = dbus_handle_errors(dbus_error);
 408                 data->callback(error, content, data->userdata);
 409                 if (error != NULL)
 410                         g_error_free(error);
 411         }
 412         if (dbus_error != NULL)
 413                 g_error_free(dbus_error);
 414
 415         g_free(data);
 416 }
 417
 418 void
 419 opimd_message_get_content(const char *message_path,
 420                           void (*callback) (GError *, GHashTable *, gpointer),
 421                           gpointer userdata)
 422 {
 423         DBusGProxy *proxy = dbus_connect_to_opimd_message(message_path);
 424         opimd_message_get_content_data_t *data =
 425                 g_malloc(sizeof(opimd_message_get_content_data_t));
 426         data->callback = callback;
 427         data->userdata = userdata;
 428         org_freesmartphone_PIM_Message_get_content_async(proxy,
 429                                                          opimd_message_get_content_callback,
 430                                                          data);
 431 }
 432
 433
 434 /* --- GetMultipleFields ----------------------------------------------------------- */
 435
 436 typedef struct {
 437         void (*callback) (GError *, GHashTable *, gpointer);
 438         gpointer userdata;
 439 } opimd_message_get_multiple_fields_data_t;
 440
 441 void
 442 opimd_message_get_multiple_fields_callback(DBusGProxy * proxy,
 443                                            GHashTable * field_data,
 444                                            GError * dbus_error,
 445                                            gpointer userdata)
 446 {
 447         (void)proxy;
 448         opimd_message_get_multiple_fields_data_t *data = userdata;
 449         GError *error = NULL;
 450
 451         if (data->callback != NULL) {
 452                 if (dbus_error != NULL)
 453                         error = dbus_handle_errors(dbus_error);
 454                 data->callback(error, field_data, userdata);
 455                 if (error != NULL)
 456                         g_error_free(error);
 457         }
 458         if (dbus_error != NULL)
 459                 g_error_free(dbus_error);
 460
 461         g_free(data);
 462 }
 463
 464 void
 465 opimd_message_get_multiple_fields(const char *message_path, const char *fields,
 466                                   void (*callback) (GError *, GHashTable *,
 467                                                     gpointer),
 468                                   gpointer userdata)
 469 {
 470         DBusGProxy *proxy = dbus_connect_to_opimd_message(message_path);
 471         opimd_message_get_multiple_fields_data_t *data =
 472                 g_malloc(sizeof(opimd_message_get_multiple_fields_data_t));
 473         data->callback = callback;
 474         data->userdata = userdata;
 475         org_freesmartphone_PIM_Message_get_multiple_fields_async(proxy, fields,
 476                                                                  opimd_message_get_multiple_fields_callback,
 477                                                                  data);
 478 }
 479
 480
 481 /* --- MoveToFolder ---------------------------------------------------------------- */
 482
 483 typedef struct {
 484         void (*callback) (GError *, gpointer);
 485         gpointer userdata;
 486 } opimd_message_move_to_folder_data_t;
 487
 488 void
 489 opimd_message_move_to_folder_callback(DBusGProxy * proxy, GError * dbus_error,
 490                                       gpointer userdata)
 491 {
 492         (void)proxy;
 493         opimd_message_move_to_folder_data_t *data = userdata;
 494         GError *error = NULL;
 495
 496         if (data->callback != NULL) {
 497                 if (dbus_error != NULL)
 498                         error = dbus_handle_errors(dbus_error);
 499                 data->callback(error, data->userdata);
 500                 if (error != NULL)
 501                         g_error_free(error);
 502         }
 503         if (dbus_error != NULL)
 504                 g_error_free(dbus_error);
 505
 506         g_free(data);
 507 }
 508
 509 void
 510 opimd_message_move_to_folder(const char *message_path, const char *folder,
 511                              void (*callback) (GError *, gpointer),
 512                              gpointer userdata)
 513 {
 514         DBusGProxy *proxy = dbus_connect_to_opimd_message(message_path);
 515         opimd_message_move_to_folder_data_t *data =
 516                 g_malloc(sizeof(opimd_message_move_to_folder_data_t));
 517         data->callback = callback;
 518         data->userdata = userdata;
 519         org_freesmartphone_PIM_Message_move_to_folder_async(proxy, folder,
 520                                                             opimd_message_move_to_folder_callback,
 521                                                             data);
 522 }
 523
 524
 525 /* --- Update ---------------------------------------------------------------------- */
 526
 527 typedef struct {
 528         void (*callback) (GError *, gpointer);
 529         gpointer userdata;
 530 } opimd_message_update_data_t;
 531
 532 void opimd_message_update_callback(DBusGProxy *proxy, GError *dbus_error,
 533                 gpointer userdata)
 534 {
 535         (void)proxy;
 536         opimd_message_update_data_t *data = userdata;
 537         GError *error = NULL;
 538
 539         if (data->callback != NULL) {
 540                 if (dbus_error != NULL)
 541                         error = dbus_handle_errors(dbus_error);
 542                 data->callback(error, data->userdata);
 543                 if (error)
 544                         g_error_free(error);
 545         }
 546
 547         if (dbus_error)
 548                 g_error_free(dbus_error);
 549
 550         g_free(data);
 551 }
 552
 553 void
 554 opimd_message_update(const char *message_path, GHashTable *field_data,
 555                 void (*callback)(GError *, gpointer), gpointer userdata)
 556 {
 557         DBusGProxy *proxy = dbus_connect_to_opimd_message(message_path);
 558         opimd_message_update_data_t *data =
 559                 g_malloc(sizeof(opimd_message_update_data_t));
 560         data->callback = callback;
 561         data->userdata = userdata;
 562         org_freesmartphone_PIM_Message_update_async(proxy, field_data,
 563                                                     opimd_message_update_callback,
 564                                                     data);
 565 }
 566
 567
 568 /* --- Delete ---------------------------------------------------------------------- */
 569
 570 typedef struct {
 571         void (*callback) (GError *, gpointer);
 572         gpointer userdata;
 573 } opimd_message_delete_data_t;
 574
 575
 576 void
 577 opimd_message_delete_callback(DBusGProxy * proxy, GError * dbus_error,
 578                               gpointer userdata)
 579 {
 580         (void)proxy;
 581         opimd_message_delete_data_t *data = userdata;
 582         GError *error = NULL;
 583
 584         if (data->callback != NULL) {
 585                 if (dbus_error != NULL)
 586                         error = dbus_handle_errors(dbus_error);
 587                 data->callback(error, data->userdata);
 588                 if (error)
 589                         g_error_free(error);
 590         }
 591
 592         if (dbus_error)
 593                 g_error_free(dbus_error);
 594
 595         g_free(data);
 596 }
 597
 598
 599 void
 600 opimd_message_delete(const char *message_path,
 601                      void (*callback) (GError *, gpointer), gpointer userdata)
 602 {
 603         DBusGProxy *proxy = dbus_connect_to_opimd_message(message_path);
 604         opimd_message_delete_data_t *data =
 605                 g_malloc(sizeof(opimd_message_delete_data_t));
 606         data->callback = callback;
 607         data->userdata = userdata;
 608         org_freesmartphone_PIM_Message_delete_async(proxy,
 609                                                     opimd_message_delete_callback,
 610                                                     data);
 611 }
 612
 613
 614
 615 /* === PIM.MessageQuery Interface ================================================== */
 616
 617 /* --- GetResultCount -------------------------------------------------------------- */
 618
 619 typedef struct {
 620         void (*callback) (GError *, gint, gpointer);
 621         gpointer userdata;
 622 } opimd_message_query_get_result_count_data_t;
 623
 624 void
 625 opimd_message_query_get_result_count_callback(DBusGProxy * proxy, int count,
 626                                               GError * dbus_error,
 627                                               gpointer userdata)
 628 {
 629         (void)proxy;
 630         opimd_message_query_get_result_count_data_t *data = userdata;
 631         GError *error = NULL;
 632
 633         if (data->callback != NULL) {
 634                 if (dbus_error != NULL)
 635                         error = dbus_handle_errors(dbus_error);
 636                 data->callback(error, count, data->userdata);
 637                 if (error != NULL)
 638                         g_error_free(error);
 639         }
 640         if (dbus_error != NULL)
 641                 g_error_free(dbus_error);
 642
 643         g_free(data);
 644 }
 645
 646 void
 647 opimd_message_query_get_result_count(DBusGProxy * query,
 648                                      void (*callback) (GError *, gint,
 649                                                        gpointer),
 650                                      gpointer userdata)
 651 {
 652         opimd_message_query_get_result_count_data_t *data =
 653                 g_malloc(sizeof(opimd_message_query_get_result_count_data_t));
 654         data->callback = callback;
 655         data->userdata = userdata;
 656         org_freesmartphone_PIM_MessageQuery_get_result_count_async(query,
 657                                                                    opimd_message_query_get_result_count_callback,
 658                                                                    data);
 659 }
 660
 661
 662 /* --- Rewind ---------------------------------------------------------------------- */
 663
 664 typedef struct {
 665         void (*callback) (GError *, gpointer);
 666         gpointer userdata;
 667 } opimd_message_query_rewind_data_t;
 668
 669 void
 670 opimd_message_query_rewind_callback(DBusGProxy * proxy, GError * dbus_error,
 671                                     gpointer userdata)
 672 {
 673         (void)proxy;
 674         opimd_message_query_rewind_data_t *data = userdata;
 675         GError *error = NULL;
 676
 677         if (data->callback != NULL) {
 678                 if (dbus_error != NULL)
 679                         error = dbus_handle_errors(dbus_error);
 680                 data->callback(error, data->userdata);
 681                 if (error != NULL)
 682                         g_error_free(error);
 683         }
 684         if (dbus_error != NULL)
 685                 g_error_free(dbus_error);
 686
 687         g_free(data);
 688 }
 689
 690 void
 691 opimd_message_query_rewind(DBusGProxy * query,
 692                            void (*callback) (GError *, gpointer),
 693                            gpointer userdata)
 694 {
 695         opimd_message_query_rewind_data_t *data =
 696                 g_malloc(sizeof(opimd_message_query_rewind_data_t));
 697         data->callback = callback;
 698         data->userdata = userdata;
 699         org_freesmartphone_PIM_MessageQuery_rewind_async(query,
 700                                                          opimd_message_query_rewind_callback,
 701                                                          data);
 702 }
 703
 704
 705 /* --- Skip ------------------------------------------------------------------------ */
 706
 707 typedef struct {
 708         void (*callback) (GError *, gpointer);
 709         gpointer userdata;
 710 } opimd_message_query_skip_data_t;
 711
 712 void
 713 opimd_message_query_skip_callback(DBusGProxy * proxy, GError * dbus_error,
 714                                   gpointer userdata)
 715 {
 716         (void)proxy;
 717         opimd_message_query_skip_data_t *data = userdata;
 718         GError *error = NULL;
 719
 720         if (data->callback != NULL) {
 721                 if (dbus_error != NULL)
 722                         error = dbus_handle_errors(dbus_error);
 723                 data->callback(error, data->userdata);
 724                 if (error != NULL)
 725                         g_error_free(error);
 726         }
 727         if (dbus_error != NULL)
 728                 g_error_free(dbus_error);
 729
 730         g_free(data);
 731 }
 732
 733 void
 734 opimd_message_query_skip(DBusGProxy * query, const gint count,
 735                          void (*callback) (GError *, gpointer),
 736                          gpointer userdata)
 737 {
 738         opimd_message_query_skip_data_t *data =
 739                 g_malloc(sizeof(opimd_message_query_skip_data_t));
 740         data->callback = callback;
 741         data->userdata = userdata;
 742         org_freesmartphone_PIM_MessageQuery_skip_async(query, count,
 743                                                        opimd_message_query_skip_callback,
 744                                                        data);
 745 }
 746
 747
 748 /* --- GetMessagePath -------------------------------------------------------------- */
 749
 750 typedef struct {
 751         void (*callback) (GError *, char *, gpointer);
 752         gpointer userdata;
 753 } opimd_message_query_get_message_path_data_t;
 754
 755 void
 756 opimd_message_query_get_message_path_callback(DBusGProxy * proxy,
 757                                               char *message_path,
 758                                               GError * dbus_error,
 759                                               gpointer userdata)
 760 {
 761         (void)proxy;
 762         opimd_message_query_get_message_path_data_t *data = userdata;
 763         GError *error = NULL;
 764
 765         if (data->callback != NULL) {
 766                 if (dbus_error != NULL)
 767                         error = dbus_handle_errors(dbus_error);
 768                 data->callback(error, message_path, data->userdata);
 769                 if (error != NULL)
 770                         g_error_free(error);
 771         }
 772         if (dbus_error != NULL)
 773                 g_error_free(dbus_error);
 774
 775         g_free(data);
 776 }
 777
 778 void
 779 opimd_message_query_get_message_path(DBusGProxy * query,
 780                                      void (*callback) (GError *, char *,
 781                                                        gpointer),
 782                                      gpointer userdata)
 783 {
 784         opimd_message_query_get_message_path_data_t *data =
 785                 g_malloc(sizeof(opimd_message_query_get_message_path_data_t));
 786         data->callback = callback;
 787         data->userdata = userdata;
 788         org_freesmartphone_PIM_MessageQuery_get_message_path_async(query,
 789                                                                    opimd_message_query_get_message_path_callback,
 790                                                                    data);
 791 }
 792
 793
 794 /* --- GetResult ------------------------------------------------------------------- */
 795
 796 typedef struct {
 797         void (*callback) (GError *, GHashTable *, gpointer);
 798         gpointer userdata;
 799 } opimd_message_query_get_result_data_t;
 800
 801 void
 802 opimd_message_query_get_result_callback(DBusGProxy * proxy, GHashTable * result,
 803                                         GError * dbus_error, gpointer userdata)
 804 {
 805         (void)proxy;
 806         opimd_message_query_get_result_data_t *data = userdata;
 807         GError *error = NULL;
 808
 809         if (data->callback != NULL) {
 810                 if (dbus_error != NULL)
 811                         error = dbus_handle_errors(dbus_error);
 812                 data->callback(error, result, data->userdata);
 813                 if (error != NULL)
 814                         g_error_free(error);
 815         }
 816         if (dbus_error != NULL)
 817                 g_error_free(dbus_error);
 818
 819         g_free(data);
 820 }
 821
 822 void
 823 opimd_message_query_get_result(DBusGProxy * query,
 824                                void (*callback) (GError *, GHashTable * result,
 825                                                  gpointer), gpointer userdata)
 826 {
 827         opimd_message_query_get_result_data_t *data =
 828                 g_malloc(sizeof(opimd_message_query_get_result_data_t));
 829         data->callback = callback;
 830         data->userdata = userdata;
 831         org_freesmartphone_PIM_MessageQuery_get_result_async(query,
 832                                                              opimd_message_query_get_result_callback,
 833                                                              data);
 834 }
 835
 836
 837 /* --- GetMultipleResults ---------------------------------------------------------- */
 838
 839 typedef struct {
 840         void (*callback) (GError *, GPtrArray *, gpointer);
 841         gpointer userdata;
 842 } opimd_message_query_get_multiple_results_data_t;
 843
 844 void
 845 opimd_message_query_get_multiple_results_callback(DBusGProxy * proxy,
 846                                                   GPtrArray * resultset,
 847                                                   GError * dbus_error,
 848                                                   gpointer userdata)
 849 {
 850         (void)proxy;
 851         opimd_message_query_get_multiple_results_data_t *data = userdata;
 852         GError *error = NULL;
 853
 854         if (data->callback != NULL) {
 855                 if (dbus_error != NULL)
 856                         error = dbus_handle_errors(dbus_error);
 857                 data->callback(error, resultset, data->userdata);
 858                 if (error != NULL)
 859                         g_error_free(error);
 860         }
 861         if (dbus_error != NULL)
 862                 g_error_free(dbus_error);
 863
 864         g_free(data);
 865 }
 866
 867 void
 868 opimd_message_query_get_multiple_results(DBusGProxy * query, int count,
 869                                          void (*callback) (GError *,
 870                                                            GPtrArray *,
 871                                                            gpointer),
 872                                          gpointer userdata)
 873 {
 874         opimd_message_query_get_multiple_results_data_t *data =
 875                 g_malloc(sizeof
 876                          (opimd_message_query_get_multiple_results_data_t));
 877         data->callback = callback;
 878         data->userdata = userdata;
 879         org_freesmartphone_PIM_MessageQuery_get_multiple_results_async(query,
 880                                                                        count,
 881                                                                        opimd_message_query_get_multiple_results_callback,
 882                                                                        data);
 883 }
 884
 885
 886
 887 /* --- Dispose --------------------------------------------------------------------- */
 888
 889 typedef struct {
 890         void (*callback) (GError *, gpointer);
 891         gpointer userdata;
 892 } opimd_message_query_dispose_data_t;
 893
 894 void
 895 opimd_message_query_dispose_callback(DBusGProxy * proxy, GError * dbus_error,
 896                                      gpointer userdata)
 897 {
 898         (void)proxy;
 899         opimd_message_query_dispose_data_t *data = userdata;
 900         GError *error = NULL;
 901
 902         if (data->callback != NULL) {
 903                 if (dbus_error != NULL)
 904                         error = dbus_handle_errors(dbus_error);
 905                 data->callback(error, data->userdata);
 906                 if (error != NULL)
 907                         g_error_free(error);
 908         }
 909         if (dbus_error != NULL)
 910                 g_error_free(dbus_error);
 911
 912         g_free(data);
 913 }
 914
 915 void
 916 opimd_message_query_dispose(DBusGProxy * query,
 917                             void (*callback) (GError *, gpointer),
 918                             gpointer userdata)
 919 {
 920         opimd_message_query_dispose_data_t *data =
 921                 g_malloc(sizeof(opimd_message_query_dispose_data_t));
 922         data->callback = callback;
 923         data->userdata = userdata;
 924         org_freesmartphone_PIM_MessageQuery_dispose_async(query,
 925                                                           opimd_message_query_dispose_callback,
 926                                                           data);
 927 }
 928
 929
 930 /* === PIM.MessageFolder Interface ================================================= */
 931
 932 /* --- GetMessageCount ------------------------------------------------------------- */
 933
 934 typedef struct {
 935         void (*callback) (GError *, gint, gpointer);
 936         gpointer userdata;
 937 } opimd_message_folder_get_message_count_data_t;
 938
 939 void
 940 opimd_message_folder_get_message_count_callback(DBusGProxy * proxy, gint count,
 941                                                 GError * dbus_error,
 942                                                 gpointer userdata)
 943 {
 944         (void)proxy;
 945         opimd_message_folder_get_message_count_data_t *data = userdata;
 946         GError *error = NULL;
 947
 948         if (data->callback != NULL) {
 949                 if (dbus_error != NULL)
 950                         error = dbus_handle_errors(dbus_error);
 951                 data->callback(error, count, data->userdata);
 952                 if (error != NULL)
 953                         g_error_free(error);
 954         }
 955         if (dbus_error != NULL)
 956                 g_error_free(dbus_error);
 957
 958         g_free(data);
 959 }
 960
 961 void
 962 opimd_message_folder_get_message_count(const char *folder_path,
 963                                        void (*callback) (GError *, gint,
 964                                                          gpointer),
 965                                        gpointer userdata)
 966 {
 967         DBusGProxy *proxy = dbus_connect_to_opimd_message_folder(folder_path);
 968         opimd_message_folder_get_message_count_data_t *data =
 969                 g_malloc(sizeof(opimd_message_folder_get_message_count_data_t));
 970         data->callback = callback;
 971         data->userdata = userdata;
 972         org_freesmartphone_PIM_MessageFolder_get_message_count_async(proxy,
 973                                                                      opimd_message_folder_get_message_count_callback,
 974                                                                      data);
 975 }
 976
 977
 978 /* --- GetMessagePaths ------------------------------------------------------------- */
 979
 980 typedef struct {
 981         void (*callback) (GError *, char **, gpointer);
 982         gpointer userdata;
 983 } opimd_message_folder_get_message_paths_data_t;
 984
 985 void
 986 opimd_message_folder_get_message_paths_callback(DBusGProxy * proxy,
 987                                                 char **message_paths,
 988                                                 GError * dbus_error,
 989                                                 gpointer userdata)
 990 {
 991         (void)proxy;
 992         opimd_message_folder_get_message_paths_data_t *data = userdata;
 993         GError *error = NULL;
 994
 995         if (data->callback != NULL) {
 996                 if (dbus_error != NULL)
 997                         error = dbus_handle_errors(dbus_error);
 998                 data->callback(error, message_paths, data->userdata);
 999                 if (error != NULL)
1000                         g_error_free(error);
1001         }
1002         if (dbus_error != NULL)
1003                 g_error_free(dbus_error);
1004
1005         g_free(data);
1006 }
1007
1008 void
1009 opimd_message_folder_get_message_paths(const char *folder_path,
1010                                        const gint first, const gint count,
1011                                        void (*callback) (GError *, char **,
1012                                                          gpointer),
1013                                        gpointer userdata)
1014 {
1015         DBusGProxy *proxy = dbus_connect_to_opimd_message_folder(folder_path);
1016         opimd_message_folder_get_message_paths_data_t *data =
1017                 g_malloc(sizeof(opimd_message_folder_get_message_paths_data_t));
1018         data->callback = callback;
1019         data->userdata = userdata;
1020         org_freesmartphone_PIM_MessageFolder_get_message_paths_async(proxy,
1021                                                                      first,
1022                                                                      count,
1023                                                                      opimd_message_folder_get_message_paths_callback,
1024                                                                      data);
1025 }
1026
1027
1028 /* --- (signal) MessageMoved ------------------------------------------------------- */
1029
1030 void
1031 opimd_message_folder_message_moved_handler(DBusGProxy * proxy,
1032                                            char *message_path, char *new_folder,
1033                                            gpointer userdata)
1034 {
1035         (void)proxy;
1036         void (*callback) (char *message_path, char *new_folder) = NULL;
1037
1038         callback = userdata;
1039
1040         if (callback != NULL)
1041                 (*callback) (message_path, new_folder);
1042 }