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                                                 button->text_h_align,
 551                                                 button->text_v_align,
 552                                                 img_up_sha,
 553                                                 img_up_name,
 554                                                 img_up_data,
 555                                                 img_up_len,
 556                                                 img_down_sha,
 557                                                 img_down_name,
 558                                                 img_down_data,
 559                                                 img_down_len,
 560                                                 img_folder->str,
 561                                                 self->themeindex,
 562                                                 self->user,
 563                                                 self->password);
 564
 565                 if(button_index == 0) {
 566                         irreco_error_dlg(GTK_WINDOW(self),
 567                                          g_strdup_printf(
 568                                                 "Button %s uploading failed",
 569                                                 button->name->str));
 570                         self->uploading_errors = TRUE;
 571                 }
 572
 573                 cleanup_button:
 574                 /* Free resources */
 575                 g_free(img_up_data);
 576                 img_up_data = NULL;
 577                 g_free(img_down_data);
 578                 img_down_data = NULL;
 579                 g_string_free(img_folder, TRUE);
 580                 img_folder = NULL;
 581
 582                 if(self->strtablesize == self->strtableindex ||
 583                    self->strtablesize == 0) {
 584                         self->strtablesize = irreco_string_table_lenght(
 585                                                       self->theme->backgrounds);
 586                         self->strtableindex = 0;
 587                         self->loader_state = LOADER_STATE_BACKGROUNDS;
 588                         IRRECO_DEBUG("Next loader state backgrounds\n");
 589                 }
 590
 591                 IRRECO_RETURN_BOOL(TRUE);
 592         }
 593
 594         case LOADER_STATE_BACKGROUNDS: {
 595                 GString *img_folder = g_string_new(NULL);
 596                 guchar  *img_data = g_malloc0(self->buffer_size);
 597                 gchar   *img_sha;
 598                 gchar   *img_name;
 599                 gint    img_len;
 600                 gint    bg_index;
 601                 gchar   *error_msg;
 602                 const gchar     *key;
 603                 IrrecoThemeBg *bg = NULL;
 604                 gfloat banner;
 605
 606                 irreco_string_table_index(self->theme->backgrounds,
 607                                           self->strtableindex, &key,
 608                                           (gpointer *) &bg);
 609
 610                 if(bg == NULL) {
 611                         IRRECO_DEBUG("No backgrounds\n");
 612                         goto cleanup_bg;
 613                 }
 614
 615                 banner = (gfloat) (self->banner_max -
 616                                    self->strtablesize + self->strtableindex) /
 617                          (gfloat) self->banner_max;
 618
 619                 self->strtableindex++;
 620
 621                 _set_banner(self, "Uploading backgrounds...", banner);
 622
 623                 IRRECO_DEBUG("Current bg: %s\n", bg->image_name->str);
 624
 625                 /* backgrounds image sizecheck */
 626                 if(irreco_file_length(bg->image_path->str) >=
 627                                       self->buffer_size) {
 628                         img_data = NULL;
 629                         img_sha = NULL;
 630                         img_name = NULL;
 631                         irreco_error_dlg(GTK_WINDOW(self),
 632                                          g_strdup_printf(
 633                                                 "Background %s image too large\n"
 634                                                 "Max allowed size: %d KiB",
 635                                                 bg->image_name->str,
 636                                                 self->buffer_size/1024));
 637                         self->uploading_errors = TRUE;
 638                         goto cleanup_bg;
 639                 }
 640                 if(_get_image_data_and_hash(bg->image_path->str,
 641                                             &img_data,
 642                                             &img_sha,
 643                                             &img_len,
 644                                             self->buffer_size,
 645                                             &error_msg)) {
 646
 647                         /* Parse folder out from bg img path */
 648                         img_name = g_utf8_strrchr(bg->image_path->str,
 649                                                     -1,
 650                                                     G_DIR_SEPARATOR);
 651                         img_name = g_utf8_find_next_char(img_name, NULL);
 652                 } else {
 653                         img_data = NULL;
 654                         img_sha = NULL;
 655                         img_name = NULL;
 656                         irreco_error_dlg(GTK_WINDOW(self), error_msg);
 657                         self->uploading_errors = TRUE;
 658                         goto cleanup_bg;
 659                 }
 660
 661                 /* Copy whole path+bg name */
 662                 g_string_printf(img_folder, "%s", bg->image_path->str);
 663                 /* Remove everything past and including rightmost folder char */
 664                 img_folder = g_string_erase(img_folder,
 665                                             strlen(bg->image_path->str) -
 666                                             strlen(g_utf8_strrchr(
 667                                                         bg->image_path->str,
 668                                                         -1,
 669                                                         G_DIR_SEPARATOR)),
 670                                             -1);
 671                 /* Remove everything prior rightmost folder character */
 672                 g_string_printf(img_folder, "%s", g_utf8_strrchr(img_folder->str,
 673                                                 -1,
 674                                                 G_DIR_SEPARATOR));
 675                 /* Remove starting folder character */
 676                 img_folder = g_string_erase(img_folder, 0, 1);
 677
 678                 if(img_len >= self->buffer_size) {
 679                         irreco_error_dlg(GTK_WINDOW(self),
 680                                          g_strdup_printf(
 681                                                 "Bg %s image too large",
 682                                                 bg->image_name->str));
 683                         self->uploading_errors = TRUE;
 684                         goto cleanup_bg;
 685                 }
 686
 687                 bg_index = irreco_webdb_client_add_bg_to_theme(
 688                                                         self->client,
 689                                                         bg->image_name->str,
 690                                                         img_sha,
 691                                                         img_name,
 692                                                         img_data,
 693                                                         img_len,
 694                                                         img_folder->str,
 695                                                         self->themeindex,
 696                                                         self->user,
 697                                                         self->password);
 698                 if(bg_index == 0) {
 699                         irreco_error_dlg(GTK_WINDOW(self),
 700                                          g_strdup_printf(
 701                                                 "Bg %s uploading failed",
 702                                                 bg->image_name->str));
 703                         self->uploading_errors = TRUE;
 704                 }
 705
 706                 cleanup_bg:
 707                 g_free(img_data);
 708                 img_data = NULL;
 709                 g_string_free(img_folder, TRUE);
 710                 img_folder = NULL;
 711
 712                 if(self->strtablesize == self->strtableindex ||
 713                    self->strtablesize == 0) {
 714                         self->loader_state = LOADER_STATE_END;
 715                         IRRECO_DEBUG("Next loader state end\n");
 716                 }
 717
 718                 IRRECO_RETURN_BOOL(TRUE);
 719         }
 720
 721         case LOADER_STATE_END:
 722
 723                 _hide_banner(self);
 724                 if(!self->uploading_errors) {
 725                         if(!irreco_webdb_client_set_theme_downloadable(
 726                                                         self->client,
 727                                                         self->themeindex,
 728                                                         TRUE,
 729                                                         self->user,
 730                                                         self->password)) {
 731                                 irreco_error_dlg(GTK_WINDOW(self),
 732                                          "Failed to make theme downloadable.\n"
 733                                          "Theme won't show at database.");
 734                                 self->uploading_errors = TRUE;
 735                         } else {
 736                                 irreco_info_dlg(GTK_WINDOW(self),
 737                                         "Theme uploaded successfully");
 738                         }
 739                 } else {
 740                         irreco_error_dlg(GTK_WINDOW(self),
 741                                         "Some error(s) occured during upload.\n"
 742                                         "Please try again.");
 743                         _loader_stop(self);
 744                         self->uploading_started = FALSE;
 745                         IRRECO_RETURN_BOOL(FALSE);
 746                 }
 747                 self->uploading_started = FALSE;
 748                 gtk_dialog_response(GTK_DIALOG(self), GTK_RESPONSE_CLOSE);
 749                 IRRECO_RETURN_BOOL(FALSE);
 750         }
 751
 752         IRRECO_DEBUG("Oh no, shouldn't ever be here\n");
 753         IRRECO_RETURN_BOOL(FALSE);
 754 }
 755
 756 /**
 757  * Retrieves image data and hash of given file
 758  *
 759  * @param img_path Path to file containing binary data
 760  * @param img_data Set to contain read binary data
 761  * @param img_sha Set to contain sha1 of data
 762  * @param img_data_len Set to contain length of data
 763  * @param buffer_size Max length of data to read
 764  * @param error_msg Set to contain error message, if error occurs
 765  * @return True upon success, false otherwise
 766  */
 767 static gboolean _get_image_data_and_hash(gchar *img_path,
 768                                          guchar **img_data,
 769                                          gchar **img_sha,
 770                                          gint *img_data_len,
 771                                          gsize buffer_size,
 772                                          gchar **error_msg)
 773 {
 774         gboolean rvalue = TRUE;
 775
 776         IRRECO_ENTER
 777
 778         if(irreco_file_exists(img_path)) {
 779                 if(irreco_read_binary_file(img_path,
 780                                             *img_data,
 781                                             buffer_size,
 782                                             img_data_len)) {
 783                         *img_sha = sha_compute_checksum_for_data(
 784                                                                 G_CHECKSUM_SHA1,
 785                                                                 *img_data,
 786                                                                 *img_data_len);
 787                 } else {
 788                         IRRECO_DEBUG("File read failed\n");
 789                         *error_msg = "File read failed\n";
 790                         rvalue = FALSE;
 791                 }
 792         } else {
 793                 IRRECO_DEBUG("No such file\n");
 794                 *error_msg = "No such file\n";
 795                 rvalue = FALSE;
 796         }
 797
 798         IRRECO_RETURN_BOOL(rvalue)
 799
 800 }
 801
 802 /**
 803  * Update shown preview image
 804  */
 805 static void _update_preview(IrrecoThemeUploadDlg *self)
 806 {
 807         IRRECO_ENTER
 808
 809         /* if theme contains preview image, use it, else get first button */
 810         if(self->preview_name) {
 811                 IRRECO_DEBUG("Preview set in dlg, using it\n");
 812         } else if(strlen(self->theme->preview_button_name->str) != 0) {
 813                 gchar *strtblkey;
 814                 IRRECO_DEBUG("Preview set to theme, using it\n");
 815                 strtblkey = g_strdup_printf("%s/%s", self->theme->name->str,
 816                                 self->theme->preview_button_name->str);
 817                 /*IRRECO_DEBUG("key: %s\n", strtblkey);*/
 818                 if(irreco_string_table_get(self->theme->buttons,
 819                                            strtblkey,
 820                                            (gpointer *) &self->preview_button)) {
 821                         self->preview_name = self->preview_button->image_up->str;
 822                 } else {
 823                         IRRECO_DEBUG("Theme preview set wrong\n");
 824                 }
 825         } else {
 826                 const gchar *key;
 827                 IRRECO_DEBUG("No preview set, using first button of theme\n");
 828                 irreco_string_table_index(self->theme->buttons,
 829                                           0, &key,
 830                                           (gpointer *) &self->preview_button);
 831                 if(self->preview_button) {
 832                         self->preview_name = self->preview_button->image_up->str;
 833                 }
 834         }
 835
 836         gtk_image_set_from_file(GTK_IMAGE(self->preview_image),
 837                                   self->preview_name);
 838
 839         gtk_widget_show_all(GTK_WIDGET(self));
 840
 841         IRRECO_RETURN
 842 }
 843
 844 /** @} */
 845
 846
 847 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 848 /* Public Functions                                                           */
 849 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 850
 851 /**
 852  * Show dialog, and ask user for input.
 853  * @param irreco_data Irreco data
 854  * @param irreco_theme IrrecoTheme to be uploaded
 855  */
 856 gboolean irreco_theme_upload_dlg_run(GtkWindow *parent_window,
 857                                      IrrecoData *irreco_data,
 858                                      IrrecoTheme * irreco_theme)
 859 {
 860         IrrecoThemeUploadDlg *self;
 861         gint            response;
 862         gboolean        loop = TRUE;
 863         gboolean        rvalue = FALSE;
 864
 865         IRRECO_ENTER
 866
 867         if(irreco_theme == NULL) { IRRECO_RETURN_BOOL(FALSE); }
 868
 869         self = (IrrecoThemeUploadDlg*)irreco_theme_upload_dlg_new(irreco_data,
 870                                                                   parent_window);
 871
 872         self->parent_window = GTK_WINDOW(self);
 873         self->irreco_data = irreco_data;
 874         self->theme = irreco_theme;
 875         self->preview_name = NULL;
 876         self->uploading_started = FALSE;
 877         self->loader_func_id = 0;
 878
 879         /* set things to dialog, cause theme & data wasn't set @ _constructed */
 880         gtk_entry_set_text(GTK_ENTRY(self->entry_name), self->theme->name->str);
 881         self->buffer_comments = gtk_text_view_get_buffer(
 882                                         GTK_TEXT_VIEW(self->textview_comments));
 883         gtk_text_buffer_set_text(GTK_TEXT_BUFFER(self->buffer_comments),
 884                                  self->theme->comment->str,
 885                                  -1);
 886         _update_preview(self);
 887
 888         do {
 889                 response = gtk_dialog_run(GTK_DIALOG(self));
 890                 switch (response) {
 891                 case GTK_RESPONSE_OK:
 892                         IRRECO_DEBUG("GTK_RESPONSE_OK\n");
 893
 894                         if(self->uploading_started) {
 895                                 IRRECO_DEBUG("Already uploading theme\n");
 896                                 break;
 897                         }
 898
 899                         /* Check themename length and get texts */
 900                         if(!_texts_ok(self)) {
 901                                 IRRECO_DEBUG("Input failure\n");
 902                                 break;
 903                         }
 904
 905                         /* Show login/reg dialog */
 906                         if(!irreco_show_login_dlg(irreco_data,
 907                                                   parent_window,
 908                                                   &self->user,
 909                                                   &self->password)) {
 910                                 IRRECO_DEBUG("Failed login\n");
 911                                 break;
 912                         }
 913
 914                         /* set new info to theme */
 915                         irreco_theme_set_author(self->theme, self->user);
 916                         irreco_theme_set_comment(self->theme, self->comments);
 917                         if(!self->preview_button) {
 918                                 irreco_error_dlg(GTK_WINDOW(self),
 919                                         "Please select preview image first");
 920                                 break;
 921                         }
 922                         irreco_theme_set_preview_button(self->theme,
 923                                         self->preview_button->name->str);
 924                         self->uploading_started = TRUE;
 925                         self->loader_state = LOADER_STATE_INIT;
 926                         IRRECO_DEBUG("Start loader\n");
 927                         _loader_start(self);
 928
 929                         break;
 930
 931                 case GTK_RESPONSE_CANCEL:
 932                         IRRECO_DEBUG("GTK_RESPONSE_CANCEL\n");
 933                         _loader_stop(self);
 934                         if(self->uploading_started) {
 935                                 irreco_info_dlg(GTK_WINDOW(self),
 936                                                 "Theme uploading aborted");
 937                         }
 938                         loop = FALSE;
 939                         break;
 940
 941                 case GTK_RESPONSE_CLOSE:
 942                         IRRECO_DEBUG("GTK_RESPONSE_CLOSE\n");
 943                         _loader_stop(self);
 944                         loop = FALSE;
 945                         rvalue = TRUE;
 946                         break;
 947
 948                 default:
 949                         IRRECO_DEBUG("Something went horribly wrong\n");
 950                         break;
 951                 }
 952
 953         } while (loop);
 954
 955         gtk_widget_destroy(GTK_WIDGET(self));
 956
 957         IRRECO_RETURN_BOOL(rvalue);
 958 }
 959
 960 /** @} */
 961
 962
 963
 964 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 965 /* Events and Callbacks                                                       */
 966 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 967
 968 /**
 969  * @name Events and Callbacks
 970  * @{
 971  */
 972
 973 /**
 974  * Run button browser where one button can be selected
 975  * Stores selected buttons name and buttonstructure
 976  */
 977 static void _run_button_browser_dlg(GtkWidget *widget,
 978                                     GdkEventButton *event,
 979                                     IrrecoThemeUploadDlg *self)
 980 {
 981         IrrecoThemeButton *preview_theme_button = NULL;
 982
 983         IRRECO_ENTER
 984
 985         preview_theme_button = irreco_button_browser_dlg_run(
 986                         GTK_WINDOW(IRRECO_THEME_UPLOAD_DLG(self)->parent_window),
 987                         self->irreco_data,
 988                         self->theme);
 989
 990         if(preview_theme_button) {
 991                 IRRECO_DEBUG("Set preview button to theme and self->\n");
 992                 self->preview_name = preview_theme_button->image_up->str;
 993                 self->preview_button = preview_theme_button;
 994                 _update_preview(self);
 995         }
 996
 997         IRRECO_RETURN
 998 }
 999
1000 /** @} */
1001
1002
1003
1004 /** @} */