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