src/gui/lbxgui.c

   1 /*
   2  *  2ooM: The Master of Orion II Reverse Engineering Project
   3  *  Graphical tool for inspecting LBX archives.
   4  *  Copyright © 2010, 2014 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 <assert.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <stdbool.h>
  24 #include <math.h>
  25
  26 #include <gtk/gtk.h>
  27
  28 #include "lbx.h"
  29 #include "image.h"
  30 #include "lbxgui.h"
  31
  32 #include "bg.xbm"
  33
  34 static GtkTreeStore *archives;
  35 static GtkBuilder *builder;
  36
  37 static GtkWidget *canvas;
  38
  39 static cairo_surface_t *framebuf;
  40 static cairo_pattern_t *bg_pattern;
  41 static bool bg_stipple;
  42
  43 static struct lbx_image *image;
  44 static struct lbx_colour palette[256];
  45
  46 /* We support stacking up to three palettes, with each superseding the last. */
  47 static struct lbx_colour palette_external[256];
  48 static struct lbx_colour palette_internal[256];
  49 static struct lbx_colour palette_override[256];
  50
  51 static void refresh_palette(void)
  52 {
  53         memcpy(palette, palette_external, sizeof palette);
  54         lbxgui_stack_palette(palette, palette_internal);
  55         lbxgui_stack_palette(palette, palette_override);
  56
  57         if (framebuf)
  58                 lbxgui_render_restart(framebuf);
  59 }
  60
  61 void play_toggled(GtkToggleButton *button, gpointer data)
  62 {
  63         gboolean active = gtk_toggle_button_get_active(button);
  64         GtkWidget *spin;
  65
  66         if (active && !image) {
  67                 gtk_toggle_button_set_active(button, FALSE);
  68                 return;
  69         }
  70
  71         spin = GTK_WIDGET(gtk_builder_get_object(builder, "framespin"));
  72         gtk_widget_set_sensitive(spin, !active);
  73
  74         if (active) {
  75                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
  76         }
  77 }
  78
  79 void set_frame(GtkSpinButton *spin, gpointer data)
  80 {
  81         unsigned frame = gtk_spin_button_get_value_as_int(spin);
  82
  83         if (image)
  84                 lbxgui_render_argb(framebuf, image, frame, palette);
  85         gdk_window_invalidate_rect(canvas->window, NULL, FALSE);
  86 }
  87
  88 static void redraw_image(void)
  89 {
  90         GtkSpinButton *spin;
  91
  92         refresh_palette();
  93
  94         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
  95         set_frame(spin, NULL);
  96 }
  97
  98 static void tick(void *p, double delta)
  99 {
 100         static double elapsed = 0;
 101         double seconds_per_frame = 1.0/15;
 102         struct lbx_imginfo info;
 103         GtkSpinButton   *spin;
 104         GtkToggleButton *play;
 105         unsigned frame, newframe;
 106
 107         if (!image)
 108                 return;
 109
 110         lbx_img_getinfo(image, &info);
 111         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
 112         play = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "playbutton"));
 113
 114         frame = gtk_spin_button_get_value_as_int(spin);
 115         if (!gtk_toggle_button_get_active(play))
 116                 return;
 117
 118         elapsed += delta;
 119         newframe = frame;
 120         while (elapsed > seconds_per_frame) {
 121                 elapsed -= seconds_per_frame;
 122
 123                 if (++newframe >= image->frames) {
 124                         if (image->leadin == image->frames - 1) {
 125                                 gtk_toggle_button_set_active(play, FALSE);
 126                                 break;
 127                         }
 128
 129                         newframe = image->leadin;
 130                 }
 131         }
 132
 133         if (frame != newframe)
 134                 gtk_spin_button_set_value(spin, newframe);
 135 }
 136
 137 static gboolean timeout(gpointer data)
 138 {
 139         static double lasttime = INFINITY;
 140         static GTimer *timer;
 141
 142         if (isinf(lasttime)) {
 143                 timer = g_timer_new();
 144                 if (timer) {
 145                         lasttime = 0;
 146                 }
 147         } else {
 148                 double time = g_timer_elapsed(timer, NULL);
 149
 150                 tick(data, time - lasttime);
 151                 lasttime = time;
 152         }
 153
 154         return TRUE;
 155 }
 156
 157 gboolean canvas_expose(GtkWidget *canvas, GdkEventExpose *event, gpointer data)
 158 {
 159         cairo_t *cr;
 160
 161         cr = gdk_cairo_create(canvas->window);
 162
 163         if (bg_stipple) {
 164                 cairo_set_source_rgb(cr, 0.6, 0.6, 0.6);
 165                 gdk_cairo_rectangle(cr, &event->area);
 166                 cairo_fill(cr);
 167
 168                 cairo_set_source_rgb(cr, 0.3, 0.3, 0.3);
 169                 gdk_cairo_rectangle(cr, &event->area);
 170                 cairo_mask(cr, bg_pattern);
 171         } else {
 172                 cairo_set_source_rgb(cr, 0, 0, 0);
 173                 gdk_cairo_rectangle(cr, &event->area);
 174                 cairo_fill(cr);
 175         }
 176
 177         cairo_set_source_surface(cr, framebuf, 0, 0);
 178         gdk_cairo_rectangle(cr, &event->area);
 179         cairo_fill(cr);
 180
 181         cairo_destroy(cr);
 182
 183         return TRUE;
 184 }
 185
 186 static int alloc_framebuffer(struct lbx_image *img)
 187 {
 188         GtkSpinButton *spin;
 189
 190         cairo_surface_destroy(framebuf);
 191         framebuf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
 192                                               img->width, img->height);
 193
 194         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
 195         gtk_spin_button_set_range(spin, 0, img->frames-1);
 196         gtk_spin_button_set_value(spin, 0);
 197
 198         gtk_widget_set_size_request(canvas, img->width, img->height);
 199         return 0;
 200 }
 201
 202 static int close_image(void *handle)
 203 {
 204         lbx_file_close(handle);
 205         return 0;
 206 }
 207
 208 static struct lbx_image *load_lbx_image(struct lbx *archive, unsigned index)
 209 {
 210         LBXfile *file;
 211         struct lbx_image *image;
 212
 213         file = lbx_file_open(archive, index);
 214         g_return_val_if_fail(file, NULL);
 215
 216         image = lbx_img_open(file, &lbx_arch_fops, close_image);
 217         if (!image)
 218                 lbx_file_close(file);
 219         return image;
 220 }
 221
 222 void set_override(GtkComboBox *combo)
 223 {
 224         GtkTreeIter iter;
 225         gpointer lbx;
 226         guint    index;
 227         struct lbx_image *img;
 228
 229         memset(palette_override, 0, sizeof palette_override);
 230         if (!gtk_combo_box_get_active_iter(combo, &iter))
 231                 return;
 232
 233         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 234                 1, &lbx,
 235                 2, &index,
 236                 -1);
 237
 238         img = load_lbx_image(lbx, index);
 239         if (img) {
 240                 lbx_img_getpalette(img, palette_override);
 241                 lbx_img_close(img);
 242                 redraw_image();
 243         }
 244 }
 245
 246 void set_palette(GtkComboBox *combo)
 247 {
 248         GtkTreeIter iter;
 249         gpointer lbx;
 250         guint    index;
 251         LBXfile  *f;
 252
 253         memset(palette_external, 0, sizeof palette_external);
 254         if (!gtk_combo_box_get_active_iter(combo, &iter))
 255                 return;
 256
 257         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 258                 1, &lbx,
 259                 2, &index,
 260                 -1);
 261
 262         f = lbx_file_open(lbx, index);
 263         if (f) {
 264                 if (lbx_img_loadpalette(f, &lbx_arch_fops, palette_external))
 265                         memset(palette_external, 0, sizeof palette_external);
 266                 lbx_file_close(f);
 267         }
 268
 269         redraw_image();
 270 }
 271
 272 void set_image(GtkComboBox *combo)
 273 {
 274         GtkTreeIter iter;
 275         gpointer lbx;
 276         guint    index;
 277         struct lbx_image *img;
 278
 279         if (image) {
 280                 lbx_img_close(image);
 281                 image = NULL;
 282         }
 283
 284         gtk_widget_set_size_request(canvas, -1, -1);
 285         memset(palette_internal, 0, sizeof palette_internal);
 286         if (!gtk_combo_box_get_active_iter(combo, &iter))
 287                 return;
 288
 289         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 290                 1, &lbx,
 291                 2, &index,
 292                 -1);
 293
 294         img = load_lbx_image(lbx, index);
 295         if (img) {
 296                 if (lbx_img_getpalette(img, palette_internal) == -1) {
 297                         puts("crap");
 298                         lbx_img_close(img);
 299                 }
 300
 301                 alloc_framebuffer(img);
 302         }
 303
 304         image = img;
 305         redraw_image();
 306 }
 307
 308 void set_background(GtkCheckMenuItem *item, gpointer data)
 309 {
 310         bg_stipple = gtk_check_menu_item_get_active(item);
 311         redraw_image();
 312 }
 313
 314 void show_about(GtkWidget *widget)
 315 {
 316         GtkWindow *parent = GTK_WINDOW(gtk_widget_get_toplevel(widget));
 317
 318         gtk_show_about_dialog(parent,
 319                 "name", g_get_application_name(),
 320                 "version", PACKAGE_VERSION,
 321                 "copyright", "Copyright \xc2\xa9 2010 Nick Bowler",
 322                 "website", "http://toom.sourceforge.net/",
 323                 NULL);
 324 }
 325
 326 static int load_archive(const char *path)
 327 {
 328         gchar *basename;
 329         GtkTreeIter iter1, iter2;
 330         unsigned nfiles;
 331         struct lbx *lbx;
 332
 333         lbx = lbx_fopen(path);
 334         if (!lbx)
 335                 return -1;
 336
 337         basename = g_path_get_basename(path);
 338         gtk_tree_store_append(archives, &iter1, NULL);
 339         gtk_tree_store_set(archives, &iter1,
 340                 0, basename,
 341                 1, (gpointer)lbx,
 342                 -1);
 343         g_free(basename);
 344
 345         for (unsigned i = 0; i < lbx->nfiles; i++) {
 346                 struct lbx_statbuf stat;
 347
 348                 lbx_file_stat(lbx, i, &stat);
 349                 gtk_tree_store_append(archives, &iter2, &iter1);
 350                 gtk_tree_store_set(archives, &iter2,
 351                         0, stat.name,
 352                         1, (gpointer)lbx,
 353                         2, (guint)i,
 354                         -1);
 355         }
 356
 357         return 0;
 358 }
 359
 360 static void load_error(const char *name, GtkWindow *window)
 361 {
 362         GtkWidget *dialog;
 363
 364         dialog = gtk_message_dialog_new(window,
 365                 GTK_DIALOG_MODAL,
 366                 GTK_MESSAGE_ERROR,
 367                 GTK_BUTTONS_OK,
 368                 "Failed to open %s.  Decent error messages coming eventually.",
 369                 name);
 370         gtk_dialog_run(GTK_DIALOG(dialog));
 371         gtk_widget_destroy(dialog);
 372 }
 373
 374 void open_archive(GtkWidget *widget)
 375 {
 376         GtkWindow *window = GTK_WINDOW(gtk_widget_get_toplevel(widget));
 377         GtkFileFilter *lbxfilter, *allfilter;
 378         GtkFileChooser *chooser;
 379         GtkTreeIter iter;
 380
 381         chooser = GTK_FILE_CHOOSER(gtk_file_chooser_dialog_new(
 382                 "Load Archive",
 383                 window,
 384                 GTK_FILE_CHOOSER_ACTION_OPEN,
 385                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 386                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 387                 NULL));
 388
 389         lbxfilter = gtk_file_filter_new();
 390         gtk_file_filter_set_name(lbxfilter, "LBX Archives (*.lbx)");
 391         gtk_file_filter_add_pattern(lbxfilter, "*.lbx");
 392         gtk_file_filter_add_pattern(lbxfilter, "*.LBX");
 393
 394         allfilter = gtk_file_filter_new();
 395         gtk_file_filter_set_name(allfilter, "All Files");
 396         gtk_file_filter_add_pattern(allfilter, "*");
 397
 398         gtk_file_chooser_add_filter(chooser, lbxfilter);
 399         gtk_file_chooser_add_filter(chooser, allfilter);
 400
 401         while (gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
 402                 gchar *name = gtk_file_chooser_get_filename(chooser);
 403
 404                 if (load_archive(name) == 0) {
 405                         g_free(name);
 406                         break;
 407                 }
 408
 409                 load_error(name, GTK_WINDOW(chooser));
 410                 g_free(name);
 411         }
 412
 413         gtk_widget_destroy(GTK_WIDGET(chooser));
 414 }
 415
 416 static void clear_combobox(GtkEntry *entry, GtkEntryIconPosition pos,
 417                            GdkEvent *event, gpointer data)
 418 {
 419         GtkComboBox *combo = data;
 420
 421         gtk_entry_set_text(entry, "");
 422         gtk_combo_box_set_active(combo, -1);
 423         redraw_image();
 424 }
 425
 426 static void init_combobox(GtkBuilder *builder, const char *name)
 427 {
 428         GtkComboBox *combo;
 429         GtkEntry *entry;
 430
 431         combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, name));
 432         gtk_combo_box_set_model(combo, GTK_TREE_MODEL(archives));
 433         gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo), 0);
 434
 435         entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo)));
 436         g_signal_connect(G_OBJECT(entry), "icon-press",
 437                 G_CALLBACK(clear_combobox), combo);
 438         gtk_entry_set_icon_from_stock(entry, GTK_ENTRY_ICON_SECONDARY,
 439                 GTK_STOCK_CLEAR);
 440 }
 441
 442 static void init_interface(void)
 443 {
 444         GtkTreeViewColumn *column;
 445         GtkCellRenderer *renderer;
 446         GtkTreeView *tree;
 447
 448         renderer = gtk_cell_renderer_text_new();
 449         column = gtk_tree_view_column_new();
 450         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 451         gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
 452
 453         tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "treeview"));
 454         gtk_tree_view_set_model(tree, GTK_TREE_MODEL(archives));
 455         gtk_tree_view_append_column(tree, column);
 456
 457         init_combobox(builder, "palettechooser");
 458         init_combobox(builder, "imagechooser");
 459         init_combobox(builder, "overchooser");
 460 }
 461
 462 /*
 463  * Reverse the bits in each byte of a 32-bit word.
 464  */
 465 static guint32 reverse4b(guint32 v)
 466 {
 467         v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1);
 468         v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);
 469         v = ((v >> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4);
 470         return v;
 471 }
 472
 473 static cairo_surface_t *
 474 xbm_to_cairo(const void *xbmdata, int width, int height)
 475 {
 476         const unsigned char *data = xbmdata;
 477         unsigned char *sdata;
 478         cairo_surface_t *s;
 479         int stride;
 480
 481         s = cairo_image_surface_create(CAIRO_FORMAT_A1, width, height);
 482         if (cairo_surface_status(s) != CAIRO_STATUS_SUCCESS)
 483                 return s;
 484
 485         sdata = cairo_image_surface_get_data(s);
 486         stride = cairo_image_surface_get_stride(s);
 487         assert(stride % 4 == 0);
 488         width = (width + 7) / 8;
 489
 490         cairo_surface_flush(s);
 491         for (int y = 0; y < height; y++) {
 492                 /*
 493                  * Cairo is nuts.  The mapping of bits to pixels in the A1
 494                  * format actually depends on the host *byte* ordering, so
 495                  * we actually need these two separate cases.
 496                  */
 497                 if (G_BYTE_ORDER == G_LITTLE_ENDIAN) {
 498                         /* Easy, XBM and Cairo match in this case */
 499                         memcpy(sdata, data, width);
 500                 } else {
 501                         /* No such luck, we have to convert manually */
 502                         for (int x = 0; x < width; x += 4) {
 503                                 guint32 word = 0;
 504
 505                                 memcpy(&word, data+x, MIN(4, width-x));
 506                                 word = reverse4b(word);
 507                                 memcpy(sdata+x, &word, 4);
 508                         }
 509                 }
 510
 511                 sdata += stride;
 512                 data += width;
 513         }
 514         cairo_surface_mark_dirty(s);
 515
 516         return s;
 517 }
 518
 519 static void init_background(GdkDrawable *drawable)
 520 {
 521         cairo_surface_t *bg;
 522         GtkWidget *check;
 523
 524         bg = xbm_to_cairo(bg_bits, bg_width, bg_height);
 525         bg_pattern = cairo_pattern_create_for_surface(bg);
 526         cairo_pattern_set_extend(bg_pattern, CAIRO_EXTEND_REPEAT);
 527         cairo_surface_destroy(bg);
 528
 529         check = GTK_WIDGET(gtk_builder_get_object(builder, "menu-background"));
 530         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(check), TRUE);
 531         set_background(GTK_CHECK_MENU_ITEM(check), NULL);
 532 }
 533
 534 int main(int argc, char **argv)
 535 {
 536         extern char lbxgui_glade[];
 537         GtkWidget *window;
 538         GError *err = NULL;
 539
 540         if (!gtk_init_with_args(&argc, &argv, NULL, NULL, NULL, &err)) {
 541                 fprintf(stderr, "%s\n", err->message);
 542                 return EXIT_FAILURE;
 543         }
 544
 545         archives = gtk_tree_store_new(3,
 546                 G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_UINT);
 547         while (*argv)
 548                 load_archive(*argv++);
 549
 550         builder = gtk_builder_new();
 551         if (!gtk_builder_add_from_string(builder, lbxgui_glade, -1, &err)) {
 552                 fprintf(stderr, "%s\n", err->message);
 553                 return EXIT_FAILURE;
 554         }
 555
 556         window = GTK_WIDGET(gtk_builder_get_object(builder, "mainwindow"));
 557         canvas = GTK_WIDGET(gtk_builder_get_object(builder, "canvas"));
 558
 559         init_interface();
 560         gtk_builder_connect_signals(builder, window);
 561
 562         g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 10, timeout, NULL, NULL);
 563         gtk_widget_show_all(window);
 564
 565         init_background(canvas->window);
 566         gtk_main();
 567 }