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