src/gui/lbxgui.c

   1 #include <config.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <math.h>
   5
   6 #include <gtk/gtk.h>
   7
   8 #include "lbx.h"
   9 #include "image.h"
  10
  11 static GtkTreeStore *archives;
  12 static GtkBuilder *builder;
  13
  14 static GtkWidget *canvas;
  15 static LBX_IMG *image;
  16 /* LBX images can have up to three palettes, with each superseding the last. */
  17 static struct lbx_colour palette_external[256];
  18 static struct lbx_colour palette_internal[256];
  19 static struct lbx_colour palette_override[256];
  20
  21 GdkPixbuf *framebuf;
  22
  23 void play_toggled(GtkToggleButton *button, gpointer data)
  24 {
  25         gboolean active = gtk_toggle_button_get_active(button);
  26         GtkWidget *spin;
  27
  28         if (active && !image) {
  29                 gtk_toggle_button_set_active(button, FALSE);
  30                 return;
  31         }
  32
  33         spin = GTK_WIDGET(gtk_builder_get_object(builder, "framespin"));
  34         gtk_widget_set_sensitive(spin, !active);
  35
  36         if (active) {
  37                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
  38         }
  39 }
  40
  41 static void get_colour(unsigned char index, unsigned char out[static 3])
  42 {
  43         struct lbx_colour *colour;
  44
  45         if (palette_override[index].active)
  46                 colour = palette_override + index;
  47         else if (palette_internal[index].active)
  48                 colour = palette_internal + index;
  49         else if (palette_external[index].active)
  50                 colour = palette_external + index;
  51         else
  52                 colour = &(struct lbx_colour) { .red = 0xff, .blue = 0xff };
  53
  54         out[0] = colour->red;
  55         out[1] = colour->green;
  56         out[2] = colour->blue;
  57 }
  58
  59 static int render_frame(LBX_IMG *img, GdkPixbuf *buf, unsigned frame)
  60 {
  61         unsigned char **imgdata, **imgmask;
  62         struct lbx_imginfo info;
  63         unsigned char *data;
  64         unsigned stride;
  65
  66         lbximg_getinfo(image, &info);
  67         imgdata = lbximg_getframe(image, frame);
  68         if (!imgdata) {
  69                 printf("failed to decode frame %u\n", frame);
  70                 return -1;
  71         }
  72         imgmask = lbximg_getmask(image);
  73
  74         data   = gdk_pixbuf_get_pixels(buf);
  75         stride = gdk_pixbuf_get_rowstride(buf);
  76
  77         for (unsigned i = 0; i < info.height; i++) {
  78                 unsigned char (*p)[3] = (void *)(data + i*stride);
  79
  80                 for (unsigned j = 0; j < info.width; j++) {
  81                         if (imgmask[i][j]) {
  82                                 get_colour(imgdata[i][j], p[j]);
  83                         } else {
  84                                 p[j][0] = 0;
  85                                 p[j][1] = 0;
  86                                 p[j][2] = 0;
  87                         }
  88                 }
  89         }
  90
  91         return 0;
  92 }
  93
  94 void set_frame(GtkSpinButton *spin, gpointer data)
  95 {
  96         unsigned frame = gtk_spin_button_get_value_as_int(spin);
  97
  98         render_frame(image, framebuf, frame);
  99         gdk_window_invalidate_rect(canvas->window, NULL, FALSE);
 100 }
 101
 102 static void tick(void *p, double delta)
 103 {
 104         static double elapsed = 0;
 105         double seconds_per_frame = 1.0/15;
 106         struct lbx_imginfo info;
 107         GtkSpinButton   *spin;
 108         GtkToggleButton *play;
 109         unsigned frame;
 110
 111         if (!image)
 112                 return;
 113
 114         lbximg_getinfo(image, &info);
 115         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
 116         play = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "playbutton"));
 117
 118         frame = gtk_spin_button_get_value_as_int(spin);
 119         if (!gtk_toggle_button_get_active(play))
 120                 return;
 121
 122         elapsed += delta;
 123         while (elapsed > seconds_per_frame) {
 124                 elapsed -= seconds_per_frame;
 125
 126                 if (++frame >= info.nframes) {
 127                         if (!info.looping) {
 128                                 gtk_toggle_button_set_active(play, FALSE);
 129                                 break;
 130                         }
 131
 132                         frame = info.loopstart;
 133                 }
 134
 135                 gtk_spin_button_set_value(spin, frame);
 136         }
 137 }
 138
 139 static gboolean timeout(gpointer data)
 140 {
 141         static double lasttime = INFINITY;
 142         static GTimer *timer;
 143
 144         if (isinf(lasttime)) {
 145                 timer = g_timer_new();
 146                 if (timer) {
 147                         lasttime = 0;
 148                 }
 149         } else {
 150                 double time = g_timer_elapsed(timer, NULL);
 151
 152                 tick(data, time - lasttime);
 153                 lasttime = time;
 154         }
 155
 156         return TRUE;
 157 }
 158
 159 gboolean canvas_expose(GtkWidget *canvas, GdkEventExpose *event, gpointer data)
 160 {
 161         if (!framebuf)
 162                 return TRUE;
 163
 164         gdk_draw_pixbuf(canvas->window, NULL, framebuf,
 165                 event->area.x, event->area.y, event->area.x, event->area.y,
 166                 event->area.width, event->area.height,
 167                 GDK_RGB_DITHER_NORMAL, 0, 0);
 168
 169         return TRUE;
 170 }
 171
 172 static int init_framedata(int reset)
 173 {
 174         struct lbx_imginfo info;
 175         GtkSpinButton *spin;
 176
 177         if (!image)
 178                 return 0;
 179
 180         lbximg_getinfo(image, &info);
 181         framebuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8,
 182                 info.width, info.height);
 183         if (!framebuf) {
 184                 printf("failed to allocate pixbuf\n");
 185                 return -1;
 186         }
 187
 188         gtk_widget_set_size_request(canvas, info.width, info.height);
 189
 190         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
 191         gtk_spin_button_set_range(spin, 0, info.nframes-1);
 192         gtk_spin_button_set_value(spin, 0);
 193         set_frame(spin, NULL);
 194         return 0;
 195 }
 196
 197 static int img_close(void *handle)
 198 {
 199         lbx_file_close(handle);
 200         return 0;
 201 }
 202
 203 void set_override_data(GtkComboBox *combo)
 204 {
 205         GtkTreeIter iter;
 206         gpointer lbx;
 207         guint    index;
 208         LBXfile  *f;
 209         LBX_IMG  *img;
 210
 211         if (!gtk_combo_box_get_active_iter(combo, &iter))
 212                 return;
 213
 214         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 215                 1, &lbx,
 216                 2, &index,
 217                 -1);
 218
 219         f = lbx_file_open(lbx, index);
 220         if (f) {
 221                 img = lbximg_open(f, &lbx_arch_fops, NULL);
 222                 if (img) {
 223                         memset(palette_override, 0, sizeof palette_override);
 224                         lbximg_getpalette(img, palette_override);
 225                         lbximg_close(img);
 226                         init_framedata(0);
 227                 }
 228
 229                 lbx_file_close(f);
 230         } else {
 231                 puts("damn");
 232         }
 233 }
 234
 235 void set_palette_data(GtkComboBox *combo)
 236 {
 237         GtkTreeIter iter;
 238         gpointer lbx;
 239         guint    index;
 240         LBXfile  *f;
 241
 242         if (!gtk_combo_box_get_active_iter(combo, &iter))
 243                 return;
 244
 245         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 246                 1, &lbx,
 247                 2, &index,
 248                 -1);
 249
 250         f = lbx_file_open(lbx, index);
 251         if (f) {
 252                 if (lbximg_loadpalette(f, &lbx_arch_fops, palette_external))
 253                         memset(palette_external, 0, sizeof palette_external);
 254                 lbx_file_close(f);
 255         }
 256
 257         init_framedata(0);
 258 }
 259
 260 void set_image_data(GtkComboBox *combo)
 261 {
 262         GtkTreeIter iter;
 263         gpointer lbx;
 264         guint    index;
 265         LBXfile  *f;
 266
 267         if (!gtk_combo_box_get_active_iter(combo, &iter))
 268                 return;
 269
 270         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 271                 1, &lbx,
 272                 2, &index,
 273                 -1);
 274
 275         f = lbx_file_open(lbx, index);
 276         if (f) {
 277                 image = lbximg_open(f, &lbx_arch_fops, img_close);
 278                 if (image) {
 279                         memset(palette_internal, 0, sizeof palette_internal);
 280                         if (lbximg_getpalette(image, palette_internal) == -1) {
 281                                 puts("crap");
 282                                 lbximg_close(image);
 283                         }
 284
 285                         if (init_framedata(1) == -1) {
 286                                 puts("crap");
 287                                 lbximg_close(image);
 288                         }
 289                 } else {
 290                         puts("fuck");
 291                         lbx_file_close(f);
 292                 }
 293         } else {
 294                 puts("damn");
 295         }
 296 }
 297
 298 void show_about(GtkWidget *widget)
 299 {
 300         GtkWindow *parent = GTK_WINDOW(gtk_widget_get_toplevel(widget));
 301
 302         gtk_show_about_dialog(parent,
 303                 "name", g_get_application_name(),
 304                 "version", PACKAGE_VERSION,
 305                 "copyright", "Copyright \xc2\xa9 2010 Nick Bowler",
 306                 "website", "http://toom.sourceforge.net/",
 307                 NULL);
 308 }
 309
 310 int load_archive(const char *path)
 311 {
 312         gchar *basename;
 313         GtkTreeIter iter1, iter2;
 314         unsigned nfiles;
 315         LBX *lbx;
 316
 317         lbx = lbx_fopen(path);
 318         if (!lbx)
 319                 return -1;
 320
 321         basename = g_path_get_basename(path);
 322         gtk_tree_store_append(archives, &iter1, NULL);
 323         gtk_tree_store_set(archives, &iter1,
 324                 0, basename,
 325                 1, (gpointer)lbx,
 326                 -1);
 327         g_free(basename);
 328
 329         nfiles = lbx_numfiles(lbx);
 330         for (unsigned i = 0; i < nfiles; i++) {
 331                 struct lbx_statbuf stat;
 332
 333                 lbx_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 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 interface_init(void)
 402 {
 403         GtkTreeViewColumn *column;
 404         GtkCellRenderer *renderer;
 405         GtkComboBox *combo;
 406         GtkTreeView *tree;
 407
 408         renderer = gtk_cell_renderer_text_new();
 409         column = gtk_tree_view_column_new();
 410         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 411         gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
 412
 413         tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "treeview"));
 414         gtk_tree_view_set_model(tree, GTK_TREE_MODEL(archives));
 415         gtk_tree_view_append_column(tree, column);
 416
 417         combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, "palettechooser"));
 418         gtk_combo_box_set_model(combo, GTK_TREE_MODEL(archives));
 419         gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo), 0);
 420
 421         combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, "imagechooser"));
 422         gtk_combo_box_set_model(combo, GTK_TREE_MODEL(archives));
 423         gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo), 0);
 424
 425         combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, "overchooser"));
 426         gtk_combo_box_set_model(combo, GTK_TREE_MODEL(archives));
 427         gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo), 0);
 428 }
 429
 430 int main(int argc, char **argv)
 431 {
 432         GtkWidget *window;
 433         GError *err = NULL;
 434
 435         if (!gtk_init_with_args(&argc, &argv, NULL, NULL, NULL, &err)) {
 436                 fprintf(stderr, "%s\n", err->message);
 437                 return EXIT_FAILURE;
 438         }
 439
 440         archives = gtk_tree_store_new(3,
 441                 G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_UINT);
 442         while (*argv)
 443                 load_archive(*argv++);
 444
 445         builder = gtk_builder_new();
 446         if (!gtk_builder_add_from_file(builder, "src/gui/lbxgui.glade", &err)) {
 447                 fprintf(stderr, "%s\n", err->message);
 448                 return EXIT_FAILURE;
 449         }
 450
 451         window = GTK_WIDGET(gtk_builder_get_object(builder, "mainwindow"));
 452         canvas = GTK_WIDGET(gtk_builder_get_object(builder, "canvas"));
 453
 454         interface_init();
 455         gtk_builder_connect_signals(builder, window);
 456
 457         g_timeout_add(10, timeout, NULL);
 458         gtk_widget_show_all(window);
 459         gtk_main();
 460 }