irreco/src/core/irreco_theme_upload_dlg.c

   1 /*
   2  * irreco - Ir Remote Control
   3  * Copyright (C) 2007  Arto Karppinen (arto.karppinen@iki.fi)
   4  *               2008  Joni Kokko (t5kojo01@students.oamk.fi)
   5  *               2008  Harri Vattulainen (t5vaha01@students.oamk.fi)
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  */
  21
  22 #include "irreco_theme_upload_dlg.h"
  23 #include "irreco_button_browser_dlg.h"
  24 #include <hildon/hildon-banner.h>
  25
  26
  27 /**
  28  * @addtogroup IrrecoThemeUploadDlg
  29  * @ingroup Irreco
  30  *
  31  * Allow user to set theme settings and upload it.
  32  *
  33  * @{
  34  */
  35
  36 /**
  37  * @file
  38  * Source file of @ref IrrecoThemeUploadDlg.
  39  */
  40
  41
  42
  43 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  44 /* Datatypes                                                                  */
  45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  46
  47 #define IRRECO_THEME_UPLOAD_PREVIEW_WIDHT       (IRRECO_SCREEN_WIDTH / 6)
  48 #define IRRECO_THEME_UPLOAD_PREVIEW_HEIGHT      (IRRECO_SCREEN_HEIGHT / 6)
  49
  50 /** Loader states. */
  51 enum
  52 {
  53         LOADER_STATE_INIT,
  54         LOADER_STATE_THEME,
  55         LOADER_STATE_BUTTONS,
  56         LOADER_STATE_BACKGROUNDS,
  57         LOADER_STATE_END
  58 };
  59
  60 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  61 /* Prototypes                                                                 */
  62 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  63 static gboolean _texts_ok(IrrecoThemeUploadDlg *self);
  64 static gboolean _send_theme(IrrecoThemeUploadDlg *self);
  65 static void _update_preview(IrrecoThemeUploadDlg *self);
  66 static void _run_button_browser_dlg(GtkWidget      *widget,
  67                                     GdkEventButton *event,
  68                                     IrrecoThemeUploadDlg *self);
  69 static gboolean _get_image_data_and_hash(gchar* img_path,
  70                                          guchar **img_data,
  71                                          gchar **img_sha,
  72                                          gint *img_data_len,
  73                                          gsize buffer_size,
  74                                          gchar **error_msg);
  75 static void _hide_banner(IrrecoThemeUploadDlg *self);
  76 static void _set_banner(IrrecoThemeUploadDlg *self,
  77                         const gchar *text,
  78                         gdouble fraction);
  79 static void _loader_start(IrrecoThemeUploadDlg *self);
  80 static void _loader_stop(IrrecoThemeUploadDlg *self);
  81
  82 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  83 /* Construction & Destruction                                                 */
  84 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  85
  86 /**
  87  * @name Construction & Destruction
  88  * @{
  89  */
  90
  91 G_DEFINE_TYPE(IrrecoThemeUploadDlg, irreco_theme_upload_dlg,
  92               IRRECO_TYPE_INTERNAL_DLG)
  93
  94 static void irreco_theme_upload_dlg_constructed(GObject *object)
  95 {
  96         IrrecoThemeUploadDlg *self;
  97
  98         GtkWidget *hbox_lr;
  99         GtkWidget *vbox_preview;
 100         GtkWidget *label_name;
 101         GtkWidget *label_comments;
 102         GtkWidget *label_preview;
 103         GtkWidget *scrolled_comments;
 104         GtkWidget *table;
 105         GtkWidget *frame_comments;
 106         GtkWidget *frame_preview;
 107
 108         IRRECO_ENTER
 109
 110         G_OBJECT_CLASS(irreco_theme_upload_dlg_parent_class)->constructed(object);
 111         self = IRRECO_THEME_UPLOAD_DLG(object);
 112
 113         self->comments = NULL;
 114
 115         /* Construct dialog. */
 116         gtk_window_set_title(GTK_WINDOW(self), _("Upload theme"));
 117         gtk_window_set_modal(GTK_WINDOW(self), TRUE);
 118         gtk_window_set_destroy_with_parent(GTK_WINDOW(self), TRUE);
 119         gtk_dialog_set_has_separator(GTK_DIALOG(self), FALSE);
 120         gtk_dialog_add_buttons(GTK_DIALOG(self),
 121                                GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 122                                GTK_STOCK_OK, GTK_RESPONSE_OK,
 123                                NULL);
 124
 125         /* Create widgets. */
 126         hbox_lr = gtk_hbox_new(FALSE, 10);
 127         vbox_preview = gtk_vbox_new(FALSE, 0);
 128         label_name = gtk_label_new("Theme name:");
 129         label_comments = gtk_label_new("Comments:   ");
 130         label_preview = gtk_label_new("Select\npreview image:");
 131         self->entry_name = gtk_entry_new();
 132         gtk_editable_set_editable(GTK_EDITABLE(self->entry_name), FALSE);
 133         self->textview_comments = gtk_text_view_new();
 134         frame_comments = gtk_frame_new(NULL);
 135
 136         /* preview */
 137         self->preview_image = gtk_image_new();
 138         gtk_image_set_from_file(GTK_IMAGE(self->preview_image), NULL);
 139         frame_preview = gtk_frame_new(NULL);
 140         self->preview_event_box = gtk_event_box_new();
 141         gtk_container_add(GTK_CONTAINER(frame_preview), self->preview_image);
 142         gtk_container_add(GTK_CONTAINER(self->preview_event_box), frame_preview);
 143         gtk_widget_set_size_request(frame_preview, 200,200);
 144
 145
 146         gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(self->textview_comments),
 147                                     GTK_WRAP_WORD_CHAR);
 148         gtk_widget_set_size_request(self->textview_comments, 400, 150);
 149         scrolled_comments = gtk_scrolled_window_new(NULL, NULL);
 150         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_comments),
 151                                        GTK_POLICY_NEVER,
 152                                        GTK_POLICY_AUTOMATIC);
 153         table = gtk_table_new(4, 2, FALSE);
 154
 155         /* Build dialog. */
 156         gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(self)->vbox),
 157                                     hbox_lr);
 158         gtk_box_pack_start_defaults(GTK_BOX(hbox_lr), table);
 159         gtk_box_pack_end_defaults(GTK_BOX(hbox_lr), vbox_preview);
 160         gtk_box_pack_start_defaults(GTK_BOX(vbox_preview), label_preview);
 161         gtk_box_pack_end_defaults(GTK_BOX(vbox_preview),
 162                                   self->preview_event_box);
 163         gtk_container_add(GTK_CONTAINER(scrolled_comments),
 164                           self->textview_comments);
 165         gtk_container_add(GTK_CONTAINER (frame_comments),
 166                           scrolled_comments);
 167         gtk_table_attach_defaults(GTK_TABLE(table),
 168                                   label_name, 0, 1, 0, 1);
 169         gtk_table_attach_defaults(GTK_TABLE(table),
 170                                   self->entry_name, 1, 2, 0, 1);
 171         gtk_table_attach_defaults(GTK_TABLE(table),
 172                                   label_comments, 0, 1, 1, 2);
 173         /*gtk_table_attach_defaults(GTK_TABLE(table),
 174                                   frame_comments, 0, 2, 2, 3);*/
 175         gtk_table_attach(GTK_TABLE(table),
 176                                   frame_comments,
 177                                   0, 2, 2, 3,
 178                                   GTK_EXPAND, GTK_EXPAND,
 179                                   5, 0);
 180         gtk_container_set_border_width (GTK_CONTAINER (self), 5);
 181
 182         /* Connect preview eventbox and start dialog from there */
 183         g_signal_connect(G_OBJECT(self->preview_event_box),
 184                          "button-release-event",
 185                          G_CALLBACK(_run_button_browser_dlg),
 186                          IRRECO_THEME_UPLOAD_DLG(self));
 187
 188         gtk_widget_show_all(GTK_WIDGET(self));
 189         IRRECO_RETURN
 190 }
 191
 192 static void irreco_theme_upload_dlg_init(IrrecoThemeUploadDlg *self)
 193 {
 194         IRRECO_ENTER
 195         IRRECO_RETURN
 196 }
 197
 198 static void irreco_theme_upload_dlg_finalize(GObject *object)
 199 {
 200         IrrecoThemeUploadDlg *self;
 201         IRRECO_ENTER
 202
 203         self = IRRECO_THEME_UPLOAD_DLG(object);
 204
 205         G_OBJECT_CLASS(irreco_theme_upload_dlg_parent_class)->finalize(object);
 206         IRRECO_RETURN
 207 }
 208
 209 static void irreco_theme_upload_dlg_class_init(IrrecoThemeUploadDlgClass *klass)
 210 {
 211         GObjectClass* object_class = G_OBJECT_CLASS (klass);
 212         /* IrrecoDlgClass* parent_class = IRRECO_DLG_CLASS (klass); */
 213
 214         object_class->finalize = irreco_theme_upload_dlg_finalize;
 215         object_class->constructed = irreco_theme_upload_dlg_constructed;
 216 }
 217
 218 GtkWidget *irreco_theme_upload_dlg_new(IrrecoData *irreco_data,
 219                                      GtkWindow *parent_window)
 220 {
 221         IrrecoThemeUploadDlg *self;
 222         IRRECO_ENTER
 223
 224         self = g_object_new(IRRECO_TYPE_THEME_UPLOAD_DLG,
 225                             "irreco-data", irreco_data,
 226                             NULL);
 227         irreco_dlg_set_parent(IRRECO_DLG(self), parent_window);
 228         IRRECO_RETURN_PTR(self);
 229 }
 230
 231 /** @} */
 232
 233
 234 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 235 /* Private Functions                                                          */
 236 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 237 /**
 238  * @name Private Functions
 239  * @{
 240  */
 241
 242 /**
 243  * Show hildon progressbar banner.
 244  *
 245  * This function will create a new banner if one has not been created yet,
 246  * if banner already exists, it's properties will be changed.
 247  *
 248  * @param text          Text to show.
 249  * @param fraction      Value of progress.
 250  */
 251 static void _set_banner(IrrecoThemeUploadDlg *self,
 252                                                 const gchar *text,
 253                                                 gdouble fraction)
 254 {
 255         IRRECO_ENTER
 256
 257         if (self->banner == NULL) {
 258                 self->banner = hildon_banner_show_progress(
 259                         GTK_WIDGET(self), NULL, "");
 260         }
 261
 262         hildon_banner_set_text(HILDON_BANNER(self->banner), text);
 263         hildon_banner_set_fraction(HILDON_BANNER(self->banner), fraction);
 264
 265         IRRECO_RETURN
 266 }
 267
 268 /**
 269  * Destroy banner, if it exists.
 270  */
 271 static void _hide_banner(IrrecoThemeUploadDlg *self)
 272 {
 273         IRRECO_ENTER
 274
 275         if (self->banner) {
 276                 gtk_widget_destroy(self->banner);
 277                 self->banner = NULL;
 278         }
 279
 280         IRRECO_RETURN
 281 }
 282
 283 /**
 284  * Start a loader state machine if one is not running already.
 285  */
 286 static void _loader_start(IrrecoThemeUploadDlg *self)
 287 {
 288         IRRECO_ENTER
 289
 290         if (self->loader_func_id == 0) {
 291                 self->loader_func_id = g_idle_add((GSourceFunc)_send_theme, self);
 292         }
 293
 294         IRRECO_RETURN
 295 }
 296
 297 /**
 298  * Stop and cleanup loader if a loader is running.
 299  */
 300 static void _loader_stop(IrrecoThemeUploadDlg *self)
 301 {
 302         IRRECO_ENTER
 303         _hide_banner(self);
 304         if (self->loader_func_id != 0) {
 305                 g_source_remove(self->loader_func_id);
 306                 self->loader_func_id = 0;
 307                 self->loader_state = 0;
 308         }
 309         IRRECO_RETURN
 310 }
 311
 312 /**
 313  * Check textfields, return TRUE if everythings fine
 314  */
 315 static gboolean _texts_ok(IrrecoThemeUploadDlg *self)
 316 {
 317         gboolean rvalue = TRUE;
 318         GtkTextIter startiter;
 319         GtkTextIter enditer;
 320
 321         IRRECO_ENTER
 322
 323         if (self->comments != NULL) g_free(self->comments);
 324
 325         gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(self->buffer_comments),
 326                                                                 &startiter);
 327         gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER(self->buffer_comments),
 328                                                                 &enditer);
 329         self->comments = gtk_text_buffer_get_text(
 330                                         GTK_TEXT_BUFFER(self->buffer_comments),
 331                                         &startiter,
 332                                         &enditer,
 333                                         FALSE);
 334         /* a Superb hack */
 335         if(strlen(self->comments) == 0) {
 336                 self->comments = " ";
 337                 IRRECO_DEBUG("No comment given, "
 338                              "using space to prevent DB failing\n");
 339         }
 340
 341         IRRECO_DEBUG("theme comments: %s\n", self->comments);
 342
 343         IRRECO_RETURN_BOOL(rvalue);
 344 }
 345
 346 /**
 347  * Upload theme confs and images, return TRUE if everything went fine
 348  */
 349 static gboolean _send_theme(IrrecoThemeUploadDlg *self)
 350 {
 351         IRRECO_ENTER
 352
 353         switch (self->loader_state) {
 354
 355         case LOADER_STATE_INIT:
 356
 357                 IRRECO_DEBUG("Loader state init\n");
 358
 359                 self->uploading_errors = FALSE;
 360                 self->client = irreco_webdb_client_new();
 361                 self->buffer_size =
 362                         irreco_webdb_client_get_max_image_size(self->client);
 363                 self->banner_max = irreco_string_table_lenght(
 364                                                 self->theme->buttons);
 365                 self->banner_max += irreco_string_table_lenght(
 366                                                 self->theme->backgrounds);
 367                 self->strtablesize = irreco_string_table_lenght(
 368                                                 self->theme->buttons);
 369                 self->strtableindex = 0;
 370                 _set_banner(self, _("Uploading theme..."), 0);
 371                 self->loader_state = LOADER_STATE_THEME;
 372
 373                 IRRECO_RETURN_BOOL(TRUE);
 374
 375         case LOADER_STATE_THEME: {
 376
 377                 gchar                   *parsedpath;
 378
 379                 IRRECO_DEBUG("Loader state theme\n");
 380
 381                 /* Parse folder out from theme path */
 382                 parsedpath = g_utf8_strrchr(self->theme->path->str,
 383                                             -1,
 384                                             G_DIR_SEPARATOR);
 385                 parsedpath = g_utf8_find_next_char(parsedpath, NULL);
 386
 387                 /* Create new theme */
 388                 self->themeindex = irreco_webdb_client_create_theme(
 389                                         self->client,
 390                                         /*self->theme_name,*/
 391                                         self->theme->name->str,
 392                                         self->comments,
 393                                         self->theme->preview_button_name->str,
 394                                         parsedpath,
 395                                         self->user,
 396                                         self->password);
 397
 398                 /* Abort if theme creation fails */
 399                 if(self->themeindex == 0) {
 400                         irreco_error_dlg(GTK_WINDOW(self),
 401                                          "Failed to create theme");
 402                         self->uploading_errors = TRUE;
 403                         _loader_stop(self);
 404                         self->uploading_started = FALSE;
 405                         IRRECO_RETURN_BOOL(FALSE);
 406                 }
 407
 408                 self->loader_state = LOADER_STATE_BUTTONS;
 409
 410                 IRRECO_RETURN_BOOL(TRUE);
 411         }
 412
 413         case LOADER_STATE_BUTTONS: {
 414
 415                 guchar *img_up_data = g_malloc0(self->buffer_size);
 416                 guchar *img_down_data = g_malloc0(self->buffer_size);
 417                 gchar *img_up_sha; /* SHAs */
 418                 gchar *img_down_sha;
 419                 gchar *img_up_name; /* filenames */
 420                 gchar *img_down_name;
 421                 gint img_up_len; /* img data lengths */
 422                 gint img_down_len;
 423                 GString *img_folder = g_string_new(NULL); /* folder of button */
 424                 gint button_index;
 425                 gchar *error_msg = NULL;
 426                 const gchar *key;
 427                 IrrecoThemeButton *button = NULL;
 428                 gfloat banner;
 429
 430                 IRRECO_DEBUG("Loader state buttons\n");
 431
 432                 irreco_string_table_index(self->theme->buttons,
 433                                           self->strtableindex, &key,
 434                                           (gpointer *) &button);
 435
 436                 if(button == NULL) {
 437                         IRRECO_DEBUG("No buttons\n");
 438                         goto cleanup_button;
 439                 }
 440
 441                 banner = (gfloat) self->strtableindex/(gfloat) self->banner_max;
 442
 443                 self->strtableindex++;
 444
 445                 _set_banner(self,
 446                             "Uploading buttons...",
 447                             banner);
 448
 449                 IRRECO_DEBUG("Current button: %s\n", button->name->str);
 450
 451                 /* button up sizecheck */
 452                 if(irreco_file_length(button->image_up->str) >=
 453                                       self->buffer_size) {
 454                         img_up_data = NULL;
 455                         img_up_sha = NULL;
 456                         img_up_name = NULL;
 457                         irreco_error_dlg(GTK_WINDOW(self),
 458                                          g_strdup_printf(
 459                                                 "Button %s image too large\n"
 460                                                 "Max allowed size: %d KiB",
 461                                                 button->name->str,
 462                                                 self->buffer_size/1024));
 463                         self->uploading_errors = TRUE;
 464                         goto cleanup_button;
 465                 }
 466
 467                 /* button up */
 468                 if(_get_image_data_and_hash(button->image_up->str,
 469                                             &img_up_data,
 470                                             &img_up_sha,
 471                                             &img_up_len,
 472                                             self->buffer_size,
 473                                             &error_msg)) {
 474
 475                         /* Parse folder out from theme img */
 476                         img_up_name = g_utf8_strrchr(button->image_up->str,
 477                                                     -1,
 478                                                     G_DIR_SEPARATOR);
 479                         img_up_name = g_utf8_find_next_char(img_up_name, NULL);
 480                 } else {
 481                         img_up_data = NULL;
 482                         img_up_sha = NULL;
 483                         img_up_name = NULL;
 484                         irreco_error_dlg(GTK_WINDOW(self), error_msg);
 485                         self->uploading_errors = TRUE;
 486                         goto cleanup_button;
 487                 }
 488
 489                 /* button down sizecheck */
 490                 if(irreco_file_length(button->image_down->str) >=
 491                                       self->buffer_size) {
 492                         img_down_data = NULL;
 493                         img_down_sha = NULL;
 494                         img_down_name = NULL;
 495                         irreco_error_dlg(GTK_WINDOW(self),
 496                                          g_strdup_printf(
 497                                                 "Button %s image too large\n"
 498                                                 "Max allowed size: %d KiB",
 499                                                 button->name->str,
 500                                                 self->buffer_size/1024));
 501                         self->uploading_errors = TRUE;
 502                         goto cleanup_button;
 503                 }
 504
 505                 /* button down */
 506                 if(_get_image_data_and_hash(button->image_down->str,
 507                                             &img_down_data,
 508                                             &img_down_sha,
 509                                             &img_down_len,
 510                                             self->buffer_size,
 511                                             &error_msg)) {
 512                         /* Parse folder out from theme img */
 513                         img_down_name = g_utf8_strrchr(button->image_down->str,
 514                                                     -1,
 515                                                     G_DIR_SEPARATOR);
 516                         img_down_name = g_utf8_find_next_char(img_down_name,
 517                                                               NULL);
 518                 } else {
 519                         img_down_data = NULL;
 520                         img_down_sha = NULL;
 521                         img_down_name = NULL;
 522                         IRRECO_DEBUG("No optional down button\n");
 523                 }
 524
 525                 /* Copy whole path+button name */
 526                 g_string_printf(img_folder, "%s", button->image_down->str);
 527                 /* Remove everything past and including rightmost folder char */
 528                 img_folder = g_string_erase(img_folder,
 529                                             strlen(button->image_down->str) -
 530                                             strlen(g_utf8_strrchr(
 531                                                         button->image_down->str,
 532                                                         -1,
 533                                                         G_DIR_SEPARATOR)),
 534                                             -1);
 535                 /* Remove everything prior rightmost folder character */
 536                 g_string_printf(img_folder, "%s", g_utf8_strrchr(img_folder->str,
 537                                                 -1,
 538                                                 G_DIR_SEPARATOR));
 539                 /* Remove starting folder character */
 540                 img_folder = g_string_erase(img_folder, 0, 1);
 541
 542                 /* Upload button */
 543                 button_index = irreco_webdb_client_add_button_to_theme(
 544                                                 self->client,
 545                                                 button->name->str,
 546                                                 button->allow_text,
 547                                                 button->text_format_up->str,
 548                                                 button->text_format_down->str,
 549                                                 button->text_padding,
 550                                                 img_up_sha,
 551                                                 img_up_name,
 552                                                 img_up_data,
 553                                                 img_up_len,
 554                                                 img_down_sha,
 555                                                 img_down_name,
 556                                                 img_down_data,
 557                                                 img_down_len,
 558                                                 img_folder->str,
 559                                                 self->themeindex,
 560                                                 self->user,
 561                                                 self->password);
 562
 563                 if(button_index == 0) {
 564                         irreco_error_dlg(GTK_WINDOW(self),
 565                                          g_strdup_printf(
 566                                                 "Button %s uploading failed",
 567                                                 button->name->str));
 568                         self->uploading_errors = TRUE;
 569                 }
 570
 571                 cleanup_button:
 572                 /* Free resources */
 573                 g_free(img_up_data);
 574                 img_up_data = NULL;
 575                 g_free(img_down_data);
 576                 img_down_data = NULL;
 577                 g_string_free(img_folder, TRUE);
 578                 img_folder = NULL;
 579
 580                 if(self->strtablesize == self->strtableindex ||
 581                    self->strtablesize == 0) {
 582                         self->strtablesize = irreco_string_table_lenght(self->theme->backgrounds);
 583                         self->strtableindex = 0;
 584                         self->loader_state = LOADER_STATE_BACKGROUNDS;
 585                         IRRECO_DEBUG("Next loader state backgrounds\n");
 586                 }
 587
 588                 IRRECO_RETURN_BOOL(TRUE);
 589         }
 590
 591         case LOADER_STATE_BACKGROUNDS: {
 592                 GString *img_folder = g_string_new(NULL);
 593                 guchar  *img_data = g_malloc0(self->buffer_size);
 594                 gchar   *img_sha;
 595                 gchar   *img_name;
 596                 gint    img_len;
 597                 gint    bg_index;
 598                 gchar   *error_msg;
 599                 const gchar     *key;
 600                 IrrecoThemeBg *bg = NULL;
 601                 gfloat banner;
 602
 603                 irreco_string_table_index(self->theme->backgrounds,
 604                                           self->strtableindex, &key,
 605                                           (gpointer *) &bg);
 606
 607                 if(bg == NULL) {
 608                         IRRECO_DEBUG("No backgrounds\n");
 609                         goto cleanup_bg;
 610                 }
 611
 612                 banner = (gfloat) (self->banner_max -
 613                                    self->strtablesize + self->strtableindex) /
 614                          (gfloat) self->banner_max;
 615
 616                 self->strtableindex++;
 617
 618                 _set_banner(self, "Uploading backgrounds...", banner);
 619
 620                 IRRECO_DEBUG("Current bg: %s\n", bg->image_name->str);
 621
 622                 /* backgrounds image sizecheck */
 623                 if(irreco_file_length(bg->image_path->str) >=
 624                                       self->buffer_size) {
 625                         img_data = NULL;
 626                         img_sha = NULL;
 627                         img_name = NULL;
 628                         irreco_error_dlg(GTK_WINDOW(self),
 629                                          g_strdup_printf(
 630                                                 "Background %s image too large\n"
 631                                                 "Max allowed size: %d KiB",
 632                                                 bg->image_name->str,
 633                                                 self->buffer_size/1024));
 634                         self->uploading_errors = TRUE;
 635                         goto cleanup_bg;
 636                 }
 637                 if(_get_image_data_and_hash(bg->image_path->str,
 638                                             &img_data,
 639                                             &img_sha,
 640                                             &img_len,
 641                                             self->buffer_size,
 642                                             &error_msg)) {
 643
 644                         /* Parse folder out from bg img path */
 645                         img_name = g_utf8_strrchr(bg->image_path->str,
 646                                                     -1,
 647                                                     G_DIR_SEPARATOR);
 648                         img_name = g_utf8_find_next_char(img_name, NULL);
 649                 } else {
 650                         img_data = NULL;
 651                         img_sha = NULL;
 652                         img_name = NULL;
 653                         irreco_error_dlg(GTK_WINDOW(self), error_msg);
 654                         self->uploading_errors = TRUE;
 655                         goto cleanup_bg;
 656                 }
 657
 658                 /* Copy whole path+bg name */
 659                 g_string_printf(img_folder, "%s", bg->image_path->str);
 660                 /* Remove everything past and including rightmost folder char */
 661                 img_folder = g_string_erase(img_folder,
 662                                             strlen(bg->image_path->str) -
 663                                             strlen(g_utf8_strrchr(
 664                                                         bg->image_path->str,
 665                                                         -1,
 666                                                         G_DIR_SEPARATOR)),
 667                                             -1);
 668                 /* Remove everything prior rightmost folder character */
 669                 g_string_printf(img_folder, "%s", g_utf8_strrchr(img_folder->str,
 670                                                 -1,
 671                                                 G_DIR_SEPARATOR));
 672                 /* Remove starting folder character */
 673                 img_folder = g_string_erase(img_folder, 0, 1);
 674
 675                 if(img_len >= self->buffer_size) {
 676                         irreco_error_dlg(GTK_WINDOW(self),
 677                                          g_strdup_printf(
 678                                                 "Bg %s image too large",
 679                                                 bg->image_name->str));
 680                         self->uploading_errors = TRUE;
 681                         goto cleanup_bg;
 682                 }
 683
 684                 bg_index = irreco_webdb_client_add_bg_to_theme(
 685                                                         self->client,
 686                                                         bg->image_name->str,
 687                                                         img_sha,
 688                                                         img_name,
 689                                                         img_data,
 690                                                         img_len,
 691                                                         img_folder->str,
 692                                                         self->themeindex,
 693                                                         self->user,
 694                                                         self->password);
 695                 if(bg_index == 0) {
 696                         irreco_error_dlg(GTK_WINDOW(self),
 697                                          g_strdup_printf(
 698                                                 "Bg %s uploading failed",
 699                                                 bg->image_name->str));
 700                         self->uploading_errors = TRUE;
 701                 }
 702
 703                 cleanup_bg:
 704                 g_free(img_data);
 705                 img_data = NULL;
 706                 g_string_free(img_folder, TRUE);
 707                 img_folder = NULL;
 708
 709                 if(self->strtablesize == self->strtableindex ||
 710                    self->strtablesize == 0) {
 711                         self->loader_state = LOADER_STATE_END;
 712                         IRRECO_DEBUG("Next loader state end\n");
 713                 }
 714
 715                 IRRECO_RETURN_BOOL(TRUE);
 716         }
 717
 718         case LOADER_STATE_END:
 719
 720                 _hide_banner(self);
 721                 if(!self->uploading_errors) {
 722                         if(!irreco_webdb_client_set_theme_downloadable(
 723                                                         self->client,
 724                                                         self->themeindex,
 725                                                         TRUE,
 726                                                         self->user,
 727                                                         self->password)) {
 728                                 irreco_error_dlg(GTK_WINDOW(self),
 729                                          "Failed to make theme downloadable.\n"
 730                                          "Theme won't show at database.");
 731                                 self->uploading_errors = TRUE;
 732                         } else {
 733                                 irreco_info_dlg(GTK_WINDOW(self),
 734                                         "Theme uploaded successfully");
 735                         }
 736                 } else {
 737                         irreco_error_dlg(GTK_WINDOW(self),
 738                                         "Some error(s) occured during upload.\n"
 739                                         "Please try again.");
 740                         _loader_stop(self);
 741                         IRRECO_RETURN_BOOL(FALSE);
 742                 }
 743                 self->uploading_started = FALSE;
 744                 gtk_dialog_response(GTK_DIALOG(self), GTK_RESPONSE_CLOSE);
 745
 746                 IRRECO_RETURN_BOOL(FALSE);
 747         }
 748
 749         IRRECO_DEBUG("Oh no, shouldn't ever be here\n");
 750         IRRECO_RETURN_BOOL(FALSE);
 751 }
 752
 753 /**
 754  * Retrieves image data and hash of given file
 755  *
 756  * @param img_path Path to file containing binary data
 757  * @param img_data Set to contain read binary data
 758  * @param img_sha Set to contain sha1 of data
 759  * @param img_data_len Set to contain length of data
 760  * @param buffer_size Max length of data to read
 761  * @param error_msg Set to contain error message, if error occurs
 762  * @return True upon success, false otherwise
 763  */
 764 static gboolean _get_image_data_and_hash(gchar *img_path,
 765                                          guchar **img_data,
 766                                          gchar **img_sha,
 767                                          gint *img_data_len,
 768                                          gsize buffer_size,
 769                                          gchar **error_msg)
 770 {
 771         gboolean rvalue = TRUE;
 772
 773         IRRECO_ENTER
 774
 775         if(irreco_file_exists(img_path)) {
 776                 if(irreco_read_binary_file(img_path,
 777                                             *img_data,
 778                                             buffer_size,
 779                                             img_data_len)) {
 780                         *img_sha = sha_compute_checksum_for_data(
 781                                                                 G_CHECKSUM_SHA1,
 782                                                                 *img_data,
 783                                                                 *img_data_len);
 784                 } else {
 785                         IRRECO_DEBUG("File read failed\n");
 786                         *error_msg = "File read failed\n";
 787                         rvalue = FALSE;
 788                 }
 789         } else {
 790                 IRRECO_DEBUG("No such file\n");
 791                 *error_msg = "No such file\n";
 792                 rvalue = FALSE;
 793         }
 794
 795         IRRECO_RETURN_BOOL(rvalue)
 796
 797 }
 798
 799 /**
 800  * Update shown preview image
 801  */
 802 static void _update_preview(IrrecoThemeUploadDlg *self)
 803 {
 804         IRRECO_ENTER
 805
 806         /* if theme contains preview image, use it, else get first button */
 807         if(self->preview_name) {
 808                 IRRECO_DEBUG("Preview set in dlg, using it\n");
 809         } else if(strlen(self->theme->preview_button_name->str) != 0) {
 810                 gchar *strtblkey;
 811                 IRRECO_DEBUG("Preview set to theme, using it\n");
 812                 strtblkey = g_strdup_printf("%s/%s", self->theme->name->str,
 813                                 self->theme->preview_button_name->str);
 814                 /*IRRECO_DEBUG("key: %s\n", strtblkey);*/
 815                 if(irreco_string_table_get(self->theme->buttons,
 816                                            strtblkey,
 817                                            (gpointer *) &self->preview_button)) {
 818                         self->preview_name = self->preview_button->image_up->str;
 819                 } else {
 820                         IRRECO_DEBUG("Theme preview set wrong\n");
 821                 }
 822         } else {
 823                 const gchar *key;
 824                 IRRECO_DEBUG("No preview set, using first button of theme\n");
 825                 irreco_string_table_index(self->theme->buttons,
 826                                           0, &key,
 827                                           (gpointer *) &self->preview_button);
 828                 if(self->preview_button) {
 829                         self->preview_name = self->preview_button->image_up->str;
 830                 }
 831         }
 832
 833         gtk_image_set_from_file(GTK_IMAGE(self->preview_image),
 834                                   self->preview_name);
 835
 836         gtk_widget_show_all(GTK_WIDGET(self));
 837
 838         IRRECO_RETURN
 839 }
 840
 841 /** @} */
 842
 843
 844 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 845 /* Public Functions                                                           */
 846 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 847
 848 /**
 849  * Show dialog, and ask user for input.
 850  * @param irreco_data Irreco data
 851  * @param irreco_theme IrrecoTheme to be uploaded
 852  */
 853 gboolean irreco_theme_upload_dlg_run(GtkWindow *parent_window,
 854                                      IrrecoData *irreco_data,
 855                                      IrrecoTheme * irreco_theme)
 856 {
 857         IrrecoThemeUploadDlg *self;
 858         gint            response;
 859         gboolean        loop = TRUE;
 860
 861         IRRECO_ENTER
 862
 863         if(irreco_theme == NULL) { IRRECO_RETURN_BOOL(FALSE); }
 864
 865         self = (IrrecoThemeUploadDlg*)irreco_theme_upload_dlg_new(irreco_data,
 866                                                                   parent_window);
 867
 868         self->parent_window = GTK_WINDOW(self);
 869         self->irreco_data = irreco_data;
 870         self->theme = irreco_theme;
 871         self->preview_name = NULL;
 872         self->uploading_started = FALSE;
 873         self->loader_func_id = 0;
 874
 875         /* set things to dialog, cause theme & data wasn't set @ _constructed */
 876         gtk_entry_set_text(GTK_ENTRY(self->entry_name), self->theme->name->str);
 877         self->buffer_comments = gtk_text_view_get_buffer(
 878                                         GTK_TEXT_VIEW(self->textview_comments));
 879         gtk_text_buffer_set_text(GTK_TEXT_BUFFER(self->buffer_comments),
 880                                  self->theme->comment->str,
 881                                  -1);
 882         _update_preview(self);
 883
 884         do {
 885                 response = gtk_dialog_run(GTK_DIALOG(self));
 886                 switch (response) {
 887                 case GTK_RESPONSE_OK:
 888                         IRRECO_DEBUG("GTK_RESPONSE_OK\n");
 889
 890                         if(self->uploading_started) {
 891                                 IRRECO_DEBUG("Already uploading theme\n");
 892                                 break;
 893                         }
 894
 895                         /* Check themename length and get texts */
 896                         if(!_texts_ok(self)) {
 897                                 IRRECO_DEBUG("Input failure\n");
 898                                 break;
 899                         }
 900
 901                         /* Show login/reg dialog */
 902                         if(!irreco_show_login_dlg(irreco_data,
 903                                                   parent_window,
 904                                                   &self->user,
 905                                                   &self->password)) {
 906                                 IRRECO_DEBUG("Failed login\n");
 907                                 break;
 908                         }
 909
 910                         /* set new info to theme */
 911                         irreco_theme_set_author(self->theme, self->user);
 912                         irreco_theme_set_comment(self->theme, self->comments);
 913                         irreco_theme_set_preview_button(self->theme,
 914                                         self->preview_button->name->str);
 915
 916                         self->uploading_started = TRUE;
 917                         self->loader_state = LOADER_STATE_INIT;
 918                         IRRECO_DEBUG("Start loader\n");
 919                         _loader_start(self);
 920
 921                         break;
 922
 923                 case GTK_RESPONSE_CANCEL:
 924                         IRRECO_DEBUG("GTK_RESPONSE_CANCEL\n");
 925                         _loader_stop(self);
 926                         if(self->uploading_started) {
 927                                 irreco_info_dlg(GTK_WINDOW(self),
 928                                                 "Theme uploading aborted");
 929                         }
 930                         loop = FALSE;
 931                         break;
 932
 933                 case GTK_RESPONSE_CLOSE:
 934                         IRRECO_DEBUG("GTK_RESPONSE_CLOSE\n");
 935                         _loader_stop(self);
 936                         loop = FALSE;
 937                         break;
 938
 939                 default:
 940                         IRRECO_DEBUG("Something went horribly wrong\n");
 941                         break;
 942                 }
 943
 944         } while (loop);
 945
 946         gtk_widget_destroy(GTK_WIDGET(self));
 947
 948         IRRECO_RETURN_BOOL(FALSE);
 949 }
 950
 951 /** @} */
 952
 953
 954
 955 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 956 /* Events and Callbacks                                                       */
 957 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 958
 959 /**
 960  * @name Events and Callbacks
 961  * @{
 962  */
 963
 964 /**
 965  * Run button browser where one button can be selected
 966  * Stores selected buttons name and buttonstructure
 967  */
 968 static void _run_button_browser_dlg(GtkWidget *widget,
 969                                     GdkEventButton *event,
 970                                     IrrecoThemeUploadDlg *self)
 971 {
 972         IrrecoThemeButton *preview_theme_button = NULL;
 973
 974         IRRECO_ENTER
 975
 976         preview_theme_button = irreco_button_browser_dlg_run(
 977                         GTK_WINDOW(IRRECO_THEME_UPLOAD_DLG(self)->parent_window),
 978                         self->irreco_data,
 979                         self->theme);
 980
 981         if(preview_theme_button) {
 982                 IRRECO_DEBUG("Set preview button to theme and self->\n");
 983                 self->preview_name = preview_theme_button->image_up->str;
 984                 self->preview_button = preview_theme_button;
 985                 _update_preview(self);
 986         }
 987
 988         IRRECO_RETURN
 989 }
 990
 991 /** @} */
 992
 993
 994
 995 /** @} */