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         lbximg_getinfo(image, &info);
 178         framebuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8,
 179                 info.width, info.height);
 180         if (!framebuf) {
 181                 printf("failed to allocate pixbuf\n");
 182                 return -1;
 183         }
 184
 185         gtk_widget_set_size_request(canvas, info.width, info.height);
 186
 187         spin = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "framespin"));
 188         gtk_spin_button_set_range(spin, 0, info.nframes-1);
 189         gtk_spin_button_set_value(spin, 0);
 190         set_frame(spin, NULL);
 191         return 0;
 192 }
 193
 194 static int img_close(void *handle)
 195 {
 196         lbx_file_close(handle);
 197         return 0;
 198 }
 199
 200 void set_palette_data(GtkComboBox *combo)
 201 {
 202         GtkTreeIter iter;
 203         gpointer lbx;
 204         guint    index;
 205         LBXfile  *f;
 206
 207         if (!gtk_combo_box_get_active_iter(combo, &iter))
 208                 return;
 209
 210         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 211                 1, &lbx,
 212                 2, &index,
 213                 -1);
 214
 215         f = lbx_file_open(lbx, index);
 216         if (f) {
 217                 if (lbximg_loadpalette(f, &lbx_arch_fops, palette_external))
 218                         memset(palette_external, 0, sizeof palette_external);
 219                 lbx_file_close(f);
 220         }
 221
 222         init_framedata(0);
 223 }
 224
 225 void set_image_data(GtkComboBox *combo)
 226 {
 227         GtkTreeIter iter;
 228         gpointer lbx;
 229         guint    index;
 230         LBXfile  *f;
 231
 232         if (!gtk_combo_box_get_active_iter(combo, &iter))
 233                 return;
 234
 235         gtk_tree_model_get(GTK_TREE_MODEL(archives), &iter,
 236                 1, &lbx,
 237                 2, &index,
 238                 -1);
 239
 240         f = lbx_file_open(lbx, index);
 241         if (f) {
 242                 struct lbx_imginfo info;
 243
 244                 image = lbximg_open(f, &lbx_arch_fops, img_close);
 245                 if (image) {
 246                         memset(palette_internal, 0, sizeof palette_internal);
 247                         if (lbximg_getpalette(image, palette_internal) == -1) {
 248                                 puts("crap");
 249                                 lbximg_close(image);
 250                         }
 251
 252                         if (init_framedata(1) == -1) {
 253                                 puts("crap");
 254                                 lbximg_close(image);
 255                         }
 256                 } else {
 257                         puts("fuck");
 258                         lbx_file_close(f);
 259                 }
 260         } else {
 261                 puts("damn");
 262         }
 263 }
 264
 265 void show_about(GtkWidget *widget)
 266 {
 267         GtkWindow *parent = GTK_WINDOW(gtk_widget_get_toplevel(widget));
 268
 269         gtk_show_about_dialog(parent,
 270                 "name", g_get_application_name(),
 271                 "version", PACKAGE_VERSION,
 272                 "copyright", "Copyright \xc2\xa9 2010 Nick Bowler",
 273                 "website", "http://toom.sourceforge.net/",
 274                 NULL);
 275 }
 276
 277 int load_archive(const char *path)
 278 {
 279         gchar *basename;
 280         GtkTreeIter iter1, iter2;
 281         unsigned nfiles;
 282         LBX *lbx;
 283
 284         lbx = lbx_fopen(path);
 285         if (!lbx)
 286                 return -1;
 287
 288         basename = g_path_get_basename(path);
 289         gtk_tree_store_append(archives, &iter1, NULL);
 290         gtk_tree_store_set(archives, &iter1,
 291                 0, basename,
 292                 1, (gpointer)lbx,
 293                 -1);
 294         g_free(basename);
 295
 296         nfiles = lbx_numfiles(lbx);
 297         for (unsigned i = 0; i < nfiles; i++) {
 298                 struct lbx_statbuf stat;
 299
 300                 lbx_stat(lbx, i, &stat);
 301                 gtk_tree_store_append(archives, &iter2, &iter1);
 302                 gtk_tree_store_set(archives, &iter2,
 303                         0, stat.name,
 304                         1, (gpointer)lbx,
 305                         2, (guint)i,
 306                         -1);
 307         }
 308
 309         return 0;
 310 }
 311
 312 void load_error(const char *name, GtkWindow *window)
 313 {
 314         GtkWidget *dialog;
 315
 316         dialog = gtk_message_dialog_new(window,
 317                 GTK_DIALOG_MODAL,
 318                 GTK_MESSAGE_ERROR,
 319                 GTK_BUTTONS_OK,
 320                 "Failed to open %s.  Decent error messages coming eventually.",
 321                 name);
 322         gtk_dialog_run(GTK_DIALOG(dialog));
 323         gtk_widget_destroy(dialog);
 324 }
 325
 326 void open_archive(GtkWidget *widget)
 327 {
 328         GtkWindow *window = GTK_WINDOW(gtk_widget_get_toplevel(widget));
 329         GtkFileFilter *lbxfilter, *allfilter;
 330         GtkFileChooser *chooser;
 331         GtkTreeIter iter;
 332
 333         chooser = GTK_FILE_CHOOSER(gtk_file_chooser_dialog_new(
 334                 "Load Archive",
 335                 window,
 336                 GTK_FILE_CHOOSER_ACTION_OPEN,
 337                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 338                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 339                 NULL));
 340
 341         lbxfilter = gtk_file_filter_new();
 342         gtk_file_filter_set_name(lbxfilter, "LBX Archives (*.lbx)");
 343         gtk_file_filter_add_pattern(lbxfilter, "*.lbx");
 344         gtk_file_filter_add_pattern(lbxfilter, "*.LBX");
 345
 346         allfilter = gtk_file_filter_new();
 347         gtk_file_filter_set_name(allfilter, "All Files");
 348         gtk_file_filter_add_pattern(allfilter, "*");
 349
 350         gtk_file_chooser_add_filter(chooser, lbxfilter);
 351         gtk_file_chooser_add_filter(chooser, allfilter);
 352
 353         while (gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
 354                 gchar *name = gtk_file_chooser_get_filename(chooser);
 355
 356                 if (load_archive(name) == 0) {
 357                         g_free(name);
 358                         break;
 359                 }
 360
 361                 load_error(name, GTK_WINDOW(chooser));
 362                 g_free(name);
 363         }
 364
 365         gtk_widget_destroy(GTK_WIDGET(chooser));
 366 }
 367
 368 static void interface_init(void)
 369 {
 370         GtkTreeViewColumn *column;
 371         GtkCellRenderer *renderer;
 372         GtkComboBox *combo;
 373         GtkTreeView *tree;
 374
 375         renderer = gtk_cell_renderer_text_new();
 376         column = gtk_tree_view_column_new();
 377         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 378         gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
 379
 380         tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "treeview"));
 381         gtk_tree_view_set_model(tree, GTK_TREE_MODEL(archives));
 382         gtk_tree_view_append_column(tree, column);
 383
 384         combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, "palettechooser"));
 385         gtk_combo_box_set_model(combo, GTK_TREE_MODEL(archives));
 386         gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo), 0);
 387
 388         combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, "imagechooser"));
 389         gtk_combo_box_set_model(combo, GTK_TREE_MODEL(archives));
 390         gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo), 0);
 391 }
 392
 393 int main(int argc, char **argv)
 394 {
 395         GtkWidget *window;
 396         GError *err = NULL;
 397
 398         if (!gtk_init_with_args(&argc, &argv, NULL, NULL, NULL, &err)) {
 399                 fprintf(stderr, "%s\n", err->message);
 400                 return EXIT_FAILURE;
 401         }
 402
 403         archives = gtk_tree_store_new(3,
 404                 G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_UINT);
 405         while (*argv)
 406                 load_archive(*argv++);
 407
 408         builder = gtk_builder_new();
 409         if (!gtk_builder_add_from_file(builder, "src/gui/lbxgui.glade", &err)) {
 410                 fprintf(stderr, "%s\n", err->message);
 411                 return EXIT_FAILURE;
 412         }
 413
 414         window = GTK_WIDGET(gtk_builder_get_object(builder, "mainwindow"));
 415         canvas = GTK_WIDGET(gtk_builder_get_object(builder, "canvas"));
 416
 417         interface_init();
 418         gtk_builder_connect_signals(builder, window);
 419
 420         g_timeout_add(10, timeout, NULL);
 421         gtk_widget_show_all(window);
 422         gtk_main();
 423 }