src/gui/lbxgui.c

   1 /*
   2  *  2ooM: The Master of Orion II Reverse Engineering Project
   3  *  Graphical tool for inspecting LBX archives.
   4  *  Copyright (C) 2010 Nick Bowler
   5  *
   6  *  This program is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include <config.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <math.h>
  23
  24 #include <gtk/gtk.h>
  25
  26 #include "lbx.h"
  27 #include "image.h"
  28 #include "render.h"
  29
  30 #include "bg.xbm"
  31
  32 static GtkTreeStore *archives;
  33 static GtkBuilder *builder;
  34
  35 static GtkWidget *canvas;
  36 static GdkGC     *bg_gc;
  37
  38 static struct lbx_image *image;
  39
  40 static GdkPixbuf *framebuf;
  41
  42 void play_toggled(GtkToggleButton *button, gpointer data)
  43 {
  44         gboolean active = gtk_toggle_button_get_active(button);
  45         GtkWidget *spin;
  46
  47         if (active && !image) {
  48                 gtk_toggle_button_set_active(button, FALSE);
  49                 return;
  50         }
  51
  52         spin = GTK_WIDGET(gtk_builder_get_object(builder, "framespin"));
  53         gtk_widget_set_sensitive(spin, !active);
  54
  55         if (active) {
  56                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
  57         }
  58 }
  59
  60 void set_frame(GtkSpinButton *spin, gpointer data)
  61 {
  62         unsigned frame = gtk_spin_button_get_value_as_int(spin);
  63
  64         if (image && framebuf)
  65                 render_to_pixbuf(image, framebuf, frame);
  66         gdk_window_invalidate_rect(canvas->window, NULL, FALSE);
  67 }
  68
  69 static void redraw_image(void)
  70 {
  71         GtkSpinButton *spin;
  72
  73         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
  74         set_frame(spin, NULL);
  75 }
  76
  77 static void tick(void *p, double delta)
  78 {
  79         static double elapsed = 0;
  80         double seconds_per_frame = 1.0/15;
  81         struct lbx_imginfo info;
  82         GtkSpinButton   *spin;
  83         GtkToggleButton *play;
  84         unsigned frame, newframe;
  85
  86         if (!image)
  87                 return;
  88
  89         lbx_img_getinfo(image, &info);
  90         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
  91         play = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "playbutton"));
  92
  93         frame = gtk_spin_button_get_value_as_int(spin);
  94         if (!gtk_toggle_button_get_active(play))
  95                 return;
  96
  97         elapsed += delta;
  98         newframe = frame;
  99         while (elapsed > seconds_per_frame) {
 100                 elapsed -= seconds_per_frame;
 101
 102                 if (++newframe >= image->frames) {
 103                         if (!info.looping) {
 104                                 gtk_toggle_button_set_active(play, FALSE);
 105                                 break;
 106                         }
 107
 108                         newframe = info.loopstart;
 109                 }
 110         }
 111
 112         if (frame != newframe)
 113                 gtk_spin_button_set_value(spin, newframe);
 114 }
 115
 116 static gboolean timeout(gpointer data)
 117 {
 118         static double lasttime = INFINITY;
 119         static GTimer *timer;
 120
 121         if (isinf(lasttime)) {
 122                 timer = g_timer_new();
 123                 if (timer) {
 124                         lasttime = 0;
 125                 }
 126         } else {
 127                 double time = g_timer_elapsed(timer, NULL);
 128
 129                 tick(data, time - lasttime);
 130                 lasttime = time;
 131         }
 132
 133         return TRUE;
 134 }
 135
 136 gboolean canvas_expose(GtkWidget *canvas, GdkEventExpose *event, gpointer data)
 137 {
 138         if (!framebuf)
 139                 return FALSE;
 140
 141         gdk_draw_rectangle(canvas->window, bg_gc, TRUE,
 142                 event->area.x, event->area.y,
 143                 event->area.width, event->area.height);
 144
 145         gdk_draw_pixbuf(canvas->window, NULL, framebuf,
 146                 event->area.x, event->area.y, event->area.x, event->area.y,
 147                 event->area.width, event->area.height,
 148                 GDK_RGB_DITHER_NORMAL, 0, 0);
 149
 150         return TRUE;
 151 }
 152
 153 static int alloc_framebuffer(struct lbx_image *image)
 154 {
 155         GtkSpinButton *spin;
 156
 157         if (framebuf)
 158                 g_object_unref(framebuf);
 159
 160         framebuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8,
 161                 image->width, image->height);
 162         g_return_val_if_fail(framebuf, -1);
 163
 164         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
 165         gtk_spin_button_set_range(spin, 0, image->frames-1);
 166         gtk_spin_button_set_value(spin, 0);
 167
 168         gtk_widget_set_size_request(canvas, image->width, image->height);
 169         return 0;
 170 }
 171
 172 static int close_image(void *handle)
 173 {
 174         lbx_file_close(handle);
 175         return 0;
 176 }
 177
 178 static struct lbx_image *load_lbx_image(struct lbx *archive, unsigned index)
 179 {
 180         LBXfile *file;
 181         struct lbx_image *image;
 182
 183         file = lbx_file_open(archive, index);
 184         g_return_val_if_fail(file, NULL);
 185
 186         image = lbx_img_open(file, &lbx_arch_fops, close_image);
 187         if (!image)
 188                 lbx_file_close(file);
 189         return image;
 190 }
 191
 192 void set_override(GtkComboBox *combo)
 193 {
 194         GtkTreeIter iter;
 195         gpointer lbx;
 196         guint    index;
 197         struct lbx_image *img;
 198
 199         memset(palette_override, 0, sizeof palette_override);
 200         if (!gtk_combo_box_get_active_iter(combo, &iter))
 201                 return;
 202
 203         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 204                 1, &lbx,
 205                 2, &index,
 206                 -1);
 207
 208         img = load_lbx_image(lbx, index);
 209         if (img) {
 210                 lbx_img_getpalette(img, palette_override);
 211                 lbx_img_close(img);
 212                 redraw_image();
 213         }
 214 }
 215
 216 void set_palette(GtkComboBox *combo)
 217 {
 218         GtkTreeIter iter;
 219         gpointer lbx;
 220         guint    index;
 221         LBXfile  *f;
 222
 223         memset(palette_external, 0, sizeof palette_external);
 224         if (!gtk_combo_box_get_active_iter(combo, &iter))
 225                 return;
 226
 227         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 228                 1, &lbx,
 229                 2, &index,
 230                 -1);
 231
 232         f = lbx_file_open(lbx, index);
 233         if (f) {
 234                 if (lbx_img_loadpalette(f, &lbx_arch_fops, palette_external))
 235                         memset(palette_external, 0, sizeof palette_external);
 236                 lbx_file_close(f);
 237         }
 238
 239         redraw_image();
 240 }
 241
 242 void set_image(GtkComboBox *combo)
 243 {
 244         GtkTreeIter iter;
 245         gpointer lbx;
 246         guint    index;
 247         struct lbx_image *img;
 248
 249         if (image) {
 250                 lbx_img_close(image);
 251                 image = NULL;
 252         }
 253
 254         gtk_widget_set_size_request(canvas, -1, -1);
 255         memset(palette_internal, 0, sizeof palette_internal);
 256         if (!gtk_combo_box_get_active_iter(combo, &iter))
 257                 return;
 258
 259         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 260                 1, &lbx,
 261                 2, &index,
 262                 -1);
 263
 264         img = load_lbx_image(lbx, index);
 265         if (img) {
 266                 if (lbx_img_getpalette(img, palette_internal) == -1) {
 267                         puts("crap");
 268                         lbx_img_close(img);
 269                 }
 270
 271                 if (alloc_framebuffer(img) == -1) {
 272                         puts("crap");
 273                         lbx_img_close(img);
 274                 }
 275         }
 276
 277         image = img;
 278         redraw_image();
 279 }
 280
 281 void set_background(GtkCheckMenuItem *item, gpointer data)
 282 {
 283         GdkColor black = { .red = 0,      .green = 0,      .blue = 0      };
 284         GdkColor dark  = { .red = 0x6666, .green = 0x6666, .blue = 0x6666 };
 285         GdkColor light = { .red = 0x9999, .green = 0x9999, .blue = 0x9999 };
 286
 287         if (gtk_check_menu_item_get_active(item)) {
 288                 /* Enable stippled background. */
 289                 gdk_gc_set_rgb_fg_color(bg_gc, &dark);
 290                 gdk_gc_set_rgb_bg_color(bg_gc, &light);
 291                 gdk_gc_set_fill(bg_gc, GDK_OPAQUE_STIPPLED);
 292         } else {
 293                 gdk_gc_set_rgb_fg_color(bg_gc, &black);
 294                 gdk_gc_set_fill(bg_gc, GDK_SOLID);
 295         }
 296         redraw_image();
 297 }
 298
 299 void show_about(GtkWidget *widget)
 300 {
 301         GtkWindow *parent = GTK_WINDOW(gtk_widget_get_toplevel(widget));
 302
 303         gtk_show_about_dialog(parent,
 304                 "name", g_get_application_name(),
 305                 "version", PACKAGE_VERSION,
 306                 "copyright", "Copyright \xc2\xa9 2010 Nick Bowler",
 307                 "website", "http://toom.sourceforge.net/",
 308                 NULL);
 309 }
 310
 311 static int load_archive(const char *path)
 312 {
 313         gchar *basename;
 314         GtkTreeIter iter1, iter2;
 315         unsigned nfiles;
 316         struct lbx *lbx;
 317
 318         lbx = lbx_fopen(path);
 319         if (!lbx)
 320                 return -1;
 321
 322         basename = g_path_get_basename(path);
 323         gtk_tree_store_append(archives, &iter1, NULL);
 324         gtk_tree_store_set(archives, &iter1,
 325                 0, basename,
 326                 1, (gpointer)lbx,
 327                 -1);
 328         g_free(basename);
 329
 330         for (unsigned i = 0; i < lbx->nfiles; i++) {
 331                 struct lbx_statbuf stat;
 332
 333                 lbx_file_stat(lbx, i, &stat);
 334                 gtk_tree_store_append(archives, &iter2, &iter1);
 335                 gtk_tree_store_set(archives, &iter2,
 336                         0, stat.name,
 337                         1, (gpointer)lbx,
 338                         2, (guint)i,
 339                         -1);
 340         }
 341
 342         return 0;
 343 }
 344
 345 static void load_error(const char *name, GtkWindow *window)
 346 {
 347         GtkWidget *dialog;
 348
 349         dialog = gtk_message_dialog_new(window,
 350                 GTK_DIALOG_MODAL,
 351                 GTK_MESSAGE_ERROR,
 352                 GTK_BUTTONS_OK,
 353                 "Failed to open %s.  Decent error messages coming eventually.",
 354                 name);
 355         gtk_dialog_run(GTK_DIALOG(dialog));
 356         gtk_widget_destroy(dialog);
 357 }
 358
 359 void open_archive(GtkWidget *widget)
 360 {
 361         GtkWindow *window = GTK_WINDOW(gtk_widget_get_toplevel(widget));
 362         GtkFileFilter *lbxfilter, *allfilter;
 363         GtkFileChooser *chooser;
 364         GtkTreeIter iter;
 365
 366         chooser = GTK_FILE_CHOOSER(gtk_file_chooser_dialog_new(
 367                 "Load Archive",
 368                 window,
 369                 GTK_FILE_CHOOSER_ACTION_OPEN,
 370                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 371                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 372                 NULL));
 373
 374         lbxfilter = gtk_file_filter_new();
 375         gtk_file_filter_set_name(lbxfilter, "LBX Archives (*.lbx)");
 376         gtk_file_filter_add_pattern(lbxfilter, "*.lbx");
 377         gtk_file_filter_add_pattern(lbxfilter, "*.LBX");
 378
 379         allfilter = gtk_file_filter_new();
 380         gtk_file_filter_set_name(allfilter, "All Files");
 381         gtk_file_filter_add_pattern(allfilter, "*");
 382
 383         gtk_file_chooser_add_filter(chooser, lbxfilter);
 384         gtk_file_chooser_add_filter(chooser, allfilter);
 385
 386         while (gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
 387                 gchar *name = gtk_file_chooser_get_filename(chooser);
 388
 389                 if (load_archive(name) == 0) {
 390                         g_free(name);
 391                         break;
 392                 }
 393
 394                 load_error(name, GTK_WINDOW(chooser));
 395                 g_free(name);
 396         }
 397
 398         gtk_widget_destroy(GTK_WIDGET(chooser));
 399 }
 400
 401 static void clear_combobox(GtkEntry *entry, GtkEntryIconPosition pos,
 402                            GdkEvent *event, gpointer data)
 403 {
 404         GtkComboBox *combo = data;
 405
 406         gtk_entry_set_text(entry, "");
 407         gtk_combo_box_set_active(combo, -1);
 408         redraw_image();
 409 }
 410
 411 static void init_combobox(GtkBuilder *builder, const char *name)
 412 {
 413         GtkComboBox *combo;
 414         GtkEntry *entry;
 415
 416         combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, name));
 417         gtk_combo_box_set_model(combo, GTK_TREE_MODEL(archives));
 418         gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo), 0);
 419
 420         entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo)));
 421         g_signal_connect(G_OBJECT(entry), "icon-press",
 422                 G_CALLBACK(clear_combobox), combo);
 423         gtk_entry_set_icon_from_stock(entry, GTK_ENTRY_ICON_SECONDARY,
 424                 GTK_STOCK_CLEAR);
 425 }
 426
 427 static void init_interface(void)
 428 {
 429         GtkTreeViewColumn *column;
 430         GtkCellRenderer *renderer;
 431         GtkTreeView *tree;
 432
 433         renderer = gtk_cell_renderer_text_new();
 434         column = gtk_tree_view_column_new();
 435         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 436         gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
 437
 438         tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "treeview"));
 439         gtk_tree_view_set_model(tree, GTK_TREE_MODEL(archives));
 440         gtk_tree_view_append_column(tree, column);
 441
 442         init_combobox(builder, "palettechooser");
 443         init_combobox(builder, "imagechooser");
 444         init_combobox(builder, "overchooser");
 445 }
 446
 447 static void init_background(GdkDrawable *drawable)
 448 {
 449         GtkWidget *check;
 450         GdkBitmap *bitmap;
 451
 452         bg_gc = gdk_gc_new(canvas->window);
 453
 454         bitmap = gdk_bitmap_create_from_data(drawable, (gchar *)bg_bits,
 455                 bg_width, bg_height);
 456
 457         gdk_gc_set_stipple(bg_gc, bitmap);
 458         gdk_gc_set_ts_origin(bg_gc, 0, 0);
 459
 460         check = GTK_WIDGET(gtk_builder_get_object(builder, "menu-background"));
 461         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(check), TRUE);
 462         set_background(GTK_CHECK_MENU_ITEM(check), NULL);
 463 }
 464
 465 int main(int argc, char **argv)
 466 {
 467         extern char lbxgui_glade[];
 468         GtkWidget *window;
 469         GError *err = NULL;
 470
 471         if (!gtk_init_with_args(&argc, &argv, NULL, NULL, NULL, &err)) {
 472                 fprintf(stderr, "%s\n", err->message);
 473                 return EXIT_FAILURE;
 474         }
 475
 476         archives = gtk_tree_store_new(3,
 477                 G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_UINT);
 478         while (*argv)
 479                 load_archive(*argv++);
 480
 481         builder = gtk_builder_new();
 482         if (!gtk_builder_add_from_string(builder, lbxgui_glade, -1, &err)) {
 483                 fprintf(stderr, "%s\n", err->message);
 484                 return EXIT_FAILURE;
 485         }
 486
 487         window = GTK_WIDGET(gtk_builder_get_object(builder, "mainwindow"));
 488         canvas = GTK_WIDGET(gtk_builder_get_object(builder, "canvas"));
 489
 490         init_interface();
 491         gtk_builder_connect_signals(builder, window);
 492
 493         g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 10, timeout, NULL, NULL);
 494         gtk_widget_show_all(window);
 495
 496         init_background(canvas->window);
 497         gtk_main();
 498 }