diff options
Diffstat (limited to 'src')
35 files changed, 1895 insertions, 278 deletions
diff --git a/src/Makefile.am b/src/Makefile.am index e43e66f..7cb7801 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -44,7 +44,7 @@ desktop_DATA = transmission-remote-gtk.desktop endif bin_PROGRAMS = transmission-remote-gtk -INCLUDES = -std=c99 -Wall -I.. -Wno-overflow -DTRGLICENSE=\""$(trglicense)"\" $(libcurl_CFLAGS) $(jsonglib_CFLAGS) $(gthread_CFLAGS) $(gtk_CFLAGS) $(gio_CFLAGS) $(notify_CFLAGS) $(libproxy_CFLAGS) $(libappindicator_CFLAGS) +INCLUDES = -std=c99 -Wall -I.. -Wno-overflow -DTRGLICENSE=\""$(trglicense)"\" $(libcurl_CFLAGS) $(jsonglib_CFLAGS) $(gthread_CFLAGS) $(gtk_CFLAGS) $(gio_CFLAGS) $(notify_CFLAGS) $(libproxy_CFLAGS) $(libappindicator_CFLAGS) $(rssglib_CFLAGS) transmission_remote_gtk_SOURCES = \ trg-cell-renderer-speed.c \ @@ -105,9 +105,13 @@ transmission_remote_gtk_SOURCES = \ trg-client.c \ trg-main-window.c \ main.c \ + trg-rss-model.c \ + trg-rss-window.c \ + trg-rss-cell-renderer.c \ + upload.c \ $(NULL) -transmission_remote_gtk_LDFLAGS = -lm $(jsonglib_LIBS) $(gtk_LIBS) $(gthread_LIBS) $(GEOIP_LIBS) $(gio_LIBS) $(notify_LIBS) $(libproxy_LIBS) $(libcurl_LIBS) $(libappindicator_LIBS) +transmission_remote_gtk_LDFLAGS = -lm $(jsonglib_LIBS) $(gtk_LIBS) $(gthread_LIBS) $(GEOIP_LIBS) $(gio_LIBS) $(notify_LIBS) $(libproxy_LIBS) $(libcurl_LIBS) $(libappindicator_LIBS) $(rssglib_LIBS) if WIN32 .rc.o: diff --git a/src/requests.c b/src/requests.c index 95be1d7..43a8561 100644 --- a/src/requests.c +++ b/src/requests.c @@ -227,7 +227,22 @@ JsonNode *torrent_add_url(const gchar * url, gboolean paused) return root; } -JsonNode *torrent_add(gchar * target, gint flags) +JsonNode *torrent_add_from_response(trg_response *response, gint flags) { + JsonNode *root = base_request(METHOD_TORRENT_ADD); + JsonObject *args = node_get_arguments(root); + gchar *encoded = g_base64_encode((guchar *)response->raw, response->size); + + json_object_set_string_member(args, PARAM_METAINFO, + encoded); + g_free(encoded); + + json_object_set_boolean_member(args, PARAM_PAUSED, + (flags & TORRENT_ADD_FLAG_PAUSED)); + + return root; +} + +JsonNode *torrent_add_from_file(gchar * target, gint flags) { JsonNode *root; JsonObject *args; diff --git a/src/requests.h b/src/requests.h index 5ea9b2a..7430fda 100644 --- a/src/requests.h +++ b/src/requests.h @@ -23,6 +23,8 @@ #include <glib-object.h> #include <json-glib/json-glib.h> +#include "trg-client.h" + JsonNode *generic_request(gchar * method, JsonArray * array); JsonNode *session_set(void); @@ -34,7 +36,8 @@ JsonNode *torrent_start(JsonArray * array); JsonNode *torrent_verify(JsonArray * array); JsonNode *torrent_reannounce(JsonArray * array); JsonNode *torrent_remove(JsonArray * array, int removeData); -JsonNode *torrent_add(gchar * filename, gint flags); +JsonNode *torrent_add_from_response(trg_response *response, gint flags); +JsonNode *torrent_add_from_file(gchar * filename, gint flags); JsonNode *torrent_add_url(const gchar * url, gboolean paused); JsonNode *torrent_set_location(JsonArray * array, gchar * location, gboolean move); diff --git a/src/torrent-cell-renderer.c b/src/torrent-cell-renderer.c index 654d7bd..5c6abd2 100644 --- a/src/torrent-cell-renderer.c +++ b/src/torrent-cell-renderer.c @@ -445,8 +445,6 @@ get_size_compact(TorrentCellRenderer * cell, g_object_unref(icon); } -#define MAX3(a,b,c) MAX(a,MAX(b,c)) - static void get_size_full(TorrentCellRenderer * cell, GtkWidget * widget, gint * width, gint * height) diff --git a/src/trg-client.c b/src/trg-client.c index 1ffde9b..f03e893 100644 --- a/src/trg-client.c +++ b/src/trg-client.c @@ -82,6 +82,7 @@ struct _TrgClientPrivate { TrgPrefs *prefs; GPrivate *tlsKey; gint configSerial; + guint http_class; GMutex *configMutex; gboolean seedRatioLimited; gdouble seedRatioLimit; @@ -441,9 +442,15 @@ void trg_client_configunlock(TrgClient * tc) void trg_response_free(trg_response * response) { - if (response->obj) - json_object_unref(response->obj); - g_free(response); + if (response) { + if (response->obj) + json_object_unref(response->obj); + + if (response->raw) + g_free(response->raw); + + g_free(response); + } } static size_t @@ -483,61 +490,20 @@ header_callback(void *ptr, size_t size, size_t nmemb, void *data) return (nmemb * size); } -static void trg_tls_update(TrgClient * tc, trg_tls * tls, gint serial) -{ - gchar *proxy; - - curl_easy_setopt(tls->curl, CURLOPT_PASSWORD, - trg_client_get_password(tc)); - curl_easy_setopt(tls->curl, CURLOPT_USERNAME, - trg_client_get_username(tc)); - curl_easy_setopt(tls->curl, CURLOPT_URL, trg_client_get_url(tc)); - -#ifndef CURL_NO_SSL - if (trg_client_get_ssl(tc) && !trg_client_get_ssl_validate(tc)) { - - curl_easy_setopt(tls->curl, CURLOPT_SSL_VERIFYHOST, 0); - curl_easy_setopt(tls->curl, CURLOPT_SSL_VERIFYPEER, 0); - } -#endif - - proxy = trg_client_get_proxy(tc); - if (proxy) { - curl_easy_setopt(tls->curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP); - curl_easy_setopt(tls->curl, CURLOPT_PROXY, proxy); - } - - tls->serial = serial; -} - trg_tls *trg_tls_new(TrgClient * tc) { trg_tls *tls = g_new0(trg_tls, 1); tls->curl = curl_easy_init(); - curl_easy_setopt(tls->curl, CURLOPT_USERAGENT, PACKAGE_NAME); - curl_easy_setopt(tls->curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC); - curl_easy_setopt(tls->curl, CURLOPT_WRITEFUNCTION, - &http_receive_callback); - curl_easy_setopt(tls->curl, CURLOPT_HEADERFUNCTION, &header_callback); - curl_easy_setopt(tls->curl, CURLOPT_WRITEHEADER, (void *) tc); - tls->serial = -1; return tls; } -static int -trg_http_perform_inner(TrgClient * tc, gchar * reqstr, - trg_response * response, gboolean recurse) -{ - TrgClientPrivate *priv = tc->priv; - TrgPrefs *prefs = trg_client_get_prefs(tc); - gpointer threadLocalStorage = g_private_get(priv->tlsKey); - trg_tls *tls; - long httpCode = 0; - gchar *session_id; - struct curl_slist *headers = NULL; +static trg_tls *get_tls(TrgClient *tc) { + TrgClientPrivate *priv = tc->priv; + gpointer threadLocalStorage = g_private_get(priv->tlsKey); + trg_tls *tls; if (!threadLocalStorage) { tls = trg_tls_new(tc); @@ -546,37 +512,104 @@ trg_http_perform_inner(TrgClient * tc, gchar * reqstr, tls = (trg_tls *) threadLocalStorage; } + return tls; +} + +static CURL* get_curl(TrgClient *tc, guint http_class) +{ + TrgClientPrivate *priv = tc->priv; + TrgPrefs *prefs = trg_client_get_prefs(tc); + trg_tls *tls = get_tls(tc); + CURL *curl = tls->curl; + g_mutex_lock(priv->configMutex); - if (priv->configSerial > tls->serial) - trg_tls_update(tc, tls, priv->configSerial); + if (priv->configSerial > tls->serial || http_class != priv->http_class) { + gchar *proxy; + + curl_easy_reset(curl); + + curl_easy_setopt(curl, CURLOPT_USERAGENT, PACKAGE_NAME); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, + &http_receive_callback); + //curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); + + if (http_class == HTTP_CLASS_TRANSMISSION) { + curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *) tc); + curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC); + curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, &header_callback); + curl_easy_setopt(curl, CURLOPT_PASSWORD, + trg_client_get_password(tc)); + curl_easy_setopt(curl, CURLOPT_USERNAME, + trg_client_get_username(tc)); + curl_easy_setopt(curl, CURLOPT_URL, trg_client_get_url(tc)); + } + + #ifndef CURL_NO_SSL + if (trg_client_get_ssl(tc) && !trg_client_get_ssl_validate(tc)) { - session_id = trg_client_get_session_id(tc); - if (session_id) { - headers = curl_slist_append(NULL, session_id); - curl_easy_setopt(tls->curl, CURLOPT_HTTPHEADER, headers); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0); + } + #endif + + proxy = trg_client_get_proxy(tc); + if (proxy) { + curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP); + curl_easy_setopt(curl, CURLOPT_PROXY, proxy); + } + + tls->serial = priv->configSerial; + priv->http_class = http_class; } - curl_easy_setopt(tls->curl, CURLOPT_TIMEOUT, - (long) trg_prefs_get_int(prefs, TRG_PREFS_KEY_TIMEOUT, - TRG_PREFS_CONNECTION)); + if (http_class == HTTP_CLASS_TRANSMISSION) + curl_easy_setopt(curl, CURLOPT_URL, trg_client_get_url(tc)); + + curl_easy_setopt(curl, CURLOPT_TIMEOUT, + (long) trg_prefs_get_int(prefs, TRG_PREFS_KEY_TIMEOUT, + TRG_PREFS_CONNECTION)); g_mutex_unlock(priv->configMutex); + /* Headers are set on each use, then freed, so make sure invalid headers aren't still around. */ + curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL); + + return curl; + +} + +static int +trg_http_perform_inner(TrgClient * tc, gchar * reqstr, + trg_response * response, gboolean recurse) +{ + CURL* curl = get_curl(tc, HTTP_CLASS_TRANSMISSION); + + struct curl_slist *headers = NULL; + gchar *session_id = NULL; + long httpCode = 0; + response->size = 0; response->raw = NULL; - curl_easy_setopt(tls->curl, CURLOPT_POSTFIELDS, reqstr); - curl_easy_setopt(tls->curl, CURLOPT_WRITEDATA, (void *) response); - response->status = curl_easy_perform(tls->curl); + curl_easy_setopt(curl, CURLOPT_POSTFIELDS, reqstr); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) response); + + session_id = trg_client_get_session_id(tc); + if (session_id) { + headers = curl_slist_append(NULL, session_id); + curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); + } + + response->status = curl_easy_perform(curl); + + curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode); if (session_id) { g_free(session_id); curl_slist_free_all(headers); } - curl_easy_getinfo(tls->curl, CURLINFO_RESPONSE_CODE, &httpCode); - if (response->status == CURLE_OK) { if (httpCode == HTTP_CONFLICT && recurse == TRUE) return trg_http_perform_inner(tc, reqstr, response, FALSE); @@ -600,11 +633,38 @@ trg_response *dispatch(TrgClient * tc, JsonNode * req) json_node_free(req); #ifdef DEBUG if (g_getenv("TRG_SHOW_OUTGOING")) - g_debug("=>(OUTgoing)=>: %s", serialized); + g_message("=>(OUTgoing)=>: %s", serialized); #endif return dispatch_str(tc, serialized); } +trg_response *dispatch_public_http(TrgClient *tc, trg_request *req) { + trg_response *response = g_new0(trg_response, 1); + + CURL* curl = get_curl(tc, HTTP_CLASS_PUBLIC); + + long httpCode = 0; + + response->size = 0; + response->raw = NULL; + + curl_easy_setopt(curl, CURLOPT_URL, req->url); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) response); + + response->status = curl_easy_perform(curl); + + g_free(req->url); + req->url = NULL; + + curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode); + + if (response->status == CURLE_OK && httpCode != HTTP_OK) { + response->status = (-httpCode) - 100; + } + + return response; +} + trg_response *dispatch_str(TrgClient * tc, gchar * req) { trg_response *response = g_new0(trg_response, 1); @@ -645,6 +705,8 @@ static void dispatch_async_threadfunc(trg_request * req, TrgClient * tc) if (req->str) rsp = dispatch_str(tc, req->str); + else if (req->url) + rsp = dispatch_public_http(tc, req); else rsp = dispatch(tc, req->node); @@ -701,6 +763,13 @@ dispatch_async_str(TrgClient * tc, gchar * req, return dispatch_async_common(tc, trg_req, callback, data); } +gboolean async_http_request(TrgClient *tc, gchar *url, GSourceFunc callback, gpointer data) { + trg_request *trg_req = g_new0(trg_request, 1); + trg_req->url = g_strdup(url); + + return dispatch_async_common(tc, trg_req, callback, data); +} + gboolean trg_client_update_session(TrgClient * tc, GSourceFunc callback, gpointer data) { diff --git a/src/trg-client.h b/src/trg-client.h index a0bee33..ce98a4e 100644 --- a/src/trg-client.h +++ b/src/trg-client.h @@ -57,6 +57,9 @@ #define FAIL_RESPONSE_UNSUCCESSFUL -3 #define DISPATCH_POOL_SIZE 3 +#define HTTP_CLASS_TRANSMISSION 0 +#define HTTP_CLASS_PUBLIC 1 + typedef struct { int status; int size; @@ -69,6 +72,7 @@ typedef struct { gint connid; JsonNode *node; gchar *str; + gchar *url; GSourceFunc callback; gpointer cb_data; } trg_request; @@ -109,6 +113,7 @@ typedef struct { * We lock updating (and checking for updates) with priv->configMutex */ int serial; + guint client_class; CURL *curl; } trg_tls; @@ -121,8 +126,11 @@ int trg_http_perform(TrgClient * client, gchar * reqstr, /* stuff that used to be in dispatch.c */ trg_response *dispatch(TrgClient * client, JsonNode * req); trg_response *dispatch_str(TrgClient * client, gchar * req); +trg_response *dispatch_public_http(TrgClient *tc, trg_request *req); gboolean dispatch_async(TrgClient * client, JsonNode * req, GSourceFunc callback, gpointer data); +gboolean async_http_request(TrgClient *tc, gchar *url, GSourceFunc callback, gpointer data); + /* end dispatch.c*/ GType trg_client_get_type(void); diff --git a/src/trg-destination-combo.c b/src/trg-destination-combo.c index 099b6a5..f7fc2f0 100644 --- a/src/trg-destination-combo.c +++ b/src/trg-destination-combo.c @@ -397,7 +397,7 @@ gchar *trg_destination_combo_get_dir(TrgDestinationCombo * combo) if (type == DEST_LABEL) { gtk_tree_model_get(model, &iter, DEST_COLUMN_DIR, &value, -1); - return value; + return g_strdup(value); } } diff --git a/src/trg-file-parser.c b/src/trg-file-parser.c index fbfb6aa..ff4ac62 100644 --- a/src/trg-file-parser.c +++ b/src/trg-file-parser.c @@ -134,32 +134,11 @@ static trg_files_tree_node *trg_parse_torrent_file_nodes(be_node * return top_node; } -trg_torrent_file *trg_parse_torrent_file(const gchar * filename) -{ - GError *error = NULL; - GMappedFile *mf; - be_node *top_node, *info_node, *name_node; - trg_torrent_file *ret = NULL; - - if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) { - g_message("%s does not exist", filename); - return NULL; - } - - mf = g_mapped_file_new(filename, FALSE, &error); +trg_torrent_file *trg_parse_torrent_data(const gchar *data, gsize length) { + trg_torrent_file *ret = NULL; + be_node *top_node, *info_node, *name_node; - if (error) { - g_error("%s", error->message); - g_error_free(error); - g_mapped_file_unref(mf); - return NULL; - } else { - top_node = - be_decoden(g_mapped_file_get_contents(mf), - g_mapped_file_get_length(mf)); - } - - g_mapped_file_unref(mf); + top_node = be_decoden(data, length); if (!top_node) { return NULL; @@ -199,3 +178,30 @@ trg_torrent_file *trg_parse_torrent_file(const gchar * filename) be_free(top_node); return ret; } + +trg_torrent_file *trg_parse_torrent_file(const gchar * filename) +{ + GError *error = NULL; + trg_torrent_file *ret = NULL; + GMappedFile *mf; + + if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) { + g_message("%s does not exist", filename); + return NULL; + } + + mf = g_mapped_file_new(filename, FALSE, &error); + + if (error) { + g_error("%s", error->message); + g_error_free(error); + g_mapped_file_unref(mf); + return NULL; + } else { + ret = trg_parse_torrent_data(g_mapped_file_get_contents(mf), g_mapped_file_get_length(mf)); + } + + g_mapped_file_unref(mf); + + return ret; +} diff --git a/src/trg-files-tree-view.c b/src/trg-files-tree-view.c index 1c93ad6..ae9e071 100644 --- a/src/trg-files-tree-view.c +++ b/src/trg-files-tree-view.c @@ -93,7 +93,7 @@ static gboolean on_files_update(gpointer data) response->cb_data = priv->win; - return on_generic_interactive_action(data); + return on_generic_interactive_action_response(data); } static void send_updated_file_prefs(TrgFilesTreeView * tv) diff --git a/src/trg-main-window.c b/src/trg-main-window.c index 906a384..4cf6047 100644 --- a/src/trg-main-window.c +++ b/src/trg-main-window.c @@ -17,9 +17,7 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include <stdlib.h> #include <string.h> @@ -73,8 +71,12 @@ #include "trg-menu-bar.h" #include "trg-status-bar.h" #include "trg-stats-dialog.h" +#ifdef HAVE_RSSGLIB +#include "trg-rss-window.h" +#endif #include "trg-remote-prefs-dialog.h" #include "trg-preferences-dialog.h" +#include "upload.h" /* The rather large main window class, which glues everything together. */ @@ -479,7 +481,7 @@ static void pause_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_pause(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void pause_all_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) @@ -488,7 +490,7 @@ static void pause_all_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) if (trg_client_is_connected(priv->client)) dispatch_async(priv->client, torrent_pause(NULL), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } gint trg_add_from_filename(TrgMainWindow * win, gchar ** uris) @@ -504,10 +506,14 @@ gint trg_add_from_filename(TrgMainWindow * win, gchar ** uris) return EXIT_SUCCESS; } - if (uris) - for (i = 0; uris[i]; i++) - if (uris[i]) + if (uris) { + for (i = 0; uris[i]; i++) { + if (is_minimised_arg(uris[i])) + g_free(uris[i]); + else if (uris[i]) filesList = g_slist_append(filesList, uris[i]); + } + } g_free(uris); @@ -517,20 +523,20 @@ gint trg_add_from_filename(TrgMainWindow * win, gchar ** uris) if (trg_prefs_get_bool(prefs, TRG_PREFS_KEY_ADD_OPTIONS_DIALOG, TRG_PREFS_GLOBAL)) { TrgTorrentAddDialog *dialog = - trg_torrent_add_dialog_new(win, client, + trg_torrent_add_dialog_new_from_filenames(win, client, filesList); gtk_widget_show_all(GTK_WIDGET(dialog)); } else { - struct add_torrent_threadfunc_args *args = - g_new0(struct add_torrent_threadfunc_args, 1); - args->list = filesList; - args->cb_data = win; - args->client = client; - args->extraArgs = FALSE; - args->flags = trg_prefs_get_add_flags(prefs); - - launch_add_thread(args); + trg_upload *upload = g_new0(trg_upload, 1); + + upload->list = filesList; + upload->main_window = win; + upload->client = client; + upload->extra_args = FALSE; + upload->flags = trg_prefs_get_add_flags(prefs); + + trg_do_upload(upload); } return EXIT_SUCCESS; @@ -542,7 +548,7 @@ static void resume_all_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) if (trg_client_is_connected(priv->client)) dispatch_async(priv->client, torrent_start(NULL), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void resume_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) @@ -553,7 +559,7 @@ static void resume_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_start(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void disconnect_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) @@ -712,7 +718,7 @@ static void reannounce_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_reannounce(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void verify_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) @@ -723,7 +729,7 @@ static void verify_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_verify(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void start_now_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) @@ -734,7 +740,7 @@ static void start_now_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_start_now(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void up_queue_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) @@ -745,7 +751,7 @@ static void up_queue_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_queue_move_up(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void top_queue_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) @@ -756,7 +762,7 @@ static void top_queue_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_queue_move_top(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void @@ -768,7 +774,7 @@ bottom_queue_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_queue_move_bottom(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static void down_queue_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) @@ -779,7 +785,7 @@ static void down_queue_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) dispatch_async(priv->client, torrent_queue_move_down(build_json_id_array (priv->torrentTreeView)), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); } static gint @@ -881,7 +887,7 @@ static void remove_cb(GtkWidget * w G_GNUC_UNUSED, TrgMainWindow * win) _("<big><b>Remove %d torrents?</b></big>"), GTK_STOCK_REMOVE) == GTK_RESPONSE_ACCEPT) dispatch_async(priv->client, torrent_remove(ids, FALSE), - on_generic_interactive_action, win); + on_generic_interactive_action_response, win); else json_array_unref(ids); } @@ -924,6 +930,22 @@ static void view_stats_toggled_cb(GtkWidget * w, gpointer data) } } +#ifdef HAVE_RSSGLIB +static void view_rss_toggled_cb(GtkWidget * w, gpointer data) +{ + TrgMainWindow *win = TRG_MAIN_WINDOW(data); + TrgMainWindowPrivate *priv = win->priv; + + if (trg_client_is_connected(priv->client)) { + TrgRssWindow *rss = + trg_rss_window_get_instance(TRG_MAIN_WINDOW(data), priv->client); + + gtk_widget_show_all(GTK_WIDGET(rss)); + gtk_window_present(GTK_WINDOW(rss)); + } +} +#endif + static void view_states_toggled_cb(GtkCheckMenuItem * w, TrgMainWindow * win) { @@ -1570,13 +1592,10 @@ gboolean on_delete_complete(gpointer data) trg_client_update_session(priv->client, on_session_get, response->cb_data); - return on_generic_interactive_action(data); + return on_generic_interactive_action_response(data); } -gboolean on_generic_interactive_action(gpointer data) -{ - trg_response *response = (trg_response *) data; - TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data); +void on_generic_interactive_action(TrgMainWindow *win, trg_response *response) { TrgMainWindowPrivate *priv = win->priv; TrgClient *tc = priv->client; @@ -1596,6 +1615,15 @@ gboolean on_generic_interactive_action(gpointer data) } trg_response_free(response); +} + +gboolean on_generic_interactive_action_response(gpointer data) +{ + trg_response *response = (trg_response *) data; + TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data); + + on_generic_interactive_action(win, response); + return FALSE; } @@ -1738,6 +1766,9 @@ static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) #if TRG_WITH_GRAPH *b_show_graph, #endif +#ifdef HAVE_RSSGLIB + *b_view_rss, +#endif *b_start_now; TrgMenuBar *menuBar; @@ -1766,6 +1797,9 @@ static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) #if TRG_WITH_GRAPH "show-graph", &b_show_graph, #endif +#ifdef HAVE_RSSGLIB + "view-rss-button", &b_view_rss, +#endif "up-queue", &b_up_queue, "down-queue", &b_down_queue, "top-queue", &b_top_queue, "bottom-queue", &b_bottom_queue, "start-now", &b_start_now, NULL); @@ -1810,6 +1844,10 @@ static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) G_CALLBACK(view_states_toggled_cb), win); g_signal_connect(b_view_stats, "activate", G_CALLBACK(view_stats_toggled_cb), win); +#ifdef HAVE_RSSGLIB + g_signal_connect(b_view_rss, "activate", + G_CALLBACK(view_rss_toggled_cb), win); +#endif #if TRG_WITH_GRAPH g_signal_connect(b_show_graph, "toggled", G_CALLBACK(trg_main_window_toggle_graph_cb), win); @@ -1928,7 +1966,7 @@ static void set_limit_cb(GtkWidget * w, TrgMainWindow * win) json_object_set_boolean_member(args, enabledKey, speed >= 0); if (limitIds) - dispatch_async(priv->client, req, on_generic_interactive_action, + dispatch_async(priv->client, req, on_generic_interactive_action_response, win); else dispatch_async(priv->client, req, on_session_set, win); @@ -1953,7 +1991,7 @@ static void set_priority_cb(GtkWidget * w, TrgMainWindow * win) json_object_set_int_member(args, FIELD_BANDWIDTH_PRIORITY, priority); - dispatch_async(priv->client, req, on_generic_interactive_action, win); + dispatch_async(priv->client, req, on_generic_interactive_action_response, win); } static GtkWidget *limit_item_new(TrgMainWindow * win, GtkWidget * menu, diff --git a/src/trg-main-window.h b/src/trg-main-window.h index 3c6ace5..3fb69af 100644 --- a/src/trg-main-window.h +++ b/src/trg-main-window.h @@ -63,7 +63,8 @@ GType trg_main_window_get_type(void); gint trg_add_from_filename(TrgMainWindow * win, gchar ** uris); gboolean on_session_set(gpointer data); gboolean on_delete_complete(gpointer data); -gboolean on_generic_interactive_action(gpointer data); +void on_generic_interactive_action(TrgMainWindow *win, trg_response *response); +gboolean on_generic_interactive_action_response(gpointer data); void auto_connect_if_required(TrgMainWindow * win); void trg_main_window_set_start_args(TrgMainWindow * win, gchar ** args); TrgMainWindow *trg_main_window_new(TrgClient * tc, gboolean minonstart); diff --git a/src/trg-menu-bar.c b/src/trg-menu-bar.c index df96240..37c6c2c 100644 --- a/src/trg-menu-bar.c +++ b/src/trg-menu-bar.c @@ -17,6 +17,8 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#include "config.h" + #include <glib/gi18n.h> #include <gtk/gtk.h> #include <gdk/gdkkeysyms.h> @@ -49,6 +51,9 @@ enum { PROP_LOCAL_PREFS_BUTTON, PROP_ABOUT_BUTTON, PROP_VIEW_STATS_BUTTON, +#ifdef HAVE_RSSGLIB + PROP_VIEW_RSS_BUTTON, +#endif PROP_VIEW_STATES_BUTTON, PROP_VIEW_NOTEBOOK_BUTTON, PROP_QUIT, @@ -96,6 +101,9 @@ struct _TrgMenuBarPrivate { GtkWidget *mb_view_states; GtkWidget *mb_view_notebook; GtkWidget *mb_view_stats; +#ifdef HAVE_RSSGLIB + GtkWidget *mb_view_rss; +#endif GtkWidget *mb_about; GtkWidget *mb_quit; GtkWidget *mb_directory_filters; @@ -140,6 +148,9 @@ void trg_menu_bar_connected_change(TrgMenuBar * mb, gboolean connected) gtk_widget_set_sensitive(priv->mb_disconnect, connected); gtk_widget_set_sensitive(priv->mb_remote_prefs, connected); gtk_widget_set_sensitive(priv->mb_view_stats, connected); +#ifdef HAVE_RSSGLIB + gtk_widget_set_sensitive(priv->mb_view_rss, connected); +#endif gtk_widget_set_sensitive(priv->mb_resume_all, connected); gtk_widget_set_sensitive(priv->mb_pause_all, connected); } @@ -273,6 +284,11 @@ trg_menu_bar_get_property(GObject * object, guint property_id, case PROP_VIEW_STATS_BUTTON: g_value_set_object(value, priv->mb_view_stats); break; +#ifdef HAVE_RSSGLIB + case PROP_VIEW_RSS_BUTTON: + g_value_set_object(value, priv->mb_view_rss); + break; +#endif case PROP_QUIT: g_value_set_object(value, priv->mb_quit); break; @@ -542,6 +558,14 @@ static GtkWidget *trg_menu_bar_view_menu_new(TrgMenuBar * mb) gtk_widget_set_sensitive(priv->mb_view_stats, FALSE); gtk_menu_shell_append(GTK_MENU_SHELL(viewMenu), priv->mb_view_stats); +#ifdef HAVE_RSSGLIB + priv->mb_view_rss = + gtk_menu_item_new_with_mnemonic(_("_RSS")); + //trg_menu_bar_accel_add(mb, priv->mb_view_rss, GDK_F7, 0); + gtk_widget_set_sensitive(priv->mb_view_rss, FALSE); + gtk_menu_shell_append(GTK_MENU_SHELL(viewMenu), priv->mb_view_rss); +#endif + return view; } @@ -578,7 +602,7 @@ trg_menu_bar_file_connect_item_new(TrgMainWindow * win, { GtkWidget *item = gtk_check_menu_item_new_with_label(text); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), checked); + gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), checked); g_object_set_data(G_OBJECT(item), "profile", profile); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), TRUE); @@ -870,6 +894,11 @@ static void trg_menu_bar_class_init(TrgMenuBarClass * klass) trg_menu_bar_install_widget_prop(object_class, PROP_VIEW_STATS_BUTTON, "view-stats-button", "View stats button"); +#ifdef HAVE_RSSGLIB + trg_menu_bar_install_widget_prop(object_class, PROP_VIEW_RSS_BUTTON, + "view-rss-button", + "View rss button"); +#endif trg_menu_bar_install_widget_prop(object_class, PROP_VIEW_STATES_BUTTON, "view-states-button", "View states Button"); diff --git a/src/trg-persistent-tree-view.c b/src/trg-persistent-tree-view.c index e116fdf..c608acb 100644 --- a/src/trg-persistent-tree-view.c +++ b/src/trg-persistent-tree-view.c @@ -37,7 +37,7 @@ typedef struct _TrgPersistentTreeViewPrivate TrgPersistentTreeViewPrivate; enum { - PROP_0, PROP_PREFS, PROP_KEY, PROP_MODEL + PROP_0, PROP_PREFS, PROP_KEY, PROP_MODEL, PROP_CONF_FLAGS }; struct _TrgPersistentTreeViewPrivate { @@ -52,6 +52,7 @@ struct _TrgPersistentTreeViewPrivate { trg_pref_widget_desc *wd; GtkTreeModel *model; trg_persistent_tree_view_column *addSelect; + gint conf_flags; }; static void selection_changed(TrgPersistentTreeView * ptv, @@ -322,6 +323,9 @@ trg_persistent_tree_view_set_property(GObject * object, case PROP_MODEL: priv->model = g_value_get_object(value); break; + case PROP_CONF_FLAGS: + priv->conf_flags = g_value_get_int(value); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; @@ -411,7 +415,7 @@ static GObject *trg_persistent_tree_view_constructor(GType type, gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 4); priv->wd = trg_pref_widget_desc_new(GTK_WIDGET(priv->tv), priv->key, - TRG_PREFS_PROFILE); + priv->conf_flags); priv->wd->widget = GTK_WIDGET(object); priv->wd->saveFunc = &trg_persistent_tree_view_save; priv->wd->refreshFunc = &trg_persistent_tree_view_refresh; @@ -462,6 +466,19 @@ trg_persistent_tree_view_class_init(TrgPersistentTreeViewClass * klass) G_PARAM_STATIC_BLURB)); g_object_class_install_property(object_class, + PROP_CONF_FLAGS, + g_param_spec_int("conf-flags", + "Conf Flags", + "Conf Flags", + INT_MIN, + INT_MAX, + TRG_PREFS_PROFILE, + G_PARAM_READWRITE | + G_PARAM_STATIC_NAME | + G_PARAM_STATIC_NICK | + G_PARAM_STATIC_BLURB)); + + g_object_class_install_property(object_class, PROP_MODEL, g_param_spec_object("persistent-model", "Persistent Model", @@ -483,12 +500,12 @@ static void trg_persistent_tree_view_init(TrgPersistentTreeView * self) TrgPersistentTreeView *trg_persistent_tree_view_new(TrgPrefs * prefs, GtkListStore * model, - const gchar * key) + const gchar * key, gint conf_flags) { GObject *obj = g_object_new(TRG_TYPE_PERSISTENT_TREE_VIEW, "prefs", prefs, "conf-key", key, "persistent-model", - model, + model, "conf-flags", conf_flags, NULL); return TRG_PERSISTENT_TREE_VIEW(obj); diff --git a/src/trg-persistent-tree-view.h b/src/trg-persistent-tree-view.h index a5a7c8f..0d16fb6 100644 --- a/src/trg-persistent-tree-view.h +++ b/src/trg-persistent-tree-view.h @@ -57,7 +57,7 @@ typedef struct { TrgPersistentTreeView *trg_persistent_tree_view_new(TrgPrefs * prefs, GtkListStore * model, - const gchar * key); + const gchar * key, gint conf_flags); trg_pref_widget_desc * trg_persistent_tree_view_get_widget_desc(TrgPersistentTreeView * diff --git a/src/trg-preferences-dialog.c b/src/trg-preferences-dialog.c index b9327c6..53e4fe9 100644 --- a/src/trg-preferences-dialog.c +++ b/src/trg-preferences-dialog.c @@ -17,9 +17,7 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include <glib.h> #include <glib/gi18n.h> @@ -60,6 +58,7 @@ struct _TrgPreferencesDialogPrivate { GtkWidget *profileNameEntry; GtkWidget *fullUpdateCheck; GList *widgets; + GtkWidget *notebook; }; static GObject *instance = NULL; @@ -601,7 +600,7 @@ static GtkWidget *trg_prefs_openExecPage(TrgPreferencesDialog * dlg) model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); ptv = trg_persistent_tree_view_new(priv->prefs, model, - TRG_PREFS_KEY_EXEC_COMMANDS); + TRG_PREFS_KEY_EXEC_COMMANDS, TRG_PREFS_PROFILE); trg_persistent_tree_view_set_add_select(ptv, trg_persistent_tree_view_add_column (ptv, 0, @@ -621,6 +620,46 @@ static GtkWidget *trg_prefs_openExecPage(TrgPreferencesDialog * dlg) return t; } +#ifdef HAVE_RSSGLIB +static GtkWidget *trg_prefs_rss_page(TrgPreferencesDialog * dlg) { + TrgPreferencesDialogPrivate *priv = + TRG_PREFERENCES_DIALOG_GET_PRIVATE(dlg); + GtkWidget *t; + guint row = 0; + TrgPersistentTreeView *ptv; + trg_pref_widget_desc *wd; + GtkListStore *model; + + t = hig_workarea_create(); + + hig_workarea_add_section_title(t, &row, + _("RSS Feeds")); + + model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); + + ptv = trg_persistent_tree_view_new(priv->prefs, model, + TRG_PREFS_KEY_RSS, TRG_PREFS_GLOBAL); + trg_persistent_tree_view_set_add_select(ptv, + trg_persistent_tree_view_add_column + (ptv, 0, + TRG_PREFS_RSS_SUBKEY_ID, + _("Name"))); + trg_persistent_tree_view_add_column(ptv, 1, + TRG_PREFS_RSS_SUBKEY_URL, + _("URL")); + + wd = trg_persistent_tree_view_get_widget_desc(ptv); + trg_pref_widget_refresh(dlg, wd); + priv->widgets = g_list_append(priv->widgets, wd); + + gtk_table_attach(GTK_TABLE(t), GTK_WIDGET(ptv), 1, 2, row, row + 1, + GTK_EXPAND | GTK_SHRINK | GTK_FILL, + GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); + + return t; +} +#endif + static GtkWidget *trg_prefs_dirsPage(TrgPreferencesDialog * dlg) { TrgPreferencesDialogPrivate *priv = @@ -639,7 +678,7 @@ static GtkWidget *trg_prefs_dirsPage(TrgPreferencesDialog * dlg) model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); ptv = trg_persistent_tree_view_new(priv->prefs, model, - TRG_PREFS_KEY_DESTINATIONS); + TRG_PREFS_KEY_DESTINATIONS, TRG_PREFS_GLOBAL); trg_persistent_tree_view_set_add_select(ptv, trg_persistent_tree_view_add_column (ptv, 0, @@ -890,7 +929,7 @@ static GObject *trg_preferences_dialog_constructor(GType type, g_signal_connect(G_OBJECT(object), "response", G_CALLBACK(trg_preferences_response_cb), NULL); - notebook = gtk_notebook_new(); + notebook = priv->notebook = gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), trg_prefs_serverPage(TRG_PREFERENCES_DIALOG @@ -917,6 +956,13 @@ static GObject *trg_preferences_dialog_constructor(GType type, (object)), gtk_label_new(_("Directories"))); +#ifdef HAVE_RSSGLIB + gtk_notebook_append_page(GTK_NOTEBOOK(notebook), + trg_prefs_rss_page(TRG_PREFERENCES_DIALOG + (object)), + gtk_label_new(_("RSS Feeds"))); +#endif + gtk_container_set_border_width(GTK_CONTAINER(notebook), GUI_PAD); gtk_box_pack_start(GTK_BOX(contentvbox), notebook, TRUE, TRUE, 0); @@ -924,6 +970,11 @@ static GObject *trg_preferences_dialog_constructor(GType type, return object; } +void trg_preferences_dialog_set_page(TrgPreferencesDialog *pref_dlg, guint page) { + TrgPreferencesDialogPrivate *priv = TRG_PREFERENCES_DIALOG_GET_PRIVATE(pref_dlg); + gtk_notebook_set_current_page(GTK_NOTEBOOK(priv->notebook), page); +} + static void trg_preferences_dialog_init(TrgPreferencesDialog * pref_dlg) { } diff --git a/src/trg-preferences-dialog.h b/src/trg-preferences-dialog.h index f5e9825..e163964 100644 --- a/src/trg-preferences-dialog.h +++ b/src/trg-preferences-dialog.h @@ -60,6 +60,7 @@ GtkWidget *trg_preferences_dialog_get_instance(TrgMainWindow * win, TrgClient * client); trg_pref_widget_desc *trg_pref_widget_desc_new(GtkWidget * w, gchar * key, int flags); +void trg_preferences_dialog_set_page(TrgPreferencesDialog *pref_dlg, guint page); G_END_DECLS #endif /* TRG_PREFERENCES_WINDOW_H_ */ diff --git a/src/trg-prefs.c b/src/trg-prefs.c index b559479..811c575 100644 --- a/src/trg-prefs.c +++ b/src/trg-prefs.c @@ -421,6 +421,12 @@ JsonArray *trg_prefs_get_profiles(TrgPrefs * p) TRG_PREFS_KEY_PROFILES); } +JsonArray *trg_prefs_get_rss(TrgPrefs *p) { + TrgPrefsPrivate *priv = p->priv; + return json_object_get_array_member(priv->userObj, + TRG_PREFS_KEY_RSS); +} + void trg_prefs_set_double(TrgPrefs * p, const gchar * key, gdouble value, int flags) diff --git a/src/trg-prefs.h b/src/trg-prefs.h index 9dda148..4245505 100644 --- a/src/trg-prefs.h +++ b/src/trg-prefs.h @@ -33,6 +33,7 @@ #define TRG_PREFS_KEY_RPC_URL_PATH "rpc-url-path" #define TRG_PREFS_KEY_PROFILE_ID "profile-id" #define TRG_PREFS_KEY_PROFILES "profiles" +#define TRG_PREFS_KEY_RSS "rss" #define TRG_PREFS_KEY_PROFILE_NAME "profile-name" #define TRG_PREFS_KEY_HOSTNAME "hostname" #define TRG_PREFS_KEY_PORT "port" @@ -78,6 +79,9 @@ #define TRG_PREFS_KEY_EXEC_COMMANDS "exec-commands" #define TRG_PREFS_KEY_EXEC_COMMANDS_SUBKEY_CMD "cmd" #define TRG_PREFS_KEY_DESTINATIONS "destinations" +#define TRG_PREFS_KEY_RSS "rss" +#define TRG_PREFS_RSS_SUBKEY_ID "id" +#define TRG_PREFS_RSS_SUBKEY_URL "url" #define TRG_PREFS_KEY_LAST_MOVE_DESTINATION "last-move-destination" #define TRG_PREFS_KEY_LAST_ADD_DESTINATION "last-add-destination" #define TRG_PREFS_KEY_DESTINATIONS_SUBKEY_DIR "dir" @@ -139,6 +143,7 @@ gboolean trg_prefs_get_bool(TrgPrefs * p, const gchar * key, int flags); JsonObject *trg_prefs_get_profile(TrgPrefs * p); JsonObject *trg_prefs_get_connection(TrgPrefs * p); JsonArray *trg_prefs_get_profiles(TrgPrefs * p); +JsonArray *trg_prefs_get_rss(TrgPrefs *p); void trg_prefs_set_connection(TrgPrefs * p, JsonObject * profile); gint trg_prefs_get_profile_id(TrgPrefs * p); void trg_prefs_del_profile(TrgPrefs * p, JsonObject * profile); diff --git a/src/trg-rss-cell-renderer.c b/src/trg-rss-cell-renderer.c new file mode 100644 index 0000000..4765f2c --- /dev/null +++ b/src/trg-rss-cell-renderer.c @@ -0,0 +1,429 @@ +#include "config.h" + +#ifdef HAVE_RSSGLIB + +#include <gtk/gtk.h> +#include <gdk/gdk.h> +#include <glib/gi18n.h> + +#include "icons.h" +#include "hig.h" +#include "util.h" +#include "trg-rss-cell-renderer.h" + +enum { + PROP_TITLE = 1, + PROP_FEED, + PROP_PUBLISHED, + PROP_UPLOADED +}; + +#define SMALL_SCALE 0.9 +#define COMPACT_ICON_SIZE GTK_ICON_SIZE_MENU +#define FULL_ICON_SIZE GTK_ICON_SIZE_DND + +#define FOREGROUND_COLOR_KEY "foreground-rgba" +typedef GdkRGBA GtrColor; +typedef cairo_t GtrDrawable; +typedef GtkRequisition GtrRequisition; + +struct TrgRssCellRendererPrivate { + GtkCellRenderer *text_renderer; + GtkCellRenderer *icon_renderer; + GString *gstr1; + GString *gstr2; + gchar *title; + gchar *published; + gchar *feed; + gboolean uploaded; +}; + +static void +trg_rss_cell_renderer_render(GtkCellRenderer * cell, + GtrDrawable * window, GtkWidget * widget, + const GdkRectangle * background_area, + const GdkRectangle * cell_area, + GtkCellRendererState flags); + +static void +gtr_cell_renderer_render(GtkCellRenderer * renderer, + GtrDrawable * drawable, + GtkWidget * widget, + const GdkRectangle * area, + GtkCellRendererState flags) +{ + gtk_cell_renderer_render(renderer, drawable, widget, area, area, + flags); +} + +static void trg_rss_cell_renderer_set_property(GObject * object, + guint property_id, + const GValue * v, + GParamSpec * pspec) +{ + TrgRssCellRenderer *self = TRG_RSS_CELL_RENDERER(object); + struct TrgRssCellRendererPrivate *p = self->priv; + + switch (property_id) { + case PROP_TITLE: + g_free(p->title); + p->title = g_value_dup_string(v); + break; + case PROP_PUBLISHED: + g_free(p->published); + p->published = g_value_dup_string(v); + break; + case PROP_FEED: + g_free(p->feed); + p->feed = g_value_dup_string(v); + break; + case PROP_UPLOADED: + p->uploaded = g_value_get_boolean(v); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void +trg_rss_cell_renderer_get_property(GObject * object, + guint property_id, + GValue * v, GParamSpec * pspec) +{ + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); +} + +G_DEFINE_TYPE(TrgRssCellRenderer, trg_rss_cell_renderer, + GTK_TYPE_CELL_RENDERER) + +static void trg_rss_cell_renderer_dispose(GObject * o) +{ + TrgRssCellRenderer *r = TRG_RSS_CELL_RENDERER(o); + + if (r && r->priv) { + struct TrgRssCellRendererPrivate *priv = r->priv; + + g_string_free(priv->gstr1, TRUE); + g_free(priv->feed); + g_free(priv->published); + g_free(priv->title); + g_object_unref(G_OBJECT(priv->text_renderer)); + g_object_unref(G_OBJECT(priv->icon_renderer)); + r->priv = NULL; + } + + G_OBJECT_CLASS(trg_rss_cell_renderer_parent_class)->dispose(o); +} + +static GdkPixbuf *get_icon(TrgRssCellRenderer * r, GtkIconSize icon_size, + GtkWidget * for_widget) +{ + const char *mime_type = "file"; + + return gtr_get_mime_type_icon(mime_type, icon_size, for_widget); +} + +static void +trg_rss_cell_renderer_get_size(GtkCellRenderer * cell, GtkWidget * widget, + const GdkRectangle * cell_area, + gint * x_offset, + gint * y_offset, + gint * width, gint * height) +{ + TrgRssCellRenderer *self = TRG_RSS_CELL_RENDERER(cell); + + if (self) { + struct TrgRssCellRendererPrivate *p = self->priv; + int xpad, ypad; + int h, w; + GtkRequisition icon_size; + GtkRequisition name_size; + GtkRequisition stat_size; + GtkRequisition prog_size; + GdkPixbuf *icon; + + icon = get_icon(self, FULL_ICON_SIZE, widget); + + gtk_cell_renderer_get_padding(cell, &xpad, &ypad); + + /* get the idealized cell dimensions */ + g_object_set(p->icon_renderer, "pixbuf", icon, NULL); + gtk_cell_renderer_get_preferred_size(p->icon_renderer, widget, NULL, + &icon_size); + g_object_set(p->text_renderer, "text", p->title, + "weight", PANGO_WEIGHT_BOLD, "scale", 1.0, "ellipsize", + PANGO_ELLIPSIZE_NONE, NULL); + gtk_cell_renderer_get_preferred_size(p->text_renderer, widget, NULL, + &name_size); + g_object_set(p->text_renderer, "text", p->feed, "weight", + PANGO_WEIGHT_NORMAL, "scale", SMALL_SCALE, NULL); + gtk_cell_renderer_get_preferred_size(p->text_renderer, widget, NULL, + &prog_size); + g_object_set(p->text_renderer, "text", p->published, NULL); + gtk_cell_renderer_get_preferred_size(p->text_renderer, widget, NULL, + &stat_size); + + /** + *** LAYOUT + **/ + + if (width != NULL) + *width = w = + xpad * 2 + icon_size.width + GUI_PAD + MAX3(name_size.width, + prog_size.width, + stat_size.width); + if (height != NULL) + *height = h = + ypad * 2 + name_size.height + prog_size.height + + GUI_PAD_SMALL + stat_size.height; + + /* cleanup */ + g_object_unref(icon); + + if (x_offset) + *x_offset = cell_area ? cell_area->x : 0; + + if (y_offset) { + int xpad, ypad; + gtk_cell_renderer_get_padding(cell, &xpad, &ypad); + *y_offset = + cell_area ? (int) ((cell_area->height - (ypad * 2 + h)) / + 2.0) : 0; + } + } +} + +static void +trg_rss_cell_renderer_class_init(TrgRssCellRendererClass * klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS(klass); + GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS(klass); + + g_type_class_add_private(klass, + sizeof(struct TrgRssCellRendererPrivate)); + + cell_class->render = trg_rss_cell_renderer_render; + cell_class->get_size = trg_rss_cell_renderer_get_size; + gobject_class->set_property = trg_rss_cell_renderer_set_property; + gobject_class->get_property = trg_rss_cell_renderer_get_property; + gobject_class->dispose = trg_rss_cell_renderer_dispose; + + g_object_class_install_property(gobject_class, + PROP_TITLE, + g_param_spec_string("title", + "title", + "Title", + NULL, + G_PARAM_READWRITE | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); + + g_object_class_install_property(gobject_class, + PROP_PUBLISHED, + g_param_spec_string("published", + "published", + "Published", + NULL, + G_PARAM_READWRITE | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); + + g_object_class_install_property(gobject_class, + PROP_FEED, + g_param_spec_string("feed", + "feed", + "Feed", + NULL, + G_PARAM_READWRITE | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); + + g_object_class_install_property(gobject_class, + PROP_UPLOADED, + g_param_spec_boolean("uploaded", + "uploaded", + "Uploaded", + FALSE, + G_PARAM_READWRITE | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); + + /*g_object_class_install_property(gobject_class, P_BAR_HEIGHT, + g_param_spec_int("bar-height", NULL, + "Bar Height", + 1, INT_MAX, + DEFAULT_BAR_HEIGHT, + G_PARAM_READWRITE));*/ + +} + +static void trg_rss_cell_renderer_init(TrgRssCellRenderer * self) +{ + struct TrgRssCellRendererPrivate *p; + + p = self->priv = G_TYPE_INSTANCE_GET_PRIVATE(self, + TRG_RSS_CELL_RENDERER_TYPE, + struct + TrgRssCellRendererPrivate); + + p->gstr1 = g_string_new(NULL); + p->gstr2 = g_string_new(NULL); + p->text_renderer = gtk_cell_renderer_text_new(); + g_object_set(p->text_renderer, "xpad", 0, "ypad", 0, NULL); + p->icon_renderer = gtk_cell_renderer_pixbuf_new(); + g_object_ref_sink(p->text_renderer); + g_object_ref_sink(p->icon_renderer); +} + + +GtkCellRenderer *trg_rss_cell_renderer_new(void) +{ + return (GtkCellRenderer *) g_object_new(TRG_RSS_CELL_RENDERER_TYPE, + NULL); +} + +static void +get_text_color(TrgRssCellRenderer * r, GtkWidget * widget, + GtrColor * setme) +{ + struct TrgRssCellRendererPrivate *p = r->priv; + + if (p->uploaded) + gtk_style_context_get_color(gtk_widget_get_style_context(widget), + GTK_STATE_FLAG_INSENSITIVE, setme); + else + gtk_style_context_get_color(gtk_widget_get_style_context(widget), + GTK_STATE_FLAG_NORMAL, setme); +} + +static void +trg_rss_cell_renderer_render(GtkCellRenderer * cell, + GtrDrawable * window, GtkWidget * widget, + const GdkRectangle * background_area, + const GdkRectangle * cell_area, + GtkCellRendererState flags) +{ + TrgRssCellRenderer *self = TRG_RSS_CELL_RENDERER(cell); + int xpad, ypad; + GtkRequisition size; + GdkRectangle fill_area; + GdkRectangle icon_area; + GdkRectangle name_area; + GdkRectangle stat_area; + GdkRectangle prog_area; + GdkRectangle prct_area; + GdkPixbuf *icon; + GtrColor text_color; + struct TrgRssCellRendererPrivate *p; + + if (!self) + return; + + p = self->priv; + + icon = get_icon(self, FULL_ICON_SIZE, widget); + gtk_cell_renderer_get_padding(GTK_CELL_RENDERER(cell), &xpad, &ypad); + get_text_color(self, widget, &text_color); + + /* get the idealized cell dimensions */ + g_object_set(p->icon_renderer, "pixbuf", icon, NULL); + gtk_cell_renderer_get_preferred_size(p->icon_renderer, widget, NULL, + &size); + icon_area.width = size.width; + icon_area.height = size.height; + g_object_set(p->text_renderer, "text", p->title, + "weight", PANGO_WEIGHT_BOLD, "ellipsize", + PANGO_ELLIPSIZE_NONE, "scale", 1.0, NULL); + gtk_cell_renderer_get_preferred_size(p->text_renderer, widget, NULL, + &size); + name_area.width = size.width; + name_area.height = size.height; + g_object_set(p->text_renderer, "text", p->feed, "weight", + PANGO_WEIGHT_NORMAL, "scale", SMALL_SCALE, NULL); + gtk_cell_renderer_get_preferred_size(p->text_renderer, widget, NULL, + &size); + prog_area.width = size.width; + prog_area.height = size.height; + g_object_set(p->text_renderer, "text", p->published, NULL); + gtk_cell_renderer_get_preferred_size(p->text_renderer, widget, NULL, + &size); + stat_area.width = size.width; + stat_area.height = size.height; + + /** + *** LAYOUT + **/ + + fill_area = *background_area; + fill_area.x += xpad; + fill_area.y += ypad; + fill_area.width -= xpad * 2; + fill_area.height -= ypad * 2; + + /* icon */ + icon_area.x = fill_area.x; + icon_area.y = fill_area.y + (fill_area.height - icon_area.height) / 2; + + /* name */ + name_area.x = icon_area.x + icon_area.width + GUI_PAD; + name_area.y = fill_area.y; + name_area.width = + fill_area.width - GUI_PAD - icon_area.width - GUI_PAD_SMALL; + + /* prog */ + prog_area.x = name_area.x; + prog_area.y = name_area.y + name_area.height; + prog_area.width = name_area.width; + + /* progressbar */ + prct_area.x = prog_area.x; + prct_area.y = prog_area.y + prog_area.height + GUI_PAD_SMALL; + prct_area.width = prog_area.width; + prct_area.height = 0; + + /* status */ + stat_area.x = prct_area.x; + stat_area.y = prct_area.y + prct_area.height + GUI_PAD_SMALL; + stat_area.width = prct_area.width; + + /** + *** RENDER + **/ + + g_object_set(p->icon_renderer, "pixbuf", icon, "sensitive", TRUE, + NULL); + gtr_cell_renderer_render(p->icon_renderer, window, widget, &icon_area, + flags); + g_object_set(p->text_renderer, "text", p->title, + "scale", 1.0, FOREGROUND_COLOR_KEY, &text_color, + "ellipsize", PANGO_ELLIPSIZE_END, "weight", + PANGO_WEIGHT_BOLD, NULL); + gtr_cell_renderer_render(p->text_renderer, window, widget, &name_area, + flags); + g_object_set(p->text_renderer, "text", p->feed, "scale", + SMALL_SCALE, "weight", PANGO_WEIGHT_NORMAL, NULL); + gtr_cell_renderer_render(p->text_renderer, window, widget, &prog_area, + flags); + g_object_set(p->text_renderer, "text", p->published, + FOREGROUND_COLOR_KEY, &text_color, NULL); + gtr_cell_renderer_render(p->text_renderer, window, widget, &stat_area, + flags); + + /* cleanup */ + g_object_unref(icon); +} + +#endif diff --git a/src/trg-rss-cell-renderer.h b/src/trg-rss-cell-renderer.h new file mode 100644 index 0000000..a255d90 --- /dev/null +++ b/src/trg-rss-cell-renderer.h @@ -0,0 +1,55 @@ +/* + * transmission-remote-gtk - A GTK RPC client to Transmission + * Copyright (C) 2011-2013 Alan Fitton + + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef TRG_RSS_CELL_RENDERER_H +#define TRG_RSS_CELL_RENDERER_H + +#include "config.h" + +#ifdef HAVE_RSSGLIB + +#include <gtk/gtk.h> + +#define TRG_RSS_CELL_RENDERER_TYPE ( trg_rss_cell_renderer_get_type( ) ) + +#define TRG_RSS_CELL_RENDERER( o ) \ + ( G_TYPE_CHECK_INSTANCE_CAST( ( o ), \ + TRG_RSS_CELL_RENDERER_TYPE, \ + TrgRssCellRenderer ) ) + +typedef struct TrgRssCellRenderer TrgRssCellRenderer; + +typedef struct TrgRssCellRendererClass TrgRssCellRendererClass; + +struct TrgRssCellRenderer { + GtkCellRenderer parent; + struct TrgRssCellRendererPrivate *priv; +}; + +struct TrgRssCellRendererClass { + GtkCellRendererClass parent; +}; + +GType trg_rss_cell_renderer_get_type(void) G_GNUC_CONST; + +GtkCellRenderer *trg_rss_cell_renderer_new(void); + +#endif + +#endif /* TRG_RSS_CELL_RENDERER_H */ diff --git a/src/trg-rss-model.c b/src/trg-rss-model.c new file mode 100644 index 0000000..f898f34 --- /dev/null +++ b/src/trg-rss-model.c @@ -0,0 +1,259 @@ +/* + * transmission-remote-gtk - A GTK RPC client to Transmission + * Copyright (C) 2011-2013 Alan Fitton + + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" + +#ifdef HAVE_RSSGLIB + +#include <gtk/gtk.h> +#include <json-glib/json-glib.h> +#include <rss-glib/rss-glib.h> + +#include "config.h" +#include "torrent.h" +#include "trg-client.h" +#include "trg-model.h" +#include "trg-rss-model.h" + +enum { + PROP_0, PROP_CLIENT +}; + +enum { + SIGNAL_GET_ERROR, SIGNAL_PARSE_ERROR, SIGNAL_COUNT +}; + +static guint signals[SIGNAL_COUNT] = { 0 }; + +G_DEFINE_TYPE(TrgRssModel, trg_rss_model, GTK_TYPE_LIST_STORE) +#define TRG_RSS_MODEL_GET_PRIVATE(o) \ + (G_TYPE_INSTANCE_GET_PRIVATE ((o), TRG_TYPE_RSS_MODEL, TrgRssModelPrivate)) +typedef struct _TrgRssModelPrivate TrgRssModelPrivate; + +struct _TrgRssModelPrivate { + TrgClient *client; + GHashTable *table; + guint index; +}; + +typedef struct { + TrgRssModel *model; + gchar *feed_id; + gchar *feed_url; + GError *error; + trg_response *response; +} feed_update; + +static void feed_update_free(feed_update *update) { + if (update->error) + g_error_free(update->error); + + g_free(update->feed_id); + g_free(update->feed_url); + + g_free(update); +} + +static gboolean on_rss_receive(gpointer data) { + trg_response *response = (trg_response *) data; + feed_update *update = (feed_update*) response->cb_data; + TrgRssModel *model = update->model; + TrgRssModelPrivate *priv = TRG_RSS_MODEL_GET_PRIVATE(model); + + if (response->status == CURLE_OK) { + RssParser* parser = rss_parser_new(); + GError *error = NULL; + if (rss_parser_load_from_data(parser, response->raw, + response->size, &error)) { + RssDocument *doc = rss_parser_get_document(parser); + GtkTreeIter iter; + GList *list, *tmp; + gchar *title; + + list = rss_document_get_items(doc); + + for (tmp = list; tmp != NULL; tmp = tmp->next) { + RssItem *item = (RssItem*) tmp->data; + const gchar *guid = rss_item_get_guid(item); + if (g_hash_table_lookup(priv->table, guid) != (void*) 1) { + gtk_list_store_append(GTK_LIST_STORE(model), &iter); + gtk_list_store_set(GTK_LIST_STORE(model), &iter, RSSCOL_ID, + guid, RSSCOL_TITLE, rss_item_get_title(item), + RSSCOL_LINK, rss_item_get_link(item), RSSCOL_FEED, + update->feed_id, RSSCOL_PUBDATE, + rss_item_get_pub_date(item), -1); + g_hash_table_insert(priv->table, g_strdup(guid), (void*) 1); + } + } + + g_list_free(list); + g_object_unref(doc); + g_object_unref(parser); + } else { + rss_parse_error perror; + perror.error = error; + perror.feed_id = update->feed_id; + + g_signal_emit(model, signals[SIGNAL_PARSE_ERROR], 0, + &perror); + + g_message("parse error: %s", error->message); + g_error_free(error); + } + } else { + rss_get_error get_error; + get_error.error_code = response->status; + get_error.feed_id = update->feed_id; + + g_signal_emit(model, signals[SIGNAL_GET_ERROR], 0, + &get_error); + } + + trg_response_free(response); + feed_update_free(update); + + return FALSE; +} + +void trg_rss_model_update(TrgRssModel * model) { + TrgRssModelPrivate *priv = TRG_RSS_MODEL_GET_PRIVATE(model); + TrgPrefs *prefs = trg_client_get_prefs(priv->client); + JsonArray *feeds = trg_prefs_get_rss(prefs); + GList *li; + + if (!feeds) + return; + + for (li = json_array_get_elements(feeds); li != NULL; + li = g_list_next(li)) { + JsonObject *feed = json_node_get_object((JsonNode *) li->data); + const gchar *url = json_object_get_string_member(feed, "url"); + const gchar *id = json_object_get_string_member(feed, "id"); + + if (!url || !id) + continue; + + feed_update *update = g_new0(feed_update, 1); + update->feed_url = g_strdup(url); + update->feed_id = g_strdup(id); + update->model = model; + + async_http_request(priv->client, update->feed_url, on_rss_receive, + update); + } + + /*trg_model_remove_removed(GTK_LIST_STORE(model), + RSSCOL_UPDATESERIAL, updateSerial);*/ +} + +static void trg_rss_model_set_property(GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec G_GNUC_UNUSED) { + TrgRssModelPrivate *priv = TRG_RSS_MODEL_GET_PRIVATE(object); + + switch (prop_id) { + case PROP_CLIENT: + priv->client = g_value_get_pointer(value); + break; + } +} + +static void trg_rss_model_get_property(GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec G_GNUC_UNUSED) { +} + +static GObject *trg_rss_model_constructor(GType type, + guint n_construct_properties, GObjectConstructParam * construct_params) { + GObject *obj = G_OBJECT_CLASS + (trg_rss_model_parent_class)->constructor(type, + n_construct_properties, construct_params); + TrgRssModelPrivate *priv = TRG_RSS_MODEL_GET_PRIVATE(obj); + + priv->table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); + + return obj; +} + +static void trg_rss_model_dispose(GObject * object) { + TrgRssModelPrivate *priv = TRG_RSS_MODEL_GET_PRIVATE(object); + g_hash_table_destroy(priv->table); + G_OBJECT_CLASS(trg_rss_model_parent_class)->dispose(object); +} + +static void trg_rss_model_class_init(TrgRssModelClass * klass) { + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_type_class_add_private(klass, sizeof(TrgRssModelPrivate)); + + object_class->set_property = trg_rss_model_set_property; + object_class->get_property = trg_rss_model_get_property; + object_class->constructor = trg_rss_model_constructor; + object_class->dispose = trg_rss_model_dispose; + + g_object_class_install_property(object_class, PROP_CLIENT, + g_param_spec_pointer("client", "client", "client", + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY + | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK + | G_PARAM_STATIC_BLURB)); + + signals[SIGNAL_GET_ERROR] = g_signal_new("get-error", + G_TYPE_FROM_CLASS + (object_class), + G_SIGNAL_RUN_LAST | + G_SIGNAL_ACTION, + G_STRUCT_OFFSET + (TrgRssModelClass, + get_error), + NULL, NULL, + g_cclosure_marshal_VOID__POINTER, + G_TYPE_NONE, 1, + G_TYPE_POINTER); + + signals[SIGNAL_PARSE_ERROR] = g_signal_new("parse-error", + G_TYPE_FROM_CLASS + (object_class), + G_SIGNAL_RUN_LAST | + G_SIGNAL_ACTION, + G_STRUCT_OFFSET + (TrgRssModelClass, + parse_error), + NULL, NULL, + g_cclosure_marshal_VOID__POINTER, + G_TYPE_NONE, 1, + G_TYPE_POINTER); +} + +static void trg_rss_model_init(TrgRssModel * self) { + GType column_types[RSSCOL_COLUMNS]; + + column_types[RSSCOL_ID] = G_TYPE_STRING; + column_types[RSSCOL_TITLE] = G_TYPE_STRING; + column_types[RSSCOL_LINK] = G_TYPE_STRING; + column_types[RSSCOL_FEED] = G_TYPE_STRING; + column_types[RSSCOL_PUBDATE] = G_TYPE_STRING; + column_types[RSSCOL_UPLOADED] = G_TYPE_BOOLEAN; + + gtk_list_store_set_column_types(GTK_LIST_STORE(self), RSSCOL_COLUMNS, + column_types); +} + +TrgRssModel *trg_rss_model_new(TrgClient *client) { + return g_object_new(TRG_TYPE_RSS_MODEL, "client", client, NULL); +} + +#endif diff --git a/src/trg-rss-model.h b/src/trg-rss-model.h new file mode 100644 index 0000000..206ee41 --- /dev/null +++ b/src/trg-rss-model.h @@ -0,0 +1,86 @@ +/* + * transmission-remote-gtk - A GTK RPC client to Transmission + * Copyright (C) 2011-2013 Alan Fitton + + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef TRG_RSS_MODEL_H_ +#define TRG_RSS_MODEL_H_ + +#include "config.h" + +#ifdef HAVE_RSSGLIB + +#include <glib-object.h> +#include <json-glib/json-glib.h> + +#include "trg-client.h" +#include "trg-model.h" + +G_BEGIN_DECLS +#define TRG_TYPE_RSS_MODEL trg_rss_model_get_type() +#define TRG_RSS_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRG_TYPE_RSS_MODEL, TrgRssModel)) +#define TRG_RSS_MODEL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), TRG_TYPE_RSS_MODEL, TrgRssModelClass)) +#define TRG_IS_RSS_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TRG_TYPE_RSS_MODEL)) +#define TRG_IS_RSS_MODEL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), TRG_TYPE_RSS_MODEL)) +#define TRG_RSS_MODEL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), TRG_TYPE_RSS_MODEL, TrgRssModelClass)) + typedef struct { + GtkListStore parent; +} TrgRssModel; + +typedef struct { + gchar *feed_id; + gint error_code; +} rss_get_error; + +typedef struct { + GError *error; + gchar *feed_id; +} rss_parse_error; + +typedef struct { + GtkListStoreClass parent_class; + void (*get_error) (TrgRssModel * model, + rss_get_error *error); + void (*parse_error) (TrgRssModel * model, + rss_parse_error *error); +} TrgRssModelClass; + +GType trg_rss_model_get_type(void); + +TrgRssModel *trg_rss_model_new(TrgClient *client); + +G_END_DECLS +void trg_rss_model_update(TrgRssModel * model); + +enum { + RSSCOL_ID, + RSSCOL_TITLE, + RSSCOL_LINK, + RSSCOL_FEED, + RSSCOL_PUBDATE, + RSSCOL_UPLOADED, + RSSCOL_COLUMNS +}; + +#endif + +#endif /* TRG_RSS_MODEL_H_ */ diff --git a/src/trg-rss-window.c b/src/trg-rss-window.c new file mode 100644 index 0000000..442cce9 --- /dev/null +++ b/src/trg-rss-window.c @@ -0,0 +1,368 @@ +/* + * transmission-remote-gtk - A GTK RPC client to Transmission + * Copyright (C) 2011-2013 Alan Fitton + + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" + +#ifdef HAVE_RSSGLIB + +#include <gtk/gtk.h> +#include <glib/gi18n.h> +#include <rss-glib/rss-glib.h> + +#include "trg-rss-window.h" +#include "trg-rss-model.h" +#include "trg-rss-cell-renderer.h" +#include "trg-torrent-add-dialog.h" +#include "trg-preferences-dialog.h" +#include "trg-client.h" +#include "upload.h" +#include "util.h" + +G_DEFINE_TYPE(TrgRssWindow, trg_rss_window, + GTK_TYPE_WINDOW) +#define TRG_RSS_WINDOW_GET_PRIVATE(o) \ +(G_TYPE_INSTANCE_GET_PRIVATE ((o), TRG_TYPE_RSS_WINDOW, TrgRssWindowPrivate)) +enum { + PROP_0, PROP_PARENT, PROP_CLIENT +}; + +typedef struct _TrgRssWindowPrivate TrgRssWindowPrivate; + +struct _TrgRssWindowPrivate { + TrgMainWindow *parent; + TrgClient *client; + GtkTreeView *tree_view; + TrgRssModel *tree_model; +}; + +static GObject *instance = NULL; + +static void +trg_rss_window_get_property(GObject * object, + guint property_id, + GValue * value, GParamSpec * pspec) +{ + TrgRssWindowPrivate *priv = + TRG_RSS_WINDOW_GET_PRIVATE(object); + switch (property_id) { + case PROP_CLIENT: + g_value_set_pointer(value, priv->client); + break; + case PROP_PARENT: + g_value_set_object(value, priv->parent); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void +trg_rss_window_set_property(GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec) +{ + TrgRssWindowPrivate *priv = + TRG_RSS_WINDOW_GET_PRIVATE(object); + switch (property_id) { + case PROP_PARENT: + priv->parent = g_value_get_object(value); + break; + case PROP_CLIENT: + priv->client = g_value_get_pointer(value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static gboolean upload_complete_searchfunc(GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer data) { + trg_upload *upload = (trg_upload*)data; + gchar *item_guid = NULL; + gboolean stop = FALSE; + + gtk_tree_model_get(model, iter, RSSCOL_ID, &item_guid, -1); + + if (!g_strcmp0(item_guid, upload->uid)) { + gtk_list_store_set(GTK_LIST_STORE(model), iter, RSSCOL_UPLOADED, TRUE, -1); + stop = TRUE; + } + + g_free(item_guid); + + return stop; +} + +static gboolean on_upload_complete(gpointer data) { + trg_response *response = (trg_response*)data; + trg_upload *upload = (trg_upload*)response->cb_data; + TrgRssWindowPrivate *priv = TRG_RSS_WINDOW_GET_PRIVATE(upload->cb_data); + + if (response->status == CURLE_OK) + gtk_tree_model_foreach(GTK_TREE_MODEL(priv->tree_model), upload_complete_searchfunc, upload); + + return FALSE; +} + +static gboolean on_torrent_receive(gpointer data) { + trg_response *response = (trg_response *) data; + trg_upload *upload = (trg_upload*)response->cb_data; + TrgRssWindowPrivate *priv = TRG_RSS_WINDOW_GET_PRIVATE(upload->cb_data); + TrgClient *client = priv->client; + TrgPrefs *prefs = trg_client_get_prefs(client); + TrgMainWindow *main_win = priv->parent; + + upload->upload_response = response; + + if (response->status == CURLE_OK) { + if (trg_prefs_get_bool(prefs, TRG_PREFS_KEY_ADD_OPTIONS_DIALOG, + TRG_PREFS_GLOBAL)) { + TrgTorrentAddDialog *dialog = + trg_torrent_add_dialog_new_from_upload(main_win, client, + upload); + gtk_widget_show_all(GTK_WIDGET(dialog)); + } else { + trg_do_upload(upload); + } + } else { + trg_error_dialog(GTK_WINDOW(main_win), response); + trg_upload_free(upload); + } + + return FALSE; +} + +static void +rss_item_activated(GtkTreeView * treeview, + GtkTreePath * path, + GtkTreeViewColumn * + col G_GNUC_UNUSED, gpointer userdata) +{ + TrgRssWindow *win = TRG_RSS_WINDOW(userdata); + TrgRssWindowPrivate *priv = TRG_RSS_WINDOW_GET_PRIVATE(win); + TrgClient *client = priv->client; + TrgPrefs *prefs = trg_client_get_prefs(client); + GtkTreeModel *model = gtk_tree_view_get_model(treeview); + trg_upload *upload = g_new0(trg_upload, 1); + GtkTreeIter iter; + gchar *link, *uid; + + //upload->upload_response = response; + upload->main_window = priv->parent; + upload->client = client; + upload->extra_args = FALSE; + upload->flags = trg_prefs_get_add_flags(prefs); + upload->callback = on_upload_complete; + upload->cb_data = win; + + gtk_tree_model_get_iter(model, &iter, path); + + gtk_tree_model_get(model, &iter, RSSCOL_LINK, &link, RSSCOL_ID, &uid, -1); + + upload->uid = uid; + + async_http_request(priv->client, link, on_torrent_receive, upload); + + g_free(link); +} + +static void trg_rss_on_get_error(TrgRssModel *model, rss_get_error *error, gpointer data) { + GtkWindow *win = GTK_WINDOW(data); + gchar *msg; + if (error->error_code <= -100) { + msg = g_strdup_printf(_("Request failed with HTTP code %d"), -(error->error_code + 100)); + } else { + msg = g_strdup(curl_easy_strerror(error->error_code)); + } + GtkWidget *dialog = gtk_message_dialog_new(win, + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + msg); + g_free(msg); + gtk_window_set_title(GTK_WINDOW(dialog), _("Error")); + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); +} + +static void trg_rss_on_parse_error(TrgRssModel *model, rss_parse_error *error, gpointer data) { + GtkWindow *win = GTK_WINDOW(data); + gchar *msg = g_strdup_printf(_("Error parsing RSS feed \"%s\": %s"), error->feed_id, error->error->message); + GtkWidget *dialog = gtk_message_dialog_new(win, + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + msg); + g_free(msg); + gtk_window_set_title(GTK_WINDOW(dialog), _("Error")); + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); +} + +static void on_configure(GtkWidget *widget, gpointer data) { + TrgRssWindowPrivate *priv = TRG_RSS_WINDOW_GET_PRIVATE(data); + GtkWidget *dlg = trg_preferences_dialog_get_instance(priv->parent, priv->client); + gtk_widget_show_all(dlg); + trg_preferences_dialog_set_page(TRG_PREFERENCES_DIALOG(dlg), 5); +} + +static void on_refresh(GtkWidget *widget, gpointer data) { + TrgRssWindowPrivate *priv = TRG_RSS_WINDOW_GET_PRIVATE(data); + trg_rss_model_update(priv->tree_model); +} + +static GObject *trg_rss_window_constructor(GType type, + guint + n_construct_properties, + GObjectConstructParam * + construct_params) +{ + GObject *object; + TrgRssWindowPrivate *priv; + GtkWidget *vbox; + GtkToolItem *item; + GtkWidget *toolbar; + + object = G_OBJECT_CLASS + (trg_rss_window_parent_class)->constructor(type, + n_construct_properties, + construct_params); + priv = TRG_RSS_WINDOW_GET_PRIVATE(object); + + priv->tree_model = trg_rss_model_new(priv->client); + + g_signal_connect(priv->tree_model, "get-error", + G_CALLBACK(trg_rss_on_get_error), object); + g_signal_connect(priv->tree_model, "parse-error", + G_CALLBACK(trg_rss_on_parse_error), object); + + trg_rss_model_update(priv->tree_model); + + priv->tree_view = GTK_TREE_VIEW(gtk_tree_view_new()); + gtk_tree_view_set_headers_visible(priv->tree_view, FALSE); + gtk_tree_view_set_model(priv->tree_view, GTK_TREE_MODEL(priv->tree_model)); + + gtk_tree_view_insert_column_with_attributes(priv->tree_view, -1, NULL, trg_rss_cell_renderer_new(), "title", RSSCOL_TITLE, "feed", RSSCOL_FEED, "published", RSSCOL_PUBDATE, "uploaded", RSSCOL_UPLOADED, NULL); + + g_signal_connect(priv->tree_view, "row-activated", + G_CALLBACK(rss_item_activated), object); + + gtk_window_set_title(GTK_WINDOW(object), _("RSS Feeds")); + + toolbar = gtk_toolbar_new(); + + item = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH); + gtk_widget_set_sensitive(GTK_WIDGET(item), TRUE); + gtk_tool_item_set_tooltip_text(item, "Refresh"); + g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(on_refresh), object); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, 0); + + item = gtk_tool_button_new_from_stock(GTK_STOCK_PREFERENCES); + gtk_widget_set_sensitive(GTK_WIDGET(item), TRUE); + gtk_tool_item_set_tooltip_text(item, "Configure Feeds"); + g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(on_configure), object); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, 0); + + vbox = trg_vbox_new(FALSE, 0); + + gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(toolbar), + FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), my_scrolledwin_new(GTK_WIDGET(priv->tree_view)), + TRUE, TRUE, 0); + + gtk_container_add(GTK_CONTAINER(object), vbox); + + /*g_signal_connect(object, "response", + G_CALLBACK(trg_rss_window_response_cb), NULL);*/ + + gtk_widget_set_size_request(GTK_WIDGET(object), 500, 300); + + return object; +} + +static void trg_rss_window_dispose(GObject * object) +{ + instance = NULL; + G_OBJECT_CLASS(trg_rss_window_parent_class)->dispose(object); +} + +static void +trg_rss_window_class_init(TrgRssWindowClass * klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + g_type_class_add_private(klass, sizeof(TrgRssWindowPrivate)); + + object_class->constructor = trg_rss_window_constructor; + object_class->get_property = trg_rss_window_get_property; + object_class->set_property = trg_rss_window_set_property; + object_class->dispose = trg_rss_window_dispose; + + g_object_class_install_property(object_class, + PROP_CLIENT, + g_param_spec_pointer("trg-client", + "TClient", + "Client", + G_PARAM_READWRITE + | + G_PARAM_CONSTRUCT_ONLY + | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); + + g_object_class_install_property(object_class, + PROP_PARENT, + g_param_spec_object("parent-window", + "Parent window", + "Parent window", + TRG_TYPE_MAIN_WINDOW, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY + | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); +} + +static void +trg_rss_window_init(TrgRssWindow * self G_GNUC_UNUSED) +{ +} + +TrgRssWindow *trg_rss_window_get_instance(TrgMainWindow *parent, TrgClient *client) +{ + if (instance == NULL) { + instance = + g_object_new(TRG_TYPE_RSS_WINDOW, "parent-window", parent, "trg-client", client, NULL); + } + + return TRG_RSS_WINDOW(instance); +} + +#endif diff --git a/src/trg-rss-window.h b/src/trg-rss-window.h new file mode 100644 index 0000000..5ce8690 --- /dev/null +++ b/src/trg-rss-window.h @@ -0,0 +1,60 @@ +/* + * transmission-remote-gtk - A GTK RPC client to Transmission + * Copyright (C) 2011-2013 Alan Fitton + + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef TRG_RSS_WINDOW_H_ +#define TRG_RSS_WINDOW_H_ + +#include "config.h" + +#ifdef HAVE_RSSGLIB + +#include <glib-object.h> +#include <gtk/gtk.h> + +#include "trg-main-window.h" + +G_BEGIN_DECLS +#define TRG_TYPE_RSS_WINDOW trg_rss_window_get_type() +#define TRG_RSS_WINDOW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRG_TYPE_RSS_WINDOW, TrgRssWindow)) +#define TRG_RSS_WINDOW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), TRG_TYPE_RSS_WINDOW, TrgRssWindowClass)) +#define TRG_IS_RSS_WINDOW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TRG_TYPE_RSS_WINDOW)) +#define TRG_IS_RSS_WINDOW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), TRG_TYPE_RSS_WINDOW)) +#define TRG_RSS_WINDOW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), TRG_TYPE_RSS_WINDOW, TrgRssWindowClass)) + typedef struct { + GtkWindow parent; +} TrgRssWindow; + +typedef struct { + GtkWindowClass parent_class; +} TrgRssWindowClass; + +GType trg_rss_window_get_type(void); + +TrgRssWindow *trg_rss_window_get_instance(TrgMainWindow *parent, TrgClient *client); + +G_END_DECLS + +#endif + +#endif /* TRG_RSS_WINDOW_H_ */ diff --git a/src/trg-toolbar.h b/src/trg-toolbar.h index 7d12b2d..6887a16 100644 --- a/src/trg-toolbar.h +++ b/src/trg-toolbar.h @@ -17,7 +17,6 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ - #ifndef TRG_TOOLBAR_H_ #define TRG_TOOLBAR_H_ diff --git a/src/trg-torrent-add-dialog.c b/src/trg-torrent-add-dialog.c index 517797e..aa63166 100644 --- a/src/trg-torrent-add-dialog.c +++ b/src/trg-torrent-add-dialog.c @@ -45,9 +45,10 @@ #include "torrent.h" #include "json.h" #include "protocol-constants.h" +#include "upload.h" enum { - PROP_0, PROP_FILENAME, PROP_PARENT, PROP_CLIENT + PROP_0, PROP_FILENAME, PROP_PARENT, PROP_CLIENT, PROP_UPLOAD }; enum { @@ -63,6 +64,7 @@ struct _TrgTorrentAddDialogPrivate { TrgClient *client; TrgMainWindow *parent; GSList *filenames; + trg_upload *upload; GtkWidget *source_chooser; GtkWidget *dest_combo; GtkWidget *priority_combo; @@ -70,6 +72,7 @@ struct _TrgTorrentAddDialogPrivate { GtkTreeStore *store; GtkWidget *paused_check; GtkWidget *delete_check; + guint n_files; }; #define MAGNET_MAX_LINK_WIDTH 75 @@ -90,6 +93,9 @@ static void trg_torrent_add_dialog_set_property(GObject * object, case PROP_PARENT: priv->parent = g_value_get_object(value); break; + case PROP_UPLOAD: + priv->upload = g_value_get_pointer(value); + break; case PROP_CLIENT: priv->client = g_value_get_pointer(value); break; @@ -115,72 +121,13 @@ trg_torrent_add_dialog_get_property(GObject * object, } } -static void -add_set_common_args(JsonObject * args, gint priority, gchar * dir) -{ - json_object_set_string_member(args, FIELD_FILE_DOWNLOAD_DIR, dir); - json_object_set_int_member(args, FIELD_BANDWIDTH_PRIORITY, - (gint64) priority); -} - -static gpointer add_files_threadfunc(gpointer data) -{ - struct add_torrent_threadfunc_args *files_thread_data = - (struct add_torrent_threadfunc_args *) data; - - GSList *li; - - for (li = files_thread_data->list; li; li = g_slist_next(li)) { - gchar *fileName = (gchar *) li->data; - JsonNode *request = - torrent_add(fileName, files_thread_data->flags); - JsonObject *args; - trg_response *response; - - if (!request) - continue; - - args = node_get_arguments(request); - - if (files_thread_data->extraArgs) - add_set_common_args(args, files_thread_data->priority, - files_thread_data->dir); - - response = dispatch(files_thread_data->client, request); - response->cb_data = files_thread_data->cb_data; - g_idle_add(on_generic_interactive_action, response); - } - - g_str_slist_free(files_thread_data->list); - - if (files_thread_data->extraArgs) - g_free(files_thread_data->dir); - - g_free(files_thread_data); - - return NULL; -} - -void launch_add_thread(struct add_torrent_threadfunc_args *args) -{ - GError *error = NULL; - g_thread_create(add_files_threadfunc, args, FALSE, &error); - - if (error) { - g_error("thread creation error: %s", error->message); - g_error_free(error); - g_str_slist_free(args->list); - g_free(args); - } -} - static gboolean add_file_indexes_foreachfunc(GtkTreeModel * model, GtkTreePath * path G_GNUC_UNUSED, GtkTreeIter * iter, gpointer data) { - JsonObject *args = (JsonObject *) data; + trg_upload *upload = (trg_upload *) data; gint priority, index, wanted; gtk_tree_model_get(model, iter, FC_PRIORITY, &priority, FC_ENABLED, @@ -189,17 +136,8 @@ add_file_indexes_foreachfunc(GtkTreeModel * model, if (gtk_tree_model_iter_has_child(model, iter) || index < 0) return FALSE; - if (wanted) - add_file_id_to_array(args, FIELD_FILES_WANTED, index); - else - add_file_id_to_array(args, FIELD_FILES_UNWANTED, index); - - if (priority == TR_PRI_LOW) - add_file_id_to_array(args, FIELD_FILES_PRIORITY_LOW, index); - else if (priority == TR_PRI_HIGH) - add_file_id_to_array(args, FIELD_FILES_PRIORITY_HIGH, index); - else - add_file_id_to_array(args, FIELD_FILES_PRIORITY_NORMAL, index); + upload->file_wanted[index] = wanted; + upload->file_priorities[index] = priority; return FALSE; } @@ -225,38 +163,33 @@ trg_torrent_add_response_cb(GtkDialog * dlg, gint res_id, gpointer data) gchar *dir = trg_destination_combo_get_dir(TRG_DESTINATION_COMBO (priv->dest_combo)); + trg_upload *upload; - if (g_slist_length(priv->filenames) == 1) { - JsonNode *req = - torrent_add((gchar *) priv->filenames->data, flags); - if (req) { - JsonObject *args = node_get_arguments(req); - gtk_tree_model_foreach(GTK_TREE_MODEL(priv->store), - add_file_indexes_foreachfunc, args); - add_set_common_args(args, priority, dir); - dispatch_async(priv->client, req, - on_generic_interactive_action, - priv->parent); - } - g_str_slist_free(priv->filenames); + if (priv->upload) { + upload = priv->upload; } else { - struct add_torrent_threadfunc_args *args = - g_new(struct add_torrent_threadfunc_args, 1); - args->list = priv->filenames; - args->cb_data = priv->parent; - args->client = priv->client; - args->dir = g_strdup(dir); - args->priority = priority; - args->flags = flags; - args->extraArgs = TRUE; - - launch_add_thread(args); + upload = g_new0(trg_upload, 1); + upload->list = priv->filenames; } + upload->main_window = priv->parent; + upload->client = priv->client; + upload->dir = dir; + upload->priority = priority; + upload->flags = flags; + upload->extra_args = TRUE; + + upload->n_files = priv->n_files; + upload->file_priorities = g_new0(gint, priv->n_files); + upload->file_wanted = g_new0(gint, priv->n_files); + + gtk_tree_model_foreach(GTK_TREE_MODEL(priv->store), + add_file_indexes_foreachfunc, upload); + + trg_do_upload(upload); + trg_destination_combo_save_selection(TRG_DESTINATION_COMBO (priv->dest_combo)); - - g_free(dir); } else { g_str_slist_free(priv->filenames); } @@ -465,7 +398,7 @@ static void addTorrentFilters(GtkFileChooser * chooser) static void store_add_node(GtkTreeStore * store, GtkTreeIter * parent, - trg_files_tree_node * node) + trg_files_tree_node * node, guint *n_files) { GtkTreeIter child; GList *li; @@ -476,11 +409,12 @@ store_add_node(GtkTreeStore * store, GtkTreeIter * parent, 1, FC_INDEX, node->index, FC_PRIORITY, TR_PRI_NORMAL, FC_SIZE, node->length, -1); + *n_files = *n_files + 1; } for (li = node->children; li; li = g_list_next(li)) store_add_node(store, node->name ? &child : NULL, - (trg_files_tree_node *) li->data); + (trg_files_tree_node *) li->data, n_files); } static void torrent_not_parsed_warning(GtkWindow * parent) @@ -511,6 +445,28 @@ static void torrent_not_found_error(GtkWindow * parent, gchar * file) } static void +trg_torrent_add_dialog_set_upload(TrgTorrentAddDialog *d, trg_upload *upload) { + TrgTorrentAddDialogPrivate *priv = + TRG_TORRENT_ADD_DIALOG_GET_PRIVATE(d); + GtkButton *chooser = GTK_BUTTON(priv->source_chooser); + trg_torrent_file *tor_data = NULL; + + if (upload->uid) + gtk_button_set_label(chooser, upload->uid); + + tor_data = trg_parse_torrent_data(upload->upload_response->raw, upload->upload_response->size); + + if (!tor_data) { + torrent_not_parsed_warning(GTK_WINDOW(priv->parent)); + } else { + store_add_node(priv->store, NULL, tor_data->top_node, &priv->n_files); + trg_torrent_file_free(tor_data); + } + + gtk_widget_set_sensitive(priv->file_list, tor_data != NULL); +} + +static void trg_torrent_add_dialog_set_filenames(TrgTorrentAddDialog * d, GSList * filenames) { @@ -521,6 +477,11 @@ trg_torrent_add_dialog_set_filenames(TrgTorrentAddDialog * d, gtk_tree_store_clear(priv->store); + if (priv->upload) { + trg_upload_free(priv->upload); + priv->upload = NULL; + } + if (nfiles == 1) { gchar *file_name = (gchar *) filenames->data; if (is_url(file_name) || is_magnet(file_name)) { @@ -556,7 +517,7 @@ trg_torrent_add_dialog_set_filenames(TrgTorrentAddDialog * d, if (!tor_data) { torrent_not_parsed_warning(GTK_WINDOW(priv->parent)); } else { - store_add_node(priv->store, NULL, tor_data->top_node); + store_add_node(priv->store, NULL, tor_data->top_node, &priv->n_files); trg_torrent_file_free(tor_data); } } else { @@ -784,8 +745,12 @@ static GObject *trg_torrent_add_dialog_constructor(GType type, priv->source_chooser = gtk_button_new(); gtk_button_set_alignment(GTK_BUTTON(priv->source_chooser), 0.0f, 0.5f); - trg_torrent_add_dialog_set_filenames(TRG_TORRENT_ADD_DIALOG(obj), - priv->filenames); + + if (priv->filenames) + trg_torrent_add_dialog_set_filenames(TRG_TORRENT_ADD_DIALOG(obj), + priv->filenames); + else if (priv->upload) + trg_torrent_add_dialog_set_upload(TRG_TORRENT_ADD_DIALOG(obj), priv->upload); gtk_table_attach(GTK_TABLE(t), priv->source_chooser, 1, 2, 0, 1, ~0, 0, 0, 0); @@ -868,6 +833,21 @@ trg_torrent_add_dialog_class_init(TrgTorrentAddDialogClass * klass) G_PARAM_STATIC_BLURB)); g_object_class_install_property(object_class, + PROP_UPLOAD, + g_param_spec_pointer("upload", + "upload", + "upload", + G_PARAM_READWRITE + | + G_PARAM_CONSTRUCT_ONLY + | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); + + g_object_class_install_property(object_class, PROP_CLIENT, g_param_spec_pointer("client", "client", @@ -902,7 +882,7 @@ static void trg_torrent_add_dialog_init(TrgTorrentAddDialog * self) { } -TrgTorrentAddDialog *trg_torrent_add_dialog_new(TrgMainWindow * parent, +TrgTorrentAddDialog *trg_torrent_add_dialog_new_from_filenames(TrgMainWindow * parent, TrgClient * client, GSList * filenames) { @@ -911,6 +891,15 @@ TrgTorrentAddDialog *trg_torrent_add_dialog_new(TrgMainWindow * parent, NULL); } +TrgTorrentAddDialog *trg_torrent_add_dialog_new_from_upload(TrgMainWindow * parent, + TrgClient * client, + trg_upload *upload) +{ + return g_object_new(TRG_TYPE_TORRENT_ADD_DIALOG, "upload", + upload, "parent", parent, "client", client, + NULL); +} + void trg_torrent_add_dialog(TrgMainWindow * win, TrgClient * client) { GtkWidget *w; @@ -937,22 +926,21 @@ void trg_torrent_add_dialog(TrgMainWindow * win, TrgClient * client) prefs); if (showOptions) { - TrgTorrentAddDialog *dialog = trg_torrent_add_dialog_new(win, + TrgTorrentAddDialog *dialog = trg_torrent_add_dialog_new_from_filenames(win, client, l); gtk_widget_show_all(GTK_WIDGET(dialog)); } else { - struct add_torrent_threadfunc_args *args = - g_new0(struct add_torrent_threadfunc_args, 1); + trg_upload *upload = g_new0(trg_upload, 1); - args->list = l; - args->cb_data = win; - args->client = client; - args->extraArgs = FALSE; - args->flags = trg_prefs_get_add_flags(prefs); + upload->list = l; + upload->main_window = win; + upload->client = client; + upload->extra_args = FALSE; + upload->flags = trg_prefs_get_add_flags(prefs); - launch_add_thread(args); + trg_do_upload(upload); } } diff --git a/src/trg-torrent-add-dialog.h b/src/trg-torrent-add-dialog.h index 0f45e2c..eebea45 100644 --- a/src/trg-torrent-add-dialog.h +++ b/src/trg-torrent-add-dialog.h @@ -24,6 +24,7 @@ #include <gtk/gtk.h> #include "trg-client.h" +#include "upload.h" #include "trg-main-window.h" G_BEGIN_DECLS @@ -46,28 +47,15 @@ typedef struct { GtkDialogClass parent_class; } TrgTorrentAddDialogClass; -/* Use synchronous dispatch() in our dedicated thread function. - * This means torrents are added in sequence, instead of dispatch_async() - * working concurrently for each upload. - */ - -struct add_torrent_threadfunc_args { - GSList *list; - TrgClient *client; - gpointer cb_data; - guint flags; - gchar *dir; - gint priority; - gboolean extraArgs; -}; - GType trg_torrent_add_dialog_get_type(void); -TrgTorrentAddDialog *trg_torrent_add_dialog_new(TrgMainWindow * win, +TrgTorrentAddDialog *trg_torrent_add_dialog_new_from_filenames(TrgMainWindow * parent, TrgClient * client, GSList * filenames); +TrgTorrentAddDialog *trg_torrent_add_dialog_new_from_upload(TrgMainWindow * parent, + TrgClient * client, + trg_upload *upload); void trg_torrent_add_dialog(TrgMainWindow * win, TrgClient * client); -void launch_add_thread(struct add_torrent_threadfunc_args *args); G_END_DECLS #endif /* TRG_TORRENT_ADD_DIALOG_H_ */ diff --git a/src/trg-torrent-add-url-dialog.c b/src/trg-torrent-add-url-dialog.c index 7f6335e..8ed15d8 100644 --- a/src/trg-torrent-add-url-dialog.c +++ b/src/trg-torrent-add-url-dialog.c @@ -90,7 +90,7 @@ trg_torrent_add_url_response_cb(TrgTorrentAddUrlDialog * dlg, gint res_id, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(priv->startCheck))); dispatch_async(priv->client, request, - on_generic_interactive_action, data); + on_generic_interactive_action_response, data); } gtk_widget_destroy(GTK_WIDGET(dlg)); diff --git a/src/trg-torrent-move-dialog.c b/src/trg-torrent-move-dialog.c index 7669545..99a11fb 100644 --- a/src/trg-torrent-move-dialog.c +++ b/src/trg-torrent-move-dialog.c @@ -69,7 +69,7 @@ trg_torrent_move_response_cb(GtkDialog * dlg, gint res_id, gpointer data) trg_destination_combo_save_selection(TRG_DESTINATION_COMBO (priv->location_combo)); dispatch_async(priv->client, request, - on_generic_interactive_action, data); + on_generic_interactive_action_response, data); } else { json_array_unref(priv->ids); } diff --git a/src/trg-torrent-props-dialog.c b/src/trg-torrent-props-dialog.c index 90ef4e3..71a9c71 100644 --- a/src/trg-torrent-props-dialog.c +++ b/src/trg-torrent-props-dialog.c @@ -172,7 +172,7 @@ static void trg_torrent_props_response_cb(GtkDialog * dialog, gint res_id, trg_json_widgets_save(priv->widgets, args); trg_json_widget_desc_list_free(priv->widgets); - dispatch_async(priv->client, request, on_generic_interactive_action, + dispatch_async(priv->client, request, on_generic_interactive_action_response, priv->parent); } diff --git a/src/trg-trackers-tree-view.c b/src/trg-trackers-tree-view.c index 7ce05b7..54948f3 100644 --- a/src/trg-trackers-tree-view.c +++ b/src/trg-trackers-tree-view.c @@ -66,7 +66,7 @@ static gboolean on_trackers_update(gpointer data) trg_trackers_model_set_accept(TRG_TRACKERS_MODEL(model), TRUE); response->cb_data = priv->win; - return on_generic_interactive_action(data); + return on_generic_interactive_action_response(data); } void diff --git a/src/upload.c b/src/upload.c new file mode 100644 index 0000000..2f16c51 --- /dev/null +++ b/src/upload.c @@ -0,0 +1,103 @@ +#include "protocol-constants.h" +#include "requests.h" +#include "trg-client.h" +#include "util.h" +#include "trg-main-window.h" +#include "json.h" +#include "upload.h" + +static gboolean upload_complete_callback(gpointer data); +static void next_upload(trg_upload *upload); + +static void +add_set_common_args(JsonObject * args, gint priority, gchar * dir) +{ + json_object_set_string_member(args, FIELD_FILE_DOWNLOAD_DIR, dir); + json_object_set_int_member(args, FIELD_BANDWIDTH_PRIORITY, + (gint64) priority); +} + +void trg_upload_free(trg_upload *upload) { + g_str_slist_free(upload->list); + g_free(upload->dir); + g_free(upload->uid); + g_free(upload->file_wanted); + g_free(upload->file_priorities); + trg_response_free(upload->upload_response); + g_free(upload); +} + +static void add_priorities(JsonObject *args, gint* priorities, gint n_files) +{ + gint i; + for (i = 0; i < n_files; i++) { + gint priority = priorities[i]; + if (priority == TR_PRI_LOW) + add_file_id_to_array(args, FIELD_FILES_PRIORITY_LOW, i); + else if (priority == TR_PRI_HIGH) + add_file_id_to_array(args, FIELD_FILES_PRIORITY_HIGH, i); + else + add_file_id_to_array(args, FIELD_FILES_PRIORITY_NORMAL, i); + } +} + +static void add_wanteds(JsonObject *args, gint* wanteds, gint n_files) { + gint i; + for (i = 0; i < n_files; i++) { + if (wanteds[i]) + add_file_id_to_array(args, FIELD_FILES_WANTED, i); + else + add_file_id_to_array(args, FIELD_FILES_UNWANTED, i); + } +} + +static void next_upload(trg_upload *upload) { + JsonNode *req = NULL; + + if (upload->upload_response && upload->progress_index < 1) + req = torrent_add_from_response(upload->upload_response, upload->flags); + else if (upload->list && upload->progress_index < g_slist_length(upload->list)) + req = torrent_add_from_file((gchar*)g_slist_nth_data(upload->list, upload->progress_index), upload->flags); + + if (req) { + JsonObject *args = node_get_arguments(req); + + if (upload->extra_args) + add_set_common_args(args, upload->priority, upload->dir); + + if (upload->file_wanted) + add_wanteds(args, upload->file_wanted, upload->n_files); + + if (upload->file_priorities) + add_priorities(args, upload->file_priorities, upload->n_files); + + upload->progress_index++; + dispatch_async(upload->client, req, upload_complete_callback, upload); + } else { + trg_upload_free(upload); + } +} + +static gboolean upload_complete_callback(gpointer data) { + trg_response *response = (trg_response*)data; + trg_upload *upload = (trg_upload*)response->cb_data; + + if (upload->callback) + upload->callback(data); + + /* the callback we're delegating to will destroy the response */ + + if (upload->main_window) + on_generic_interactive_action(upload->main_window, response); + else + trg_response_free(response); + + next_upload(upload); + + return FALSE; +} + +void trg_do_upload(trg_upload *upload) +{ + next_upload(upload); +} diff --git a/src/upload.h b/src/upload.h new file mode 100644 index 0000000..5dc17e2 --- /dev/null +++ b/src/upload.h @@ -0,0 +1,30 @@ +#ifndef UPLOAD_H_ +#define UPLOAD_H_ + +#include <glib.h> + +#include "trg-client.h" +#include "trg-main-window.h" + +typedef struct { + GSList *list; // list of filenames + trg_response *upload_response; // OR: a HTTP response containing a torrent + TrgClient *client; + gpointer cb_data; + TrgMainWindow *main_window; // a parent window to attach any error dialogs to + guint flags; + gchar *dir; + gint priority; + gint* file_priorities; + gint* file_wanted; + guint n_files; + gboolean extra_args; + guint progress_index; + GSourceFunc callback; + gchar *uid; +} trg_upload; + +void trg_upload_free(trg_upload *upload); +void trg_do_upload(trg_upload *upload); + +#endif @@ -340,7 +340,7 @@ gchar *make_error_message(JsonObject * response, int status) { if (status == FAIL_JSON_DECODE) { return g_strdup(_("JSON decoding error.")); - } else if (status == FAIL_RESPONSE_UNSUCCESSFUL) { + } else if (response && status == FAIL_RESPONSE_UNSUCCESSFUL) { const gchar *resultStr = json_object_get_string_member(response, "result"); if (resultStr == NULL) @@ -32,6 +32,7 @@ #define trg_strlpercent(a, b) tr_strlpercent(a, b, sizeof(a)) #define trg_strlsize(a, b) tr_formatter_size_B(a, b, sizeof(a)) #define trg_strlratio(a, b) tr_strlratio(a, b, sizeof(a)) +#define MAX3(a,b,c) MAX(a,MAX(b,c)) #define TR_RATIO_NA -1 #define TR_RATIO_INF -2 |