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 /*
 236  *-------------------------------------------------------------------
 237  * dnd
 238  *-------------------------------------------------------------------
 239  */
 240
 241 static GtkTargetEntry bar_pane_exif_drag_types[] = {
 242         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 243         { "text/plain", 0, TARGET_TEXT_PLAIN }
 244 };
 245 static gint n_exif_entry_drag_types = 2;
 246
 247 static GtkTargetEntry bar_pane_exif_drop_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_drop_types = 2;
 252
 253
 254 static void bar_pane_exif_entry_dnd_get(GtkWidget *entry, GdkDragContext *context,
 255                                      GtkSelectionData *selection_data, guint info,
 256                                      guint time, gpointer data)
 257 {
 258         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 259
 260         switch (info)
 261                 {
 262                 case TARGET_APP_EXIF_ENTRY:
 263                         gtk_selection_data_set(selection_data, selection_data->target,
 264                                                8, (gpointer) &entry, sizeof(entry));
 265                         break;
 266
 267                 case TARGET_TEXT_PLAIN:
 268                 default:
 269                         gtk_selection_data_set_text(selection_data, ee->key, -1);
 270                         break;
 271                 }
 272
 273 }
 274
 275 static void bar_pane_exif_dnd_receive(GtkWidget *pane, GdkDragContext *context,
 276                                           gint x, gint y,
 277                                           GtkSelectionData *selection_data, guint info,
 278                                           guint time, gpointer data)
 279 {
 280         PaneExifData *ped;
 281         GList *work, *list;
 282         gint pos;
 283         GtkWidget *new_entry = NULL;
 284
 285         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 286         if (!ped) return;
 287
 288         switch (info)
 289                 {
 290                 case TARGET_APP_EXIF_ENTRY:
 291                         new_entry = *(gpointer *)selection_data->data;
 292
 293                         if (new_entry->parent && new_entry->parent != ped->vbox) bar_pane_exif_reparent_entry(new_entry, pane);
 294
 295                         break;
 296                 default:
 297                         /* FIXME: this needs a check for valid exif keys */
 298                         new_entry = bar_pane_exif_add_entry(ped, (gchar *)selection_data->data, NULL, TRUE);
 299                         break;
 300                 }
 301
 302         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 303         work = list;
 304         pos = 0;
 305         while (work)
 306                 {
 307                 gint nx, ny;
 308                 GtkWidget *entry = work->data;
 309                 work = work->next;
 310
 311                 if (entry == new_entry) continue;
 312
 313                 if (GTK_WIDGET_DRAWABLE(entry) &&
 314                     gtk_widget_translate_coordinates(pane, entry, x, y, &nx, &ny) &&
 315                     ny < entry->allocation.height / 2) break;
 316                 pos++;
 317                 }
 318         g_list_free(list);
 319
 320         gtk_box_reorder_child(GTK_BOX(ped->vbox), new_entry, pos);
 321 }
 322
 323 static void bar_pane_exif_entry_dnd_begin(GtkWidget *entry, GdkDragContext *context, gpointer data)
 324 {
 325         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 326
 327         if (!ee) return;
 328         dnd_set_drag_label(entry, context, ee->key);
 329 }
 330
 331 static void bar_pane_exif_entry_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 332 {
 333 }
 334
 335 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry)
 336 {
 337         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 338
 339         gtk_drag_source_set(entry, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 340                             bar_pane_exif_drag_types, n_exif_entry_drag_types,
 341                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 342         g_signal_connect(G_OBJECT(entry), "drag_data_get",
 343                          G_CALLBACK(bar_pane_exif_entry_dnd_get), ee);
 344
 345         g_signal_connect(G_OBJECT(entry), "drag_begin",
 346                          G_CALLBACK(bar_pane_exif_entry_dnd_begin), ee);
 347         g_signal_connect(G_OBJECT(entry), "drag_end",
 348                          G_CALLBACK(bar_pane_exif_entry_dnd_end), ee);
 349 }
 350
 351 static void bar_pane_exif_dnd_init(GtkWidget *pane)
 352 {
 353         gtk_drag_dest_set(pane,
 354                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
 355                           bar_pane_exif_drop_types, n_exif_entry_drop_types,
 356                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
 357         g_signal_connect(G_OBJECT(pane), "drag_data_received",
 358                          G_CALLBACK(bar_pane_exif_dnd_receive), NULL);
 359 }
 360
 361 static void bar_pane_exif_edit_close_cb(GtkWidget *widget, gpointer data)
 362 {
 363         GenericDialog *gd = data;
 364         generic_dialog_close(gd);
 365 }
 366
 367 static void bar_pane_exif_edit_destroy_cb(GtkWidget *widget, gpointer data)
 368 {
 369         ConfDialogData *cdd = data;
 370         g_signal_handlers_disconnect_by_func(cdd->widget, G_CALLBACK(bar_pane_exif_edit_close_cb), cdd->gd);
 371         g_free(cdd);
 372 }
 373
 374 static void bar_pane_exif_edit_cancel_cb(GenericDialog *gd, gpointer data)
 375 {
 376 }
 377
 378 static void bar_pane_exif_edit_ok_cb(GenericDialog *gd, gpointer data)
 379 {
 380         ConfDialogData *cdd = data;
 381
 382         /* either one or the other */
 383         PaneExifData *ped = g_object_get_data(G_OBJECT(cdd->widget), "pane_data");
 384         ExifEntry *ee = g_object_get_data(G_OBJECT(cdd->widget), "entry_data");
 385
 386         if (ped)
 387                 {
 388                 bar_pane_exif_add_entry(ped,
 389                                         gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)),
 390                                         gtk_entry_get_text(GTK_ENTRY(cdd->title_entry)),
 391                                         cdd->if_set);
 392                 }
 393
 394         if (ee)
 395                 {
 396                 const gchar *title;
 397                 GtkWidget *pane = cdd->widget->parent;
 398
 399                 while (pane)
 400                         {
 401                         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 402                         if (ped) break;
 403                         pane = pane->parent;
 404                         }
 405
 406                 if (!pane) return;
 407
 408                 g_free(ee->key);
 409                 ee->key = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)));
 410                 title = gtk_entry_get_text(GTK_ENTRY(cdd->title_entry));
 411                 if (strcmp(ee->title, title) != 0)
 412                         {
 413                         g_free(ee->title);
 414                         ee->title = g_strdup(title);
 415                         ee->auto_title = FALSE;
 416                         }
 417
 418                 ee->if_set = cdd->if_set;
 419
 420                 bar_pane_exif_entry_update_title(ee);
 421                 bar_pane_exif_update(ped);
 422                 }
 423 }
 424
 425 static void bar_pane_exif_conf_dialog(GtkWidget *widget)
 426 {
 427         ConfDialogData *cdd;
 428         GenericDialog *gd;
 429         GtkWidget *table;
 430
 431         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 432            we can decide it by the attached data */
 433         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 434
 435         cdd = g_new0(ConfDialogData, 1);
 436
 437         cdd->widget = widget;
 438
 439
 440         cdd->if_set = ee ? ee->if_set : TRUE;
 441
 442         cdd->gd = gd = generic_dialog_new(ee ? _("Configure entry") : _("Add entry"), "exif_entry_edit",
 443                                 widget, TRUE,
 444                                 bar_pane_exif_edit_cancel_cb, cdd);
 445         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 446                          G_CALLBACK(bar_pane_exif_edit_destroy_cb), cdd);
 447
 448         /* in case the entry is deleted during editing */
 449         g_signal_connect(G_OBJECT(widget), "destroy",
 450                          G_CALLBACK(bar_pane_exif_edit_close_cb), gd);
 451
 452         generic_dialog_add_message(gd, NULL, ee ? _("Configure entry") : _("Add entry"), NULL);
 453
 454         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
 455                                   bar_pane_exif_edit_ok_cb, TRUE);
 456
 457         table = pref_table_new(gd->vbox, 3, 2, FALSE, TRUE);
 458         pref_table_label(table, 0, 0, _("Key:"), 1.0);
 459
 460         cdd->key_entry = gtk_entry_new();
 461         gtk_widget_set_size_request(cdd->key_entry, 300, -1);
 462         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->key_entry), ee->key);
 463         gtk_table_attach_defaults(GTK_TABLE(table), cdd->key_entry, 1, 2, 0, 1);
 464         generic_dialog_attach_default(gd, cdd->key_entry);
 465         gtk_widget_show(cdd->key_entry);
 466
 467         pref_table_label(table, 0, 1, _("Title:"), 1.0);
 468
 469         cdd->title_entry = gtk_entry_new();
 470         gtk_widget_set_size_request(cdd->title_entry, 300, -1);
 471         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->title_entry), ee->title);
 472         gtk_table_attach_defaults(GTK_TABLE(table), cdd->title_entry, 1, 2, 1, 2);
 473         generic_dialog_attach_default(gd, cdd->title_entry);
 474         gtk_widget_show(cdd->title_entry);
 475
 476         pref_checkbox_new_int(gd->vbox, _("Show only if set"), cdd->if_set, &cdd->if_set);
 477
 478         gtk_widget_show(gd->dialog);
 479 }
 480
 481 static void bar_pane_exif_conf_dialog_cb(GtkWidget *menu_widget, gpointer data)
 482 {
 483         GtkWidget *widget = data;
 484         bar_pane_exif_conf_dialog(widget);
 485 }
 486
 487 static void bar_pane_exif_delete_entry_cb(GtkWidget *menu_widget, gpointer data)
 488 {
 489         GtkWidget *entry = data;
 490         gtk_widget_destroy(entry);
 491 }
 492
 493 static void bar_pane_exif_toggle_show_all_cb(GtkWidget *menu_widget, gpointer data)
 494 {
 495         PaneExifData *ped = data;
 496         ped->show_all = !ped->show_all;
 497         bar_pane_exif_update(ped);
 498 }
 499
 500 static void bar_pane_exif_menu_popup(GtkWidget *widget, PaneExifData *ped)
 501 {
 502         GtkWidget *menu;
 503         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 504            we can decide it by the attached data */
 505         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 506
 507         menu = popup_menu_short_lived();
 508
 509         if (ee)
 510                 {
 511                 /* for the entry */
 512                 gchar *conf = g_strdup_printf(_("Configure \"%s\""), ee->title);
 513                 gchar *del = g_strdup_printf(_("Delete \"%s\""), ee->title);
 514
 515                 menu_item_add_stock(menu, conf, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_exif_conf_dialog_cb), widget);
 516                 menu_item_add_stock(menu, del, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_exif_delete_entry_cb), widget);
 517                 menu_item_add_divider(menu);
 518
 519                 g_free(conf);
 520                 g_free(del);
 521                 }
 522
 523         /* for the pane */
 524         menu_item_add_stock(menu, _("Add entry"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_exif_conf_dialog_cb), ped->widget);
 525         menu_item_add_check(menu, _("Show hidden entries"), ped->show_all, G_CALLBACK(bar_pane_exif_toggle_show_all_cb), ped);
 526
 527         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
 528 }
 529
 530 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
 531 {
 532         PaneExifData *ped = data;
 533         if (bevent->button == MOUSE_BUTTON_RIGHT)
 534                 {
 535                 bar_pane_exif_menu_popup(widget, ped);
 536                 return TRUE;
 537                 }
 538         return FALSE;
 539 }
 540
 541 static void bar_pane_exif_entry_write_config(GtkWidget *entry, GString *outstr, gint indent)
 542 {
 543         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 544         if (!ee) return;
 545
 546         WRITE_STRING("<entry\n");
 547         indent++;
 548         WRITE_CHAR(*ee, key);
 549         if (!ee->auto_title) WRITE_CHAR(*ee, title);
 550         WRITE_BOOL(*ee, if_set);
 551         indent--;
 552         WRITE_STRING("/>\n");
 553 }
 554
 555 static void bar_pane_exif_write_config(GtkWidget *pane, GString *outstr, gint indent)
 556 {
 557         PaneExifData *ped;
 558         GList *work, *list;
 559
 560         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 561         if (!ped) return;
 562
 563         WRITE_STRING("<pane_exif\n");
 564         indent++;
 565         write_char_option(outstr, indent, "pane.title", gtk_label_get_text(GTK_LABEL(ped->pane.title)));
 566         WRITE_BOOL(*ped, pane.expanded);
 567         indent--;
 568         WRITE_STRING(">\n");
 569         indent++;
 570
 571         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 572         work = list;
 573         while (work)
 574                 {
 575                 GtkWidget *entry = work->data;
 576                 work = work->next;
 577
 578                 bar_pane_exif_entry_write_config(entry, outstr, indent);
 579                 }
 580         g_list_free(list);
 581         indent--;
 582         WRITE_STRING("</pane_exif>\n");
 583 }
 584
 585
 586 void bar_pane_exif_close(GtkWidget *widget)
 587 {
 588         PaneExifData *ped;
 589
 590         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 591         if (!ped) return;
 592
 593         gtk_widget_destroy(ped->vbox);
 594 }
 595
 596 static void bar_pane_exif_destroy(GtkWidget *widget, gpointer data)
 597 {
 598         PaneExifData *ped = data;
 599
 600         g_object_unref(ped->size_group);
 601         file_data_unref(ped->fd);
 602         g_free(ped);
 603 }
 604
 605 static void bar_pane_exif_size_request(GtkWidget *pane, GtkRequisition *requisition, gpointer data)
 606 {
 607         PaneExifData *ped = data;
 608         if (requisition->height < ped->min_height)
 609                 {
 610                 requisition->height = ped->min_height;
 611                 }
 612 }
 613
 614 static void bar_pane_exif_size_allocate(GtkWidget *pane, GtkAllocation *alloc, gpointer data)
 615 {
 616         PaneExifData *ped = data;
 617         ped->min_height = alloc->height;
 618 }
 619
 620 GtkWidget *bar_pane_exif_new(const gchar *title, gboolean expanded, gboolean populate)
 621 {
 622         PaneExifData *ped;
 623
 624         ped = g_new0(PaneExifData, 1);
 625
 626         ped->pane.pane_set_fd = bar_pane_exif_set_fd;
 627         ped->pane.pane_write_config = bar_pane_exif_write_config;
 628         ped->pane.title = bar_pane_expander_title(title);
 629         ped->pane.expanded = expanded;
 630
 631         ped->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 632         ped->widget = gtk_event_box_new();
 633         ped->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 634         gtk_container_add(GTK_CONTAINER(ped->widget), ped->vbox);
 635         gtk_widget_show(ped->vbox);
 636
 637         ped->min_height = MIN_HEIGHT;
 638         g_object_set_data(G_OBJECT(ped->widget), "pane_data", ped);
 639         g_signal_connect_after(G_OBJECT(ped->widget), "destroy",
 640                                G_CALLBACK(bar_pane_exif_destroy), ped);
 641         g_signal_connect(G_OBJECT(ped->widget), "size-request",
 642                          G_CALLBACK(bar_pane_exif_size_request), ped);
 643         g_signal_connect(G_OBJECT(ped->widget), "size-allocate",
 644                          G_CALLBACK(bar_pane_exif_size_allocate), ped);
 645
 646         bar_pane_exif_dnd_init(ped->widget);
 647         g_signal_connect(ped->widget, "button_press_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 648
 649         if (populate)
 650                 {
 651                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Camera"), NULL, TRUE);
 652                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("DateTime"), NULL, TRUE);
 653                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ShutterSpeed"), NULL, TRUE);
 654                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Aperture"), NULL, TRUE);
 655                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ExposureBias"), NULL, TRUE);
 656                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ISOSpeedRating"), NULL, TRUE);
 657                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("FocalLength"), NULL, TRUE);
 658                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("FocalLength35mmFilm"), NULL, TRUE);
 659                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Flash"), NULL, TRUE);
 660                 bar_pane_exif_add_entry(ped, "Exif.Photo.ExposureProgram", NULL, TRUE);
 661                 bar_pane_exif_add_entry(ped, "Exif.Photo.MeteringMode", NULL, TRUE);
 662                 bar_pane_exif_add_entry(ped, "Exif.Photo.LightSource", NULL, TRUE);
 663                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ColorProfile"), NULL, TRUE);
 664                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("SubjectDistance"), NULL, TRUE);
 665                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Resolution"), NULL, TRUE);
 666                 bar_pane_exif_add_entry(ped, "Exif.Image.Orientation", NULL, TRUE);
 667                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("GPSPosition"), NULL, TRUE);
 668                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("GPSAltitude"), NULL, TRUE);
 669                 bar_pane_exif_add_entry(ped, "Exif.Image.ImageDescription", NULL, TRUE);
 670                 bar_pane_exif_add_entry(ped, "Exif.Image.Copyright", NULL, TRUE);
 671                 }
 672
 673         gtk_widget_show(ped->widget);
 674
 675         return ped->widget;
 676 }
 677
 678 GtkWidget *bar_pane_exif_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
 679 {
 680         gchar *title = g_strdup(_("NoName"));
 681         gboolean expanded = TRUE;
 682
 683         while (*attribute_names)
 684                 {
 685                 const gchar *option = *attribute_names++;
 686                 const gchar *value = *attribute_values++;
 687
 688                 if (READ_CHAR_FULL("pane.title", title)) continue;
 689                 if (READ_BOOL_FULL("pane.expanded", expanded)) continue;
 690
 691                 DEBUG_1("unknown attribute %s = %s", option, value);
 692                 }
 693
 694         return bar_pane_exif_new(title, expanded, FALSE);
 695 }
 696
 697 void bar_pane_exif_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
 698 {
 699         PaneExifData *ped;
 700         gchar *key = NULL;
 701         gchar *title = NULL;
 702         gboolean if_set = TRUE;
 703
 704         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 705         if (!ped) return;
 706
 707         while (*attribute_names)
 708                 {
 709                 const gchar *option = *attribute_names++;
 710                 const gchar *value = *attribute_values++;
 711
 712                 if (READ_CHAR_FULL("key", key)) continue;
 713                 if (READ_CHAR_FULL("title", title)) continue;
 714                 if (READ_BOOL_FULL("if_set", if_set)) continue;
 715
 716                 DEBUG_1("unknown attribute %s = %s", option, value);
 717                 }
 718
 719         if (key && key[0]) bar_pane_exif_add_entry(ped, key, title, if_set);
 720 }
 721
 722
 723 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */