← Back to branch summary

~rodrigo-moya/ubuntuone-client/no-enabling-on-special-udfs

« back to all changes in this revision

Viewing changes to nautilus/ubuntuone-nautilus.c

  • Committer: Tarmac
  • Author(s): Rodrigo Moya
  • Date: 2010-07-06 22:54:29 UTC
  • mfrom: (554.4.5 direct-dbus-is-no-more)
  • Revision ID: rodrigo@megeve-20100706225429-i9teuxkq5lyga87m
Do all Syncdaemon access via DBus from libsyncdaemon, no more direct DBus calls in the Nautilus plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
nautilus/ubuntuone-nautilus.c
72
72
                                            gboolean success,
73
73
                                            SyncdaemonMetadata *metadata,
74
74
                                            gpointer user_data);
75
 
static void ubuntuone_nautilus_end_dbus_call (DBusGProxy * proxy,
76
 
                                              DBusGProxyCall * call_id,
77
 
                                              gpointer user_data);
78
 
static void ubuntuone_nautilus_got_shared (DBusGProxy * proxy,
79
 
                                           DBusGProxyCall * call_id,
80
 
                                           gpointer user_data);
81
 
static void ubuntuone_nautilus_status_changed (DBusGProxy * proxy,
82
 
                                               GHashTable * hash,
 
75
static void ubuntuone_nautilus_status_changed (SyncdaemonDaemon *daemon,
 
76
                                               SyncdaemonStatusInfo *status_info,
83
77
                                               gpointer user_data);
84
 
static void ubuntuone_nautilus_upload_started (DBusGProxy * proxy,
 
78
static void ubuntuone_nautilus_upload_started (SyncdaemonDaemon *daemon,
85
79
                                               gchar * path,
86
80
                                               gpointer user_data);
87
 
static void ubuntuone_nautilus_upload_finished (DBusGProxy * proxy,
88
 
                                                 gchar * path, GHashTable * info,
89
 
                                                 gpointer user_data);
90
 
static void ubuntuone_nautilus_download_started (DBusGProxy * proxy,
91
 
                                                 gchar * path,
92
 
                                                 gpointer user_data);
93
 
static void ubuntuone_nautilus_download_finished (DBusGProxy * proxy,
94
 
                                                  gchar * path, GHashTable * info,
 
81
static void ubuntuone_nautilus_upload_finished (SyncdaemonDaemon *daemon,
 
82
                                                 gchar * path,
 
83
                                                SyncdaemonTransferInfo * info,
 
84
                                                 gpointer user_data);
 
85
static void ubuntuone_nautilus_download_started (SyncdaemonDaemon *daemon,
 
86
                                                 gchar * path,
 
87
                                                 gpointer user_data);
 
88
static void ubuntuone_nautilus_download_finished (SyncdaemonDaemon *daemon,
 
89
                                                  gchar * path,
 
90
                                                  SyncdaemonTransferInfo * info,
95
91
                                                  gpointer user_data);
96
 
static void ubuntuone_nautilus_udf_created (DBusGProxy * proxy,
97
 
                                            GHashTable * hash,
98
 
                                            gpointer user_data);
99
 
static void ubuntuone_nautilus_udf_deleted (DBusGProxy * proxy,
100
 
                                            GHashTable * hash,
101
 
                                            gpointer user_data);
102
 
static void ubuntuone_nautilus_udf_error (DBusGProxy * proxy,
103
 
                                          GHashTable * hash,
104
 
                                          gchar * error,
105
 
                                          gpointer user_data);
 
92
static void ubuntuone_nautilus_udf_created (SyncdaemonDaemon *daemon,
 
93
                                            gboolean success,
 
94
                                            SyncdaemonFolderInfo *folder_info,
 
95
                                            gpointer user_data);
 
96
static void ubuntuone_nautilus_udf_deleted (SyncdaemonDaemon *daemon,
 
97
                                            gboolean success,
 
98
                                            SyncdaemonFolderInfo *folder_info,
 
99
                                            gpointer user_data);
106
100
static void ubuntuone_nautilus_file_published (SyncdaemonDaemon *daemon,
107
101
                                               GHashTable * hash,
108
102
                                               gpointer user_data);
109
103
static void ubuntuone_nautilus_got_public_files (SyncdaemonDaemon *daemon,
110
104
                                                 GPtrArray * files,
111
105
                                                 gpointer user_data);
112
 
static void ubuntuone_nautilus_share_created (DBusGProxy * proxy,
113
 
                                              GHashTable * hash,
114
 
                                              gpointer user_data);
115
 
static void ubuntuone_nautilus_sharing_error (DBusGProxy * proxy,
116
 
                                              GHashTable * hash,
117
 
                                              gchar * error,
 
106
static void ubuntuone_nautilus_share_created (SyncdaemonDaemon *daemon,
 
107
                                              gboolean success,
 
108
                                              GHashTable * hash,
118
109
                                              gpointer user_data);
119
110
 
120
111
static GObjectClass * parent_class = NULL;
442
433
  switch (response) {
443
434
  case GTK_RESPONSE_ACCEPT: {
444
435
    gchar * name, * modify;
445
 
    GSList *emails, *l;
446
 
    gchar **emails_array;
 
436
    GSList *emails;
447
437
    gint i;
 
438
    SyncdaemonSharesInterface *interface;
448
439
    gboolean allow_mods = FALSE;
449
440
 
450
441
    emails = u1_contacts_picker_get_selected_emails (U1_CONTACTS_PICKER (data->user_picker));
462
453
      return;
463
454
    }
464
455
 
465
 
    emails_array = g_new0 (gchar *, g_slist_length (emails));
466
 
    for (l = emails, i = 0; l != NULL; l = l->next, i++)
467
 
       emails_array[i] = g_strdup (l->data);
468
 
 
469
456
    name = g_strdup (gtk_entry_get_text (GTK_ENTRY (data->name_entry)));
470
457
    allow_mods = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->allow_mods));
471
458
    modify = g_strdup_printf ("%d", allow_mods);
472
459
 
473
 
    dbus_g_proxy_begin_call (data->uon->u1_shares, "create_shares",
474
 
                             ubuntuone_nautilus_end_dbus_call, NULL,
475
 
                             NULL,
476
 
                             G_TYPE_STRING, data->path,
477
 
                             G_TYPE_STRV, emails_array,
478
 
                             G_TYPE_STRING, name,
479
 
                             G_TYPE_STRING, modify,
480
 
                             G_TYPE_INVALID);
 
460
    interface = SYNCDAEMON_SHARES_INTERFACE (syncdaemon_daemon_get_shares_interface (data->uon->syncdaemon));
 
461
    if (interface != NULL) {
 
462
            syncdaemon_shares_interface_create (interface,
 
463
                                                data->path,
 
464
                                                emails,
 
465
                                                name,
 
466
                                                modify);
 
467
    }
481
468
 
482
 
    g_strfreev (emails_array);
483
469
    u1_contacts_picker_free_selection_list (emails);
484
470
    g_free (name);
485
471
    g_free (modify);
566
552
                                               gpointer * user_data) {
567
553
  struct _CBData * data = (struct _CBData *) user_data;
568
554
  gchar * share_id;
 
555
  SyncdaemonSharesInterface *interface;
569
556
 
570
 
  share_id = g_hash_table_lookup (data->uon->shares, data->path);
571
 
  dbus_g_proxy_begin_call (data->uon->u1_shares, "delete_share",
572
 
                           ubuntuone_nautilus_end_dbus_call, NULL,
573
 
                           NULL,
574
 
                           G_TYPE_STRING, share_id,
575
 
                           G_TYPE_INVALID);
 
557
  interface = (SyncdaemonSharesInterface *) syncdaemon_daemon_get_shares_interface (data->uon->syncdaemon);
 
558
  if (interface != NULL) {
 
559
    share_id = g_hash_table_lookup (data->uon->shares, data->path);
 
560
    syncdaemon_shares_interface_delete (interface, share_id);
 
561
  }
576
562
}
577
563
 
578
564
/* Menu provider */
730
716
static GType un_type = 0;
731
717
 
732
718
static void ubuntuone_nautilus_instance_init (UbuntuOneNautilus * uon) {
 
719
  SyncdaemonSharesInterface *interface;
 
720
 
733
721
  uon->connected = FALSE;
734
722
  uon->uploads = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
735
723
  uon->downloads = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
740
728
  uon->udfs = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
741
729
  uon->public = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
742
730
 
743
 
  uon->bus = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
744
 
  if (!uon->bus) {
745
 
    g_warning ("Failed to get session bus.");
746
 
    return;
747
 
  }
748
 
 
749
731
  uon->syncdaemon = syncdaemon_daemon_new ();
750
 
  uon->u1_status = dbus_g_proxy_new_for_name (uon->bus,
751
 
                                              "com.ubuntuone.SyncDaemon",
752
 
                                              "/status",
753
 
                                              "com.ubuntuone.SyncDaemon.Status");
754
 
  uon->u1_shares = dbus_g_proxy_new_for_name (uon->bus,
755
 
                                              "com.ubuntuone.SyncDaemon",
756
 
                                              "/shares",
757
 
                                              "com.ubuntuone.SyncDaemon.Shares");
758
 
 
759
 
  uon->u1_folders = dbus_g_proxy_new_for_name (uon->bus,
760
 
                                               "com.ubuntuone.SyncDaemon",
761
 
                                               "/folders",
762
 
                                               "com.ubuntuone.SyncDaemon.Folders");
763
732
 
764
733
  /* Default to ~/Ubuntu One for now, as it's all we really support */
765
734
  uon->managed = g_build_filename (g_get_home_dir (), "Ubuntu One", NULL);
776
745
  uon->managed = g_strdup (syncdaemon_daemon_get_root_dir (uon->syncdaemon));
777
746
  if (uon->managed != NULL)
778
747
    uon->gotroot = TRUE;
779
 
  dbus_g_proxy_begin_call (uon->u1_shares, "get_shared",
780
 
                           ubuntuone_nautilus_got_shared, uon,
781
 
                           NULL, G_TYPE_INVALID);
 
748
 
 
749
  interface = SYNCDAEMON_SHARES_INTERFACE (syncdaemon_daemon_get_shares_interface (uon->syncdaemon));
 
750
  if (interface) {
 
751
    syncdaemon_shares_interface_get_shared (interface);
 
752
  }
782
753
#endif
783
754
 
784
 
  /* Marshaller for UploadFinished and DownloadFinished signals */
785
 
  dbus_g_object_register_marshaller (ubuntuone_nautilus_marshal_VOID__STRING_OBJECT,
786
 
                                     G_TYPE_NONE,
787
 
                                     G_TYPE_STRING,
788
 
                                     dbus_g_type_get_map ("GHashTable",
789
 
                                        G_TYPE_STRING,
790
 
                                        G_TYPE_STRING),
791
 
                                     G_TYPE_INVALID);
792
 
 
793
 
  /* Marshaller for ShareCreateError signal */
794
 
  dbus_g_object_register_marshaller (ubuntuone_nautilus_marshal_VOID__OBJECT_STRING,
795
 
                                     G_TYPE_NONE,
796
 
                                     dbus_g_type_get_map ("GHashTable",
797
 
                                        G_TYPE_STRING,
798
 
                                        G_TYPE_STRING),
799
 
                                     G_TYPE_STRING,
800
 
                                     G_TYPE_INVALID);
801
 
 
802
 
  dbus_g_proxy_add_signal (uon->u1_status, "StatusChanged",
803
 
                           dbus_g_type_get_map ("GHashTable",
804
 
                                                G_TYPE_STRING,
805
 
                                                G_TYPE_STRING),
806
 
                           G_TYPE_INVALID);
807
 
  dbus_g_proxy_connect_signal (uon->u1_status, "StatusChanged",
808
 
                               G_CALLBACK(ubuntuone_nautilus_status_changed),
809
 
                               uon, NULL);
810
 
 
811
 
  dbus_g_proxy_add_signal (uon->u1_status, "UploadStarted",
812
 
                           G_TYPE_STRING,
813
 
                           G_TYPE_INVALID);
814
 
  dbus_g_proxy_connect_signal (uon->u1_status, "UploadStarted",
815
 
                               G_CALLBACK (ubuntuone_nautilus_upload_started),
816
 
                               uon, NULL);
817
 
  dbus_g_proxy_add_signal (uon->u1_status, "UploadFinished",
818
 
                           G_TYPE_STRING,
819
 
                           dbus_g_type_get_map ("GHashTable",
820
 
                                                G_TYPE_STRING,
821
 
                                                G_TYPE_STRING),
822
 
                           G_TYPE_INVALID);
823
 
  dbus_g_proxy_connect_signal (uon->u1_status, "UploadFinished",
824
 
                               G_CALLBACK (ubuntuone_nautilus_upload_finished),
825
 
                               uon, NULL);
826
 
  dbus_g_proxy_add_signal (uon->u1_status, "DownloadStarted",
827
 
                           G_TYPE_STRING,
828
 
                           G_TYPE_INVALID);
829
 
  dbus_g_proxy_connect_signal (uon->u1_status, "DownloadStarted",
830
 
                               G_CALLBACK (ubuntuone_nautilus_download_started),
831
 
                               uon, NULL);
832
 
  dbus_g_proxy_add_signal (uon->u1_status, "DownloadFinished",
833
 
                           G_TYPE_STRING,
834
 
                           dbus_g_type_get_map ("GHashTable",
835
 
                                                G_TYPE_STRING,
836
 
                                                G_TYPE_STRING),
837
 
                           G_TYPE_INVALID);
838
 
  dbus_g_proxy_connect_signal (uon->u1_status, "DownloadFinished",
839
 
                               G_CALLBACK (ubuntuone_nautilus_download_finished),
840
 
                               uon, NULL);
841
 
  dbus_g_proxy_add_signal (uon->u1_shares, "ShareCreated",
842
 
                           dbus_g_type_get_map ("GHashTable",
843
 
                                                G_TYPE_STRING,
844
 
                                                G_TYPE_STRING),
845
 
                           G_TYPE_INVALID);
846
 
  dbus_g_proxy_connect_signal (uon->u1_shares, "ShareCreated",
847
 
                               G_CALLBACK (ubuntuone_nautilus_share_created),
848
 
                               uon, NULL);
849
 
  dbus_g_proxy_add_signal (uon->u1_shares, "ShareCreateError",
850
 
                           dbus_g_type_get_map ("GHashTable",
851
 
                                                G_TYPE_STRING,
852
 
                                                G_TYPE_STRING),
853
 
                           G_TYPE_STRING,
854
 
                           G_TYPE_INVALID);
855
 
  dbus_g_proxy_connect_signal (uon->u1_shares, "ShareCreateError",
856
 
                               G_CALLBACK (ubuntuone_nautilus_sharing_error),
857
 
                               uon, NULL);
858
 
 
859
 
  dbus_g_proxy_add_signal (uon->u1_folders, "FolderCreated",
860
 
                           dbus_g_type_get_map ("GHashTable",
861
 
                                                G_TYPE_STRING,
862
 
                                                G_TYPE_STRING),
863
 
                           G_TYPE_INVALID);
864
 
  dbus_g_proxy_connect_signal (uon->u1_folders, "FolderCreated",
865
 
                               G_CALLBACK (ubuntuone_nautilus_udf_created),
866
 
                               uon, NULL);
867
 
  dbus_g_proxy_add_signal (uon->u1_folders, "FolderSubscribed",
868
 
                           dbus_g_type_get_map ("GHashTable",
869
 
                                                G_TYPE_STRING,
870
 
                                                G_TYPE_STRING),
871
 
                           G_TYPE_INVALID);
872
 
  dbus_g_proxy_connect_signal (uon->u1_folders, "FolderSubscribed",
873
 
                               G_CALLBACK (ubuntuone_nautilus_udf_created),
874
 
                               uon, NULL);
875
 
  dbus_g_proxy_add_signal (uon->u1_folders, "FolderCreateError",
876
 
                                                   dbus_g_type_get_map ("GHashTable",
877
 
                                                                                                G_TYPE_STRING,
878
 
                                                                                                G_TYPE_STRING),
879
 
                                                   G_TYPE_STRING,
880
 
                                                   G_TYPE_INVALID);
881
 
  dbus_g_proxy_connect_signal (uon->u1_folders, "FolderCreateError",
882
 
                                                           G_CALLBACK (ubuntuone_nautilus_udf_error),
883
 
                                                           uon, NULL);
884
 
  dbus_g_proxy_add_signal (uon->u1_folders, "FolderSubscribeError",
885
 
                                                   dbus_g_type_get_map ("GHashTable",
886
 
                                                                                                G_TYPE_STRING,
887
 
                                                                                                G_TYPE_STRING),
888
 
                                                   G_TYPE_STRING,
889
 
                                                   G_TYPE_INVALID);
890
 
  dbus_g_proxy_connect_signal (uon->u1_folders, "FolderSubscribeError",
891
 
                                                           G_CALLBACK (ubuntuone_nautilus_udf_error),
892
 
                                                           uon, NULL);
893
 
 
894
 
  dbus_g_proxy_add_signal (uon->u1_folders, "FolderDeleted",
895
 
                           dbus_g_type_get_map ("GHashTable",
896
 
                                                G_TYPE_STRING,
897
 
                                                G_TYPE_STRING),
898
 
                           G_TYPE_INVALID);
899
 
  dbus_g_proxy_connect_signal (uon->u1_folders, "FolderDeleted",
900
 
                               G_CALLBACK (ubuntuone_nautilus_udf_deleted),
901
 
                               uon, NULL);
902
 
  dbus_g_proxy_add_signal (uon->u1_folders, "FolderUnSubscribed",
903
 
                           dbus_g_type_get_map ("GHashTable",
904
 
                                                G_TYPE_STRING,
905
 
                                                G_TYPE_STRING),
906
 
                           G_TYPE_INVALID);
907
 
  dbus_g_proxy_connect_signal (uon->u1_folders, "FolderUnSubscribed",
908
 
                               G_CALLBACK (ubuntuone_nautilus_udf_deleted),
909
 
                               uon, NULL);
910
 
  dbus_g_proxy_add_signal (uon->u1_folders, "FolderDeleteError",
911
 
                                                   dbus_g_type_get_map ("GHashTable",
912
 
                                                                                                G_TYPE_STRING,
913
 
                                                                                                G_TYPE_STRING),
914
 
                                                   G_TYPE_STRING,
915
 
                                                   G_TYPE_INVALID);
916
 
  dbus_g_proxy_connect_signal (uon->u1_folders, "FolderDeleteError",
917
 
                                                           G_CALLBACK (ubuntuone_nautilus_udf_error),
918
 
                                                           uon, NULL);
919
 
  dbus_g_proxy_add_signal (uon->u1_folders, "FolderUnSubscribeError",
920
 
                                                   dbus_g_type_get_map ("GHashTable",
921
 
                                                                                                G_TYPE_STRING,
922
 
                                                                                                G_TYPE_STRING),
923
 
                                                   G_TYPE_STRING,
924
 
                                                   G_TYPE_INVALID);
925
 
  dbus_g_proxy_connect_signal (uon->u1_folders, "FolderUnSubscribeError",
926
 
                                                           G_CALLBACK (ubuntuone_nautilus_udf_error),
927
 
                                                           uon, NULL);
928
 
 
 
755
  g_signal_connect (G_OBJECT (uon->syncdaemon), "status_changed",
 
756
                    G_CALLBACK (ubuntuone_nautilus_status_changed), uon);
 
757
  g_signal_connect (G_OBJECT (uon->syncdaemon), "upload_started",
 
758
                    G_CALLBACK (ubuntuone_nautilus_upload_started), uon);
 
759
  g_signal_connect (G_OBJECT (uon->syncdaemon), "upload_finished",
 
760
                    G_CALLBACK (ubuntuone_nautilus_upload_finished), uon);
 
761
  g_signal_connect (G_OBJECT (uon->syncdaemon), "download_started",
 
762
                    G_CALLBACK (ubuntuone_nautilus_download_started), uon);
 
763
  g_signal_connect (G_OBJECT (uon->syncdaemon), "download_finished",
 
764
                    G_CALLBACK (ubuntuone_nautilus_download_finished), uon);
 
765
 
 
766
  g_signal_connect (G_OBJECT (uon->syncdaemon), "share_created",
 
767
                    G_CALLBACK (ubuntuone_nautilus_share_created), uon);
 
768
 
 
769
  g_signal_connect (G_OBJECT (uon->syncdaemon), "folder_created",
 
770
                    G_CALLBACK (ubuntuone_nautilus_udf_created), uon);
 
771
  g_signal_connect (G_OBJECT (uon->syncdaemon), "folder_subscribed",
 
772
                    G_CALLBACK (ubuntuone_nautilus_udf_created), uon);
 
773
  g_signal_connect (G_OBJECT (uon->syncdaemon), "folder_deleted",
 
774
                    G_CALLBACK (ubuntuone_nautilus_udf_deleted), uon);
 
775
  g_signal_connect (G_OBJECT (uon->syncdaemon), "folder_unsubscribed",
 
776
                    G_CALLBACK (ubuntuone_nautilus_udf_deleted), uon);
929
777
 
930
778
  /* Connect to public files-related signals */
931
779
  g_signal_connect (G_OBJECT (uon->syncdaemon), "file_published",
949
797
  if (uon->syncdaemon)
950
798
    g_object_unref (uon->syncdaemon);
951
799
 
952
 
  if (uon->u1_status)
953
 
    g_object_unref (uon->u1_status);
954
 
 
955
 
  if (uon->u1_shares)
956
 
    g_object_unref (uon->u1_shares);
957
 
 
958
 
  if (uon->u1_folders)
959
 
    g_object_unref (uon->u1_folders);
960
 
 
961
 
  if (uon->bus)
962
 
    dbus_g_connection_unref (uon->bus);
963
 
 
964
800
  g_hash_table_destroy (uon->uploads);
965
801
  uon->uploads = NULL;
966
802
 
1084
920
  ubuntuone_nautilus_reset_emblem (uon, new_path);
1085
921
}
1086
922
 
1087
 
static void ubuntuone_nautilus_end_dbus_call (DBusGProxy * proxy,
1088
 
                                              DBusGProxyCall * call_id,
1089
 
                                              gpointer user_data) {
1090
 
  g_return_if_fail (proxy != NULL);
1091
 
 
1092
 
  dbus_g_proxy_end_call (proxy, call_id, NULL, G_TYPE_INVALID);
1093
 
}
1094
 
 
1095
 
static void ubuntuone_nautilus_got_udfs(DBusGProxy * proxy,
1096
 
                                        DBusGProxyCall * call_id,
1097
 
                                        gpointer user_data) {
1098
 
  UbuntuOneNautilus * uon;
1099
 
  GSList * data, *l;
1100
 
  GError * error = NULL;
1101
 
 
1102
 
  g_return_if_fail (proxy != NULL);
1103
 
 
1104
 
  if (!dbus_g_proxy_end_call (proxy, call_id, &error,
1105
 
                              dbus_g_type_get_collection ("GSList",
1106
 
                                                          dbus_g_type_get_map
1107
 
                                                          ("GHashTable",
1108
 
                                                           G_TYPE_STRING,
1109
 
                                                           G_TYPE_STRING)),
1110
 
                              &data,
1111
 
                              G_TYPE_INVALID)) {
1112
 
    g_warning ("ERROR: %s", error->message);
1113
 
    return;
1114
 
  }
1115
 
 
1116
 
  uon = UBUNTUONE_NAUTILUS (user_data);
1117
 
  for (l = data; l != NULL && l->data != NULL; l = l->next) {
1118
 
    GHashTable * hash = l->data;
1119
 
    ubuntuone_nautilus_udf_created (proxy, hash, user_data);
1120
 
  }
1121
 
  g_slist_free (data);
1122
 
 
1123
 
  uon->gotudfs = TRUE;
1124
 
}
1125
 
 
1126
 
static void ubuntuone_nautilus_got_shared (DBusGProxy * proxy,
1127
 
                                           DBusGProxyCall * call_id,
1128
 
                                           gpointer user_data) {
1129
 
  UbuntuOneNautilus * uon;
1130
 
  GSList * data, * l;
1131
 
  GError * error = NULL;
1132
 
 
1133
 
  g_return_if_fail (proxy != NULL);
1134
 
 
1135
 
  if (!dbus_g_proxy_end_call (proxy, call_id, &error,
1136
 
                              dbus_g_type_get_collection ("GSList",
1137
 
                                                          dbus_g_type_get_map
1138
 
                                                          ("GHashTable",
1139
 
                                                           G_TYPE_STRING,
1140
 
                                                           G_TYPE_STRING)),
1141
 
                              &data,
1142
 
                              G_TYPE_INVALID)) {
1143
 
    g_warning ("ERROR: %s", error->message);
1144
 
    return;
1145
 
  }
1146
 
 
1147
 
  uon = UBUNTUONE_NAUTILUS (user_data);
1148
 
  for (l = data; l != NULL && l->data != NULL; l = l->next) {
1149
 
    GHashTable * hash = l->data;
1150
 
    ubuntuone_nautilus_share_created (proxy, hash, user_data);
1151
 
  }
1152
 
  g_slist_free (data);
1153
 
}
1154
 
 
1155
 
static void ubuntuone_nautilus_status_changed (DBusGProxy * proxy,
1156
 
                                               GHashTable * hash,
 
923
static void ubuntuone_nautilus_status_changed (SyncdaemonDaemon *daemon,
 
924
                                               SyncdaemonStatusInfo *status_info,
1157
925
                                               gpointer user_data) {
1158
926
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1159
 
  gchar * status;
 
927
  const gchar * status;
1160
928
  gboolean is_online;
1161
929
 
1162
 
  is_online = g_strcmp0(g_hash_table_lookup (hash, "is_online"), "True") == 0;
1163
 
  status = g_hash_table_lookup (hash, "name");
 
930
  is_online = syncdaemon_status_info_get_online (status_info);
 
931
  status = syncdaemon_status_info_get_name (status_info);
1164
932
 
1165
933
  /* Get the root when we get a status change signal, if we haven't yet */
1166
934
  if (!uon->gotroot) {
1170
938
  }
1171
939
 
1172
940
  /* Get the list of UDFs if we haven't already */
1173
 
  if (!uon->gotudfs)
1174
 
    dbus_g_proxy_begin_call (uon->u1_folders, "get_folders",
1175
 
                             ubuntuone_nautilus_got_udfs, uon,
1176
 
                             NULL, G_TYPE_INVALID);
 
941
  if (!uon->gotudfs) {
 
942
    SyncdaemonInterface *interface;
 
943
 
 
944
    interface = syncdaemon_daemon_get_folders_interface (uon->syncdaemon);
 
945
    if (interface != NULL) {
 
946
            GSList *folders, *l;
 
947
 
 
948
      folders = syncdaemon_folders_interface_get_folders (SYNCDAEMON_FOLDERS_INTERFACE (interface));
 
949
      for (l = folders; l != NULL; l = l->next) {
 
950
        SyncdaemonFolderInfo *folder_info = SYNCDAEMON_FOLDER_INFO (l->data);
 
951
 
 
952
        ubuntuone_nautilus_udf_created (uon->syncdaemon, TRUE, folder_info, uon);
 
953
        uon->gotudfs = TRUE;
 
954
      }
 
955
 
 
956
      g_slist_free (folders);
 
957
    }
 
958
  }
1177
959
 
1178
960
  /* Get the list of public files if we haven't already */
1179
961
  if (is_online && !uon->gotpubs) {
1187
969
  }
1188
970
}
1189
971
 
1190
 
static void ubuntuone_nautilus_upload_started (DBusGProxy * proxy,
 
972
static void ubuntuone_nautilus_upload_started (SyncdaemonDaemon *daemon,
1191
973
                                               gchar * path,
1192
974
                                               gpointer user_data) {
1193
975
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1199
981
  }
1200
982
}
1201
983
 
1202
 
static void ubuntuone_nautilus_upload_finished (DBusGProxy * proxy,
1203
 
                                                gchar * path, GHashTable * info,
 
984
static void ubuntuone_nautilus_upload_finished (SyncdaemonDaemon *daemon,
 
985
                                                gchar * path,
 
986
                                                SyncdaemonTransferInfo * info,
1204
987
                                                gpointer user_data) {
1205
988
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1206
989
  gchar * new_path;
1214
997
  ubuntuone_nautilus_reset_emblem (uon, path);
1215
998
}
1216
999
 
1217
 
static void ubuntuone_nautilus_download_started (DBusGProxy * proxy,
 
1000
static void ubuntuone_nautilus_download_started (SyncdaemonDaemon *daemon,
1218
1001
                                                 gchar * path,
1219
1002
                                                 gpointer user_data) {
1220
1003
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1226
1009
  }
1227
1010
}
1228
1011
 
1229
 
static void ubuntuone_nautilus_download_finished (DBusGProxy * proxy,
 
1012
static void ubuntuone_nautilus_download_finished (SyncdaemonDaemon *daemon,
1230
1013
                                                  gchar * path,
1231
 
                                                  GHashTable * info,
 
1014
                                                  SyncdaemonTransferInfo * info,
1232
1015
                                                  gpointer user_data) {
1233
1016
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1234
1017
  gchar * new_path;
1242
1025
  ubuntuone_nautilus_reset_emblem (uon, path);
1243
1026
}
1244
1027
 
1245
 
static void ubuntuone_nautilus_udf_created (DBusGProxy * proxy,
1246
 
                                            GHashTable * hash,
 
1028
static void ubuntuone_nautilus_udf_created (SyncdaemonDaemon *daemon,
 
1029
                                            gboolean success,
 
1030
                                            SyncdaemonFolderInfo *folder_info,
1247
1031
                                            gpointer user_data) {
1248
1032
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1249
 
  gchar * path, * id, * subbed;
 
1033
  const gchar * path, * id;
1250
1034
  gboolean subscribed;
1251
1035
 
1252
 
  path = g_hash_table_lookup (hash, "path");
1253
 
  id = g_hash_table_lookup (hash, "volume_id");
1254
 
  subbed = g_hash_table_lookup (hash, "subscribed");
1255
 
  subscribed = (subbed != NULL && strlen (subbed) != 0);
1256
 
  if (!g_hash_table_lookup (uon->udfs, path)) {
1257
 
    if (subscribed) {
1258
 
      g_hash_table_replace (uon->udfs, g_strdup (path), g_strdup (id));
1259
 
      ubuntuone_nautilus_reset_emblem (uon, path);
1260
 
    }
1261
 
  }
1262
 
}
1263
 
 
1264
 
static void ubuntuone_nautilus_udf_deleted (DBusGProxy * proxy,
1265
 
                                           GHashTable * hash,
1266
 
                                           gpointer user_data) {
1267
 
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1268
 
  gchar * path;
1269
 
 
1270
 
  path = g_hash_table_lookup (hash, "path");
1271
 
  if (path != NULL) {
1272
 
        g_hash_table_remove (uon->udfs, path);
 
1036
  path = syncdaemon_folder_info_get_path (folder_info);
 
1037
  id = syncdaemon_folder_info_get_volume_id (folder_info);
 
1038
  subscribed = syncdaemon_folder_info_get_subscribed (folder_info);
 
1039
  if (success) {
 
1040
    if (!g_hash_table_lookup (uon->udfs, path)) {
 
1041
      if (subscribed) {
 
1042
        g_hash_table_replace (uon->udfs, g_strdup (path), g_strdup (id));
1273
1043
        ubuntuone_nautilus_reset_emblem (uon, path);
 
1044
      }
 
1045
    }
1274
1046
  }
1275
1047
}
1276
1048
 
1277
 
static void ubuntuone_nautilus_udf_error (DBusGProxy * proxy,
1278
 
                                                                                  GHashTable * hash,
1279
 
                                                                                  gchar * error,
1280
 
                                                                                  gpointer user_data) {
 
1049
static void ubuntuone_nautilus_udf_deleted (SyncdaemonDaemon *daemon,
 
1050
                                            gboolean success,
 
1051
                                            SyncdaemonFolderInfo *folder_info,
 
1052
                                            gpointer user_data) {
1281
1053
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1282
 
  gchar * path, * id, * subbed;
1283
 
  gboolean subscribed;
1284
 
 
1285
 
  path = g_hash_table_lookup (hash, "path");
1286
 
  id = g_hash_table_lookup (hash, "volume_id");
1287
 
  subbed = g_hash_table_lookup (hash, "subscribed");
1288
 
  subscribed = (subbed != NULL && strlen (subbed) != 0);
1289
 
 
1290
 
  if (id != NULL && subscribed)
1291
 
        ubuntuone_nautilus_udf_created (proxy, hash, user_data);
1292
 
  else
1293
 
        ubuntuone_nautilus_udf_deleted (proxy, hash, user_data);
 
1054
  const gchar * path;
 
1055
 
 
1056
  path = syncdaemon_folder_info_get_path (folder_info);
 
1057
  if (path != NULL && success) {
 
1058
    g_hash_table_remove (uon->udfs, path);
 
1059
    ubuntuone_nautilus_reset_emblem (uon, path);
 
1060
  }
1294
1061
}
1295
1062
 
1296
1063
static void ubuntuone_nautilus_file_published (SyncdaemonDaemon *daemon,
1328
1095
                         g_strdup (g_hash_table_lookup (files->pdata[i], "public_url")));
1329
1096
}
1330
1097
 
1331
 
static void ubuntuone_nautilus_share_created (DBusGProxy * proxy,
 
1098
static void ubuntuone_nautilus_share_created (SyncdaemonDaemon *daemon,
 
1099
                                              gboolean success,
1332
1100
                                              GHashTable * hash,
1333
1101
                                              gpointer user_data) {
1334
1102
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1335
 
  gchar * path, * id;
 
1103
  gchar * path;
1336
1104
 
1337
1105
  path = g_hash_table_lookup (hash, "path");
1338
 
  id = g_hash_table_lookup (hash, "volume_id");
 
1106
  if (success) {
 
1107
    gchar * id;
 
1108
    id = g_hash_table_lookup (hash, "volume_id");
1339
1109
 
1340
 
  if (!g_hash_table_lookup (uon->shares, path)) {
1341
 
    g_hash_table_insert (uon->shares, g_strdup (path), g_strdup (id));
1342
 
    ubuntuone_nautilus_reset_emblem (uon, path);
 
1110
    if (!g_hash_table_lookup (uon->shares, path)) {
 
1111
      g_hash_table_insert (uon->shares, g_strdup (path), g_strdup (id));
 
1112
      ubuntuone_nautilus_reset_emblem (uon, path);
 
1113
    }
 
1114
  } else {
 
1115
    ubuntuone_show_error_dialog (uon, _("Error creating share."),
 
1116
                                 _("There was an error sharing the folder '%s'"),
 
1117
                                 path);
1343
1118
  }
1344
1119
}
1345
1120
 
1346
 
static void ubuntuone_nautilus_sharing_error (DBusGProxy * proxy,
1347
 
                                              GHashTable * hash,
1348
 
                                              gchar * error,
1349
 
                                              gpointer user_data) {
1350
 
  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
1351
 
  gchar * path, * message;
1352
 
  GtkWidget * dialog;
1353
 
 
1354
 
  path = g_hash_table_lookup (hash, "path");
1355
 
 
1356
 
  dialog = gtk_message_dialog_new (GTK_WINDOW (uon->cb_data->parent),
1357
 
                                   GTK_DIALOG_DESTROY_WITH_PARENT,
1358
 
                                   GTK_MESSAGE_ERROR,
1359
 
                                   GTK_BUTTONS_CLOSE,
1360
 
                                   _("Error creating share."));
1361
 
  message = g_strdup_printf (_("There was an error sharing the folder '%s':\n%s"),
1362
 
                             path,
1363
 
                             error);
1364
 
  gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
1365
 
                                            "%s", message);
1366
 
  g_free (message);
1367
 
  g_signal_connect_swapped (G_OBJECT (dialog), "response",
1368
 
                            G_CALLBACK (gtk_widget_destroy), dialog);
1369
 
  gtk_widget_show (dialog);
1370
 
}
1371
 
 
1372
1121
/* Required Nautilus module handling methods */
1373
1122
void nautilus_module_initialize (GTypeModule * module) {
1374
1123
#ifdef ENABLE_NLS