src/bar_exif.c

   1 /*
   2  * Geeqie
   3  * (C) 2004 John Ellis
   4  * Copyright (C) 2008 - 2009 The Geeqie Team
   5  *
   6  * Author: Vladimir Nadvornik
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13
  14 #include "main.h"
  15 #include "bar_exif.h"
  16
  17 #include "exif.h"
  18 #include "metadata.h"
  19 #include "filedata.h"
  20 #include "history_list.h"
  21 #include "misc.h"
  22 #include "ui_misc.h"
  23 #include "ui_menu.h"
  24 #include "bar.h"
  25 #include "rcfile.h"
  26 #include "dnd.h"
  27 #include "ui_utildlg.h"
  28
  29
  30 #include <math.h>
  31
  32 #define MIN_HEIGHT 25
  33 /*
  34  *-------------------------------------------------------------------
  35  * EXIF widget
  36  *-------------------------------------------------------------------
  37  */
  38
  39 typedef struct _ExifEntry ExifEntry;
  40 struct _ExifEntry
  41 {
  42         GtkWidget *ebox;
  43         GtkWidget *hbox;
  44         GtkWidget *title_label;
  45         GtkWidget *value_label;
  46
  47         gchar *key;
  48         gchar *title;
  49         gboolean if_set;
  50         gboolean auto_title;
  51 };
  52
  53
  54 typedef struct _PaneExifData PaneExifData;
  55 struct _PaneExifData
  56 {
  57         PaneData pane;
  58         GtkWidget *vbox;
  59         GtkWidget *widget;
  60         GtkSizeGroup *size_group;
  61
  62         gint min_height;
  63
  64         gboolean all_hidden;
  65         gboolean show_all;
  66
  67         FileData *fd;
  68 };
  69
  70 typedef struct _ConfDialogData ConfDialogData;
  71 struct _ConfDialogData
  72 {
  73         GtkWidget *widget; /* pane or entry, devidet by presenceof "pane_data" or "entry_data" */
  74
  75         /* dialog parts */
  76         GenericDialog *gd;
  77         GtkWidget *key_entry;
  78         GtkWidget *title_entry;
  79         gboolean if_set;
  80 };
  81
  82 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry);
  83 static void bar_pane_exif_entry_update_title(ExifEntry *ee);
  84 static void bar_pane_exif_update(PaneExifData *ped);
  85 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data);
  86
  87 static void bar_pane_exif_entry_destroy(GtkWidget *widget, gpointer data)
  88 {
  89         ExifEntry *ee = data;
  90
  91         g_free(ee->key);
  92         g_free(ee->title);
  93         g_free(ee);
  94 }
  95
  96
  97 static GtkWidget *bar_pane_exif_add_entry(PaneExifData *ped, const gchar *key, const gchar *title, gint if_set)
  98 {
  99         ExifEntry *ee = g_new0(ExifEntry, 1);
 100
 101         ee->key = g_strdup(key);
 102         if (title && title[0])
 103                 {
 104                 ee->title = g_strdup(title);
 105                 }
 106         else
 107                 {
 108                 ee->title = exif_get_description_by_key(key);
 109                 ee->auto_title = TRUE;
 110                 }
 111
 112         ee->if_set = if_set;
 113
 114         ee->ebox = gtk_event_box_new();
 115         g_object_set_data(G_OBJECT(ee->ebox), "entry_data", ee);
 116         g_signal_connect_after(G_OBJECT(ee->ebox), "destroy",
 117                                G_CALLBACK(bar_pane_exif_entry_destroy), ee);
 118
 119         ee->hbox = gtk_hbox_new(FALSE, 0);
 120         gtk_container_add(GTK_CONTAINER(ee->ebox), ee->hbox);
 121         gtk_widget_show(ee->hbox);
 122
 123         ee->title_label = gtk_label_new(NULL);
 124         gtk_misc_set_alignment(GTK_MISC(ee->title_label), 1.0, 0.5);
 125         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 126         gtk_box_pack_start(GTK_BOX(ee->hbox), ee->title_label, FALSE, TRUE, 0);
 127         gtk_widget_show(ee->title_label);
 128
 129         ee->value_label = gtk_label_new(NULL);
 130 //      gtk_label_set_width_chars(GTK_LABEL(ee->value_label), 20);
 131         gtk_label_set_ellipsize(GTK_LABEL(ee->value_label), PANGO_ELLIPSIZE_END);
 132 //      gtk_widget_set_size_request(ee->value_label, 100, -1);
 133         gtk_misc_set_alignment(GTK_MISC(ee->value_label), 0.0, 0.5);
 134         gtk_box_pack_start(GTK_BOX(ee->hbox), ee->value_label, TRUE, TRUE, 1);
 135         gtk_widget_show(ee->value_label);
 136         gtk_box_pack_start(GTK_BOX(ped->vbox), ee->ebox, FALSE, FALSE, 0);
 137
 138         bar_pane_exif_entry_dnd_init(ee->ebox);
 139         g_signal_connect(ee->ebox, "button_press_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 140
 141         bar_pane_exif_entry_update_title(ee);
 142         bar_pane_exif_update(ped);
 143
 144         return ee->ebox;
 145 }
 146
 147 static void bar_pane_exif_reparent_entry(GtkWidget *entry, GtkWidget *pane)
 148 {
 149         GtkWidget *old_pane = entry->parent;
 150         PaneExifData *ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 151         PaneExifData *old_ped = g_object_get_data(G_OBJECT(old_pane), "pane_data");
 152         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 153
 154         if (!ped || !old_ped || !ee) return;
 155
 156         g_object_ref(entry);
 157
 158         gtk_size_group_remove_widget(old_ped->size_group, ee->title_label);
 159         gtk_container_remove(GTK_CONTAINER(old_ped->vbox), entry);
 160
 161         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 162         gtk_box_pack_start(GTK_BOX(ped->vbox), entry, FALSE, FALSE, 0);
 163 }
 164
 165 static void bar_pane_exif_entry_update_title(ExifEntry *ee)
 166 {
 167         gchar *markup;
 168
 169         markup = g_markup_printf_escaped("<span size='small'>%s:</span>", (ee->title) ? ee->title : "fixme");
 170         gtk_label_set_markup(GTK_LABEL(ee->title_label), markup);
 171         g_free(markup);
 172 }
 173
 174 static void bar_pane_exif_update_entry(PaneExifData *ped, GtkWidget *entry, gboolean update_title)
 175 {
 176         gchar *text;
 177         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 178
 179         if (!ee) return;
 180         text = metadata_read_string(ped->fd, ee->key, METADATA_FORMATTED);
 181
 182         if (!ped->show_all && ee->if_set && (!text || !*text))
 183                 {
 184                 gtk_label_set_text(GTK_LABEL(ee->value_label), NULL);
 185                 gtk_widget_hide(entry);
 186                 }
 187         else
 188                 {
 189                 gtk_label_set_text(GTK_LABEL(ee->value_label), text);
 190 #if GTK_CHECK_VERSION(2,12,0)
 191                 gtk_widget_set_tooltip_text(ee->hbox, text);
 192 #endif
 193                 gtk_widget_show(entry);
 194                 ped->all_hidden = FALSE;
 195                 }
 196
 197         g_free(text);
 198
 199         if (update_title) bar_pane_exif_entry_update_title(ee);
 200 }
 201
 202 static void bar_pane_exif_update(PaneExifData *ped)
 203 {
 204         GList *list, *work;
 205
 206         ped->all_hidden = TRUE;
 207
 208         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 209         work = list;
 210         while (work)
 211                 {
 212                 GtkWidget *entry = work->data;
 213                 work = work->next;
 214
 215                 bar_pane_exif_update_entry(ped, entry, FALSE);
 216                 }
 217         g_list_free(list);
 218
 219         gtk_widget_set_sensitive(ped->pane.title, !ped->all_hidden);
 220 }
 221
 222 void bar_pane_exif_set_fd(GtkWidget *widget, FileData *fd)
 223 {
 224         PaneExifData *ped;
 225
 226         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 227         if (!ped) return;
 228
 229         file_data_unref(ped->fd);
 230         ped->fd = file_data_ref(fd);
 231
 232         bar_pane_exif_update(ped);
 233 }
 234
 235 static void bar_pane_exif_notify_cb(FileData *fd, NotifyType type, gpointer data)
 236 {
 237         PaneExifData *ped = data;
 238         if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE | NOTIFY_METADATA)) && fd == ped->fd) bar_pane_exif_update(ped);
 239 }
 240
 241 /*
 242  *-------------------------------------------------------------------
 243  * dnd
 244  *-------------------------------------------------------------------
 245  */
 246
 247 static GtkTargetEntry bar_pane_exif_drag_types[] = {
 248         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 249         { "text/plain", 0, TARGET_TEXT_PLAIN }
 250 };
 251 static gint n_exif_entry_drag_types = 2;
 252
 253 static GtkTargetEntry bar_pane_exif_drop_types[] = {
 254         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 255         { "text/plain", 0, TARGET_TEXT_PLAIN }
 256 };
 257 static gint n_exif_entry_drop_types = 2;
 258
 259
 260 static void bar_pane_exif_entry_dnd_get(GtkWidget *entry, GdkDragContext *context,
 261                                      GtkSelectionData *selection_data, guint info,
 262                                      guint time, gpointer data)
 263 {
 264         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 265
 266         switch (info)
 267                 {
 268                 case TARGET_APP_EXIF_ENTRY:
 269                         gtk_selection_data_set(selection_data, selection_data->target,
 270                                                8, (gpointer) &entry, sizeof(entry));
 271                         break;
 272
 273                 case TARGET_TEXT_PLAIN:
 274                 default:
 275                         gtk_selection_data_set_text(selection_data, ee->key, -1);
 276                         break;
 277                 }
 278
 279 }
 280
 281 static void bar_pane_exif_dnd_receive(GtkWidget *pane, GdkDragContext *context,
 282                                           gint x, gint y,
 283                                           GtkSelectionData *selection_data, guint info,
 284                                           guint time, gpointer data)
 285 {
 286         PaneExifData *ped;
 287         GList *work, *list;
 288         gint pos;
 289         GtkWidget *new_entry = NULL;
 290
 291         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 292         if (!ped) return;
 293
 294         switch (info)
 295                 {
 296                 case TARGET_APP_EXIF_ENTRY:
 297                         new_entry = *(gpointer *)selection_data->data;
 298
 299                         if (new_entry->parent && new_entry->parent != ped->vbox) bar_pane_exif_reparent_entry(new_entry, pane);
 300
 301                         break;
 302                 default:
 303                         /* FIXME: this needs a check for valid exif keys */
 304                         new_entry = bar_pane_exif_add_entry(ped, (gchar *)selection_data->data, NULL, TRUE);
 305                         break;
 306                 }
 307
 308         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 309         work = list;
 310         pos = 0;
 311         while (work)
 312                 {
 313                 gint nx, ny;
 314                 GtkWidget *entry = work->data;
 315                 work = work->next;
 316
 317                 if (entry == new_entry) continue;
 318
 319                 if (GTK_WIDGET_DRAWABLE(entry) &&
 320                     gtk_widget_translate_coordinates(pane, entry, x, y, &nx, &ny) &&
 321                     ny < entry->allocation.height / 2) break;
 322                 pos++;
 323                 }
 324         g_list_free(list);
 325
 326         gtk_box_reorder_child(GTK_BOX(ped->vbox), new_entry, pos);
 327 }
 328
 329 static void bar_pane_exif_entry_dnd_begin(GtkWidget *entry, GdkDragContext *context, gpointer data)
 330 {
 331         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 332
 333         if (!ee) return;
 334         dnd_set_drag_label(entry, context, ee->key);
 335 }
 336
 337 static void bar_pane_exif_entry_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 338 {
 339 }
 340
 341 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry)
 342 {
 343         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 344
 345         gtk_drag_source_set(entry, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 346                             bar_pane_exif_drag_types, n_exif_entry_drag_types,
 347                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 348         g_signal_connect(G_OBJECT(entry), "drag_data_get",
 349                          G_CALLBACK(bar_pane_exif_entry_dnd_get), ee);
 350
 351         g_signal_connect(G_OBJECT(entry), "drag_begin",
 352                          G_CALLBACK(bar_pane_exif_entry_dnd_begin), ee);
 353         g_signal_connect(G_OBJECT(entry), "drag_end",
 354                          G_CALLBACK(bar_pane_exif_entry_dnd_end), ee);
 355 }
 356
 357 static void bar_pane_exif_dnd_init(GtkWidget *pane)
 358 {
 359         gtk_drag_dest_set(pane,
 360                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
 361                           bar_pane_exif_drop_types, n_exif_entry_drop_types,
 362                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
 363         g_signal_connect(G_OBJECT(pane), "drag_data_received",
 364                          G_CALLBACK(bar_pane_exif_dnd_receive), NULL);
 365 }
 366
 367 static void bar_pane_exif_edit_close_cb(GtkWidget *widget, gpointer data)
 368 {
 369         GenericDialog *gd = data;
 370         generic_dialog_close(gd);
 371 }
 372
 373 static void bar_pane_exif_edit_destroy_cb(GtkWidget *widget, gpointer data)
 374 {
 375         ConfDialogData *cdd = data;
 376         g_signal_handlers_disconnect_by_func(cdd->widget, G_CALLBACK(bar_pane_exif_edit_close_cb), cdd->gd);
 377         g_free(cdd);
 378 }
 379
 380 static void bar_pane_exif_edit_cancel_cb(GenericDialog *gd, gpointer data)
 381 {
 382 }
 383
 384 static void bar_pane_exif_edit_ok_cb(GenericDialog *gd, gpointer data)
 385 {
 386         ConfDialogData *cdd = data;
 387
 388         /* either one or the other */
 389         PaneExifData *ped = g_object_get_data(G_OBJECT(cdd->widget), "pane_data");
 390         ExifEntry *ee = g_object_get_data(G_OBJECT(cdd->widget), "entry_data");
 391
 392         if (ped)
 393                 {
 394                 bar_pane_exif_add_entry(ped,
 395                                         gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)),
 396                                         gtk_entry_get_text(GTK_ENTRY(cdd->title_entry)),
 397                                         cdd->if_set);
 398                 }
 399
 400         if (ee)
 401                 {
 402                 const gchar *title;
 403                 GtkWidget *pane = cdd->widget->parent;
 404
 405                 while (pane)
 406                         {
 407                         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 408                         if (ped) break;
 409                         pane = pane->parent;
 410                         }
 411
 412                 if (!pane) return;
 413
 414                 g_free(ee->key);
 415                 ee->key = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)));
 416                 title = gtk_entry_get_text(GTK_ENTRY(cdd->title_entry));
 417                 if (strcmp(ee->title, title) != 0)
 418                         {
 419                         g_free(ee->title);
 420                         ee->title = g_strdup(title);
 421                         ee->auto_title = FALSE;
 422                         }
 423
 424                 ee->if_set = cdd->if_set;
 425
 426                 bar_pane_exif_entry_update_title(ee);
 427                 bar_pane_exif_update(ped);
 428                 }
 429 }
 430
 431 static void bar_pane_exif_conf_dialog(GtkWidget *widget)
 432 {
 433         ConfDialogData *cdd;
 434         GenericDialog *gd;
 435         GtkWidget *table;
 436
 437         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 438            we can decide it by the attached data */
 439         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 440
 441         cdd = g_new0(ConfDialogData, 1);
 442
 443         cdd->widget = widget;
 444
 445
 446         cdd->if_set = ee ? ee->if_set : TRUE;
 447
 448         cdd->gd = gd = generic_dialog_new(ee ? _("Configure entry") : _("Add entry"), "exif_entry_edit",
 449                                 widget, TRUE,
 450                                 bar_pane_exif_edit_cancel_cb, cdd);
 451         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 452                          G_CALLBACK(bar_pane_exif_edit_destroy_cb), cdd);
 453
 454         /* in case the entry is deleted during editing */
 455         g_signal_connect(G_OBJECT(widget), "destroy",
 456                          G_CALLBACK(bar_pane_exif_edit_close_cb), gd);
 457
 458         generic_dialog_add_message(gd, NULL, ee ? _("Configure entry") : _("Add entry"), NULL);
 459
 460         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
 461                                   bar_pane_exif_edit_ok_cb, TRUE);
 462
 463         table = pref_table_new(gd->vbox, 3, 2, FALSE, TRUE);
 464         pref_table_label(table, 0, 0, _("Key:"), 1.0);
 465
 466         cdd->key_entry = gtk_entry_new();
 467         gtk_widget_set_size_request(cdd->key_entry, 300, -1);
 468         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->key_entry), ee->key);
 469         gtk_table_attach_defaults(GTK_TABLE(table), cdd->key_entry, 1, 2, 0, 1);
 470         generic_dialog_attach_default(gd, cdd->key_entry);
 471         gtk_widget_show(cdd->key_entry);
 472
 473         pref_table_label(table, 0, 1, _("Title:"), 1.0);
 474
 475         cdd->title_entry = gtk_entry_new();
 476         gtk_widget_set_size_request(cdd->title_entry, 300, -1);
 477         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->title_entry), ee->title);
 478         gtk_table_attach_defaults(GTK_TABLE(table), cdd->title_entry, 1, 2, 1, 2);
 479         generic_dialog_attach_default(gd, cdd->title_entry);
 480         gtk_widget_show(cdd->title_entry);
 481
 482         pref_checkbox_new_int(gd->vbox, _("Show only if set"), cdd->if_set, &cdd->if_set);
 483
 484         gtk_widget_show(gd->dialog);
 485 }
 486
 487 static void bar_pane_exif_conf_dialog_cb(GtkWidget *menu_widget, gpointer data)
 488 {
 489         GtkWidget *widget = data;
 490         bar_pane_exif_conf_dialog(widget);
 491 }
 492
 493 static void bar_pane_exif_delete_entry_cb(GtkWidget *menu_widget, gpointer data)
 494 {
 495         GtkWidget *entry = data;
 496         gtk_widget_destroy(entry);
 497 }
 498
 499 static void bar_pane_exif_toggle_show_all_cb(GtkWidget *menu_widget, gpointer data)
 500 {
 501         PaneExifData *ped = data;
 502         ped->show_all = !ped->show_all;
 503         bar_pane_exif_update(ped);
 504 }
 505
 506 static void bar_pane_exif_menu_popup(GtkWidget *widget, PaneExifData *ped)
 507 {
 508         GtkWidget *menu;
 509         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 510            we can decide it by the attached data */
 511         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 512
 513         menu = popup_menu_short_lived();
 514
 515         if (ee)
 516                 {
 517                 /* for the entry */
 518                 gchar *conf = g_strdup_printf(_("Configure \"%s\""), ee->title);
 519                 gchar *del = g_strdup_printf(_("Delete \"%s\""), ee->title);
 520
 521                 menu_item_add_stock(menu, conf, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_exif_conf_dialog_cb), widget);
 522                 menu_item_add_stock(menu, del, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_exif_delete_entry_cb), widget);
 523                 menu_item_add_divider(menu);
 524
 525                 g_free(conf);
 526                 g_free(del);
 527                 }
 528
 529         /* for the pane */
 530         menu_item_add_stock(menu, _("Add entry"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_exif_conf_dialog_cb), ped->widget);
 531         menu_item_add_check(menu, _("Show hidden entries"), ped->show_all, G_CALLBACK(bar_pane_exif_toggle_show_all_cb), ped);
 532
 533         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
 534 }
 535
 536 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
 537 {
 538         PaneExifData *ped = data;
 539         if (bevent->button == MOUSE_BUTTON_RIGHT)
 540                 {
 541                 bar_pane_exif_menu_popup(widget, ped);
 542                 return TRUE;
 543                 }
 544         return FALSE;
 545 }
 546
 547 static void bar_pane_exif_entry_write_config(GtkWidget *entry, GString *outstr, gint indent)
 548 {
 549         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 550         if (!ee) return;
 551
 552         WRITE_STRING("<entry\n");
 553         indent++;
 554         WRITE_CHAR(*ee, key);
 555         if (!ee->auto_title) WRITE_CHAR(*ee, title);
 556         WRITE_BOOL(*ee, if_set);
 557         indent--;
 558         WRITE_STRING("/>\n");
 559 }
 560
 561 static void bar_pane_exif_write_config(GtkWidget *pane, GString *outstr, gint indent)
 562 {
 563         PaneExifData *ped;
 564         GList *work, *list;
 565
 566         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 567         if (!ped) return;
 568
 569         WRITE_STRING("<pane_exif\n");
 570         indent++;
 571         write_char_option(outstr, indent, "pane.title", gtk_label_get_text(GTK_LABEL(ped->pane.title)));
 572         WRITE_BOOL(*ped, pane.expanded);
 573         indent--;
 574         WRITE_STRING(">\n");
 575         indent++;
 576
 577         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 578         work = list;
 579         while (work)
 580                 {
 581                 GtkWidget *entry = work->data;
 582                 work = work->next;
 583
 584                 bar_pane_exif_entry_write_config(entry, outstr, indent);
 585                 }
 586         g_list_free(list);
 587         indent--;
 588         WRITE_STRING("</pane_exif>\n");
 589 }
 590
 591
 592 void bar_pane_exif_close(GtkWidget *widget)
 593 {
 594         PaneExifData *ped;
 595
 596         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 597         if (!ped) return;
 598
 599         gtk_widget_destroy(ped->vbox);
 600 }
 601
 602 static void bar_pane_exif_destroy(GtkWidget *widget, gpointer data)
 603 {
 604         PaneExifData *ped = data;
 605
 606         file_data_unregister_notify_func(bar_pane_exif_notify_cb, ped);
 607         g_object_unref(ped->size_group);
 608         file_data_unref(ped->fd);
 609         g_free(ped);
 610 }
 611
 612 static void bar_pane_exif_size_request(GtkWidget *pane, GtkRequisition *requisition, gpointer data)
 613 {
 614         PaneExifData *ped = data;
 615         if (requisition->height < ped->min_height)
 616                 {
 617                 requisition->height = ped->min_height;
 618                 }
 619 }
 620
 621 static void bar_pane_exif_size_allocate(GtkWidget *pane, GtkAllocation *alloc, gpointer data)
 622 {
 623         PaneExifData *ped = data;
 624         ped->min_height = alloc->height;
 625 }
 626
 627 GtkWidget *bar_pane_exif_new(const gchar *title, gboolean expanded, gboolean populate)
 628 {
 629         PaneExifData *ped;
 630
 631         ped = g_new0(PaneExifData, 1);
 632
 633         ped->pane.pane_set_fd = bar_pane_exif_set_fd;
 634         ped->pane.pane_write_config = bar_pane_exif_write_config;
 635         ped->pane.title = bar_pane_expander_title(title);
 636         ped->pane.expanded = expanded;
 637
 638         ped->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 639         ped->widget = gtk_event_box_new();
 640         ped->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 641         gtk_container_add(GTK_CONTAINER(ped->widget), ped->vbox);
 642         gtk_widget_show(ped->vbox);
 643
 644         ped->min_height = MIN_HEIGHT;
 645         g_object_set_data(G_OBJECT(ped->widget), "pane_data", ped);
 646         g_signal_connect_after(G_OBJECT(ped->widget), "destroy",
 647                                G_CALLBACK(bar_pane_exif_destroy), ped);
 648         g_signal_connect(G_OBJECT(ped->widget), "size-request",
 649                          G_CALLBACK(bar_pane_exif_size_request), ped);
 650         g_signal_connect(G_OBJECT(ped->widget), "size-allocate",
 651                          G_CALLBACK(bar_pane_exif_size_allocate), ped);
 652
 653         bar_pane_exif_dnd_init(ped->widget);
 654         g_signal_connect(ped->widget, "button_press_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 655
 656         file_data_register_notify_func(bar_pane_exif_notify_cb, ped, NOTIFY_PRIORITY_LOW);
 657
 658         if (populate)
 659                 {
 660                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Camera"), NULL, TRUE);
 661                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("DateTime"), NULL, TRUE);
 662                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ShutterSpeed"), NULL, TRUE);
 663                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Aperture"), NULL, TRUE);
 664                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ExposureBias"), NULL, TRUE);
 665                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ISOSpeedRating"), NULL, TRUE);
 666                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("FocalLength"), NULL, TRUE);
 667                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("FocalLength35mmFilm"), NULL, TRUE);
 668                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Flash"), NULL, TRUE);
 669                 bar_pane_exif_add_entry(ped, "Exif.Photo.ExposureProgram", NULL, TRUE);
 670                 bar_pane_exif_add_entry(ped, "Exif.Photo.MeteringMode", NULL, TRUE);
 671                 bar_pane_exif_add_entry(ped, "Exif.Photo.LightSource", NULL, TRUE);
 672                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ColorProfile"), NULL, TRUE);
 673                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("SubjectDistance"), NULL, TRUE);
 674                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Resolution"), NULL, TRUE);
 675                 bar_pane_exif_add_entry(ped, "Exif.Image.Orientation", NULL, TRUE);
 676                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("GPSPosition"), NULL, TRUE);
 677                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("GPSAltitude"), NULL, TRUE);
 678                 bar_pane_exif_add_entry(ped, "Exif.Image.ImageDescription", NULL, TRUE);
 679                 bar_pane_exif_add_entry(ped, "Exif.Image.Copyright", NULL, TRUE);
 680                 }
 681
 682         gtk_widget_show(ped->widget);
 683
 684         return ped->widget;
 685 }
 686
 687 GtkWidget *bar_pane_exif_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
 688 {
 689         gchar *title = g_strdup(_("NoName"));
 690         gboolean expanded = TRUE;
 691
 692         while (*attribute_names)
 693                 {
 694                 const gchar *option = *attribute_names++;
 695                 const gchar *value = *attribute_values++;
 696
 697                 if (READ_CHAR_FULL("pane.title", title)) continue;
 698                 if (READ_BOOL_FULL("pane.expanded", expanded)) continue;
 699
 700                 DEBUG_1("unknown attribute %s = %s", option, value);
 701                 }
 702
 703         return bar_pane_exif_new(title, expanded, FALSE);
 704 }
 705
 706 void bar_pane_exif_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
 707 {
 708         PaneExifData *ped;
 709         gchar *key = NULL;
 710         gchar *title = NULL;
 711         gboolean if_set = TRUE;
 712
 713         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 714         if (!ped) return;
 715
 716         while (*attribute_names)
 717                 {
 718                 const gchar *option = *attribute_names++;
 719                 const gchar *value = *attribute_values++;
 720
 721                 if (READ_CHAR_FULL("key", key)) continue;
 722                 if (READ_CHAR_FULL("title", title)) continue;
 723                 if (READ_BOOL_FULL("if_set", if_set)) continue;
 724
 725                 DEBUG_1("unknown attribute %s = %s", option, value);
 726                 }
 727
 728         if (key && key[0]) bar_pane_exif_add_entry(ped, key, title, if_set);
 729 }
 730
 731
 732 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */