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         if (!ped || !old_ped || !ee) return;
 154
 155         g_object_ref(entry);
 156
 157         gtk_size_group_remove_widget(old_ped->size_group, ee->title_label);
 158         gtk_container_remove(GTK_CONTAINER(old_ped->vbox), entry);
 159
 160         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 161         gtk_box_pack_start(GTK_BOX(ped->vbox), entry, FALSE, FALSE, 0);
 162 }
 163
 164 static void bar_pane_exif_entry_update_title(ExifEntry *ee)
 165 {
 166         gchar *markup;
 167
 168         markup = g_markup_printf_escaped("<span size='small'>%s:</span>", (ee->title) ? ee->title : "fixme");
 169         gtk_label_set_markup(GTK_LABEL(ee->title_label), markup);
 170         g_free(markup);
 171 }
 172
 173 static void bar_pane_exif_update_entry(PaneExifData *ped, GtkWidget *entry, gboolean update_title)
 174 {
 175         gchar *text;
 176         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 177         if (!ee) return;
 178         text = metadata_read_string(ped->fd, ee->key, METADATA_FORMATTED);
 179
 180         if (!ped->show_all && ee->if_set && (!text || !*text))
 181                 {
 182                 gtk_label_set_text(GTK_LABEL(ee->value_label), NULL);
 183                 gtk_widget_hide(entry);
 184                 }
 185         else
 186                 {
 187                 gtk_label_set_text(GTK_LABEL(ee->value_label), text);
 188 #if GTK_CHECK_VERSION(2,12,0)
 189                 gtk_widget_set_tooltip_text(ee->hbox, text);
 190 #endif
 191                 gtk_widget_show(entry);
 192                 ped->all_hidden = FALSE;
 193                 }
 194
 195         g_free(text);
 196
 197         if (update_title) bar_pane_exif_entry_update_title(ee);
 198 }
 199
 200 static void bar_pane_exif_update(PaneExifData *ped)
 201 {
 202         GList *list, *work;
 203
 204         ped->all_hidden = TRUE;
 205
 206         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 207         work = list;
 208         while (work)
 209                 {
 210                 GtkWidget *entry = work->data;
 211                 work = work->next;
 212
 213
 214                 bar_pane_exif_update_entry(ped, entry, FALSE);
 215                 }
 216         g_list_free(list);
 217
 218         gtk_widget_set_sensitive(ped->pane.title, !ped->all_hidden);
 219 }
 220
 221 void bar_pane_exif_set_fd(GtkWidget *widget, FileData *fd)
 222 {
 223         PaneExifData *ped;
 224
 225         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 226         if (!ped) return;
 227
 228         file_data_unref(ped->fd);
 229         ped->fd = file_data_ref(fd);
 230
 231         bar_pane_exif_update(ped);
 232 }
 233
 234 /*
 235  *-------------------------------------------------------------------
 236  * dnd
 237  *-------------------------------------------------------------------
 238  */
 239
 240 static GtkTargetEntry bar_pane_exif_drag_types[] = {
 241         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 242         { "text/plain", 0, TARGET_TEXT_PLAIN }
 243 };
 244 static gint n_exif_entry_drag_types = 2;
 245
 246 static GtkTargetEntry bar_pane_exif_drop_types[] = {
 247         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 248         { "text/plain", 0, TARGET_TEXT_PLAIN }
 249 };
 250 static gint n_exif_entry_drop_types = 2;
 251
 252
 253 static void bar_pane_exif_entry_dnd_get(GtkWidget *entry, GdkDragContext *context,
 254                                      GtkSelectionData *selection_data, guint info,
 255                                      guint time, gpointer data)
 256 {
 257         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 258
 259         switch (info)
 260                 {
 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         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 285         if (!ped) return;
 286
 287         switch (info)
 288                 {
 289                 case TARGET_APP_EXIF_ENTRY:
 290                         new_entry = *(gpointer *)selection_data->data;
 291
 292                         if (new_entry->parent && new_entry->parent != ped->vbox) bar_pane_exif_reparent_entry(new_entry, pane);
 293
 294                         break;
 295                 default:
 296                         /* FIXME: this needs a check for valid exif keys */
 297                         new_entry = bar_pane_exif_add_entry(ped, (gchar *)selection_data->data, NULL, TRUE);
 298                         break;
 299                 }
 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         if (!ee) return;
 327         dnd_set_drag_label(entry, context, ee->key);
 328 }
 329
 330 static void bar_pane_exif_entry_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 331 {
 332 }
 333
 334 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry)
 335 {
 336         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 337
 338         gtk_drag_source_set(entry, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 339                             bar_pane_exif_drag_types, n_exif_entry_drag_types,
 340                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 341         g_signal_connect(G_OBJECT(entry), "drag_data_get",
 342                          G_CALLBACK(bar_pane_exif_entry_dnd_get), ee);
 343
 344         g_signal_connect(G_OBJECT(entry), "drag_begin",
 345                          G_CALLBACK(bar_pane_exif_entry_dnd_begin), ee);
 346         g_signal_connect(G_OBJECT(entry), "drag_end",
 347                          G_CALLBACK(bar_pane_exif_entry_dnd_end), ee);
 348 }
 349
 350 static void bar_pane_exif_dnd_init(GtkWidget *pane)
 351 {
 352         gtk_drag_dest_set(pane,
 353                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
 354                           bar_pane_exif_drop_types, n_exif_entry_drop_types,
 355                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
 356         g_signal_connect(G_OBJECT(pane), "drag_data_received",
 357                          G_CALLBACK(bar_pane_exif_dnd_receive), NULL);
 358 }
 359
 360 static void bar_pane_exif_edit_close_cb(GtkWidget *widget, gpointer data)
 361 {
 362         GenericDialog *gd = data;
 363         generic_dialog_close(gd);
 364 }
 365
 366 static void bar_pane_exif_edit_destroy_cb(GtkWidget *widget, gpointer data)
 367 {
 368         ConfDialogData *cdd = data;
 369         g_signal_handlers_disconnect_by_func(cdd->widget, G_CALLBACK(bar_pane_exif_edit_close_cb), cdd->gd);
 370         g_free(cdd);
 371 }
 372
 373 static void bar_pane_exif_edit_cancel_cb(GenericDialog *gd, gpointer data)
 374 {
 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         if (ee)
 394                 {
 395                 const gchar *title;
 396                 GtkWidget *pane = cdd->widget->parent;
 397                 while (pane)
 398                         {
 399                         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 400                         if (ped) break;
 401                         pane = pane->parent;
 402                         }
 403
 404                 if (!pane) return;
 405
 406                 g_free(ee->key);
 407                 ee->key = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)));
 408                 title = gtk_entry_get_text(GTK_ENTRY(cdd->title_entry));
 409                 if (strcmp(ee->title, title) != 0)
 410                         {
 411                         g_free(ee->title);
 412                         ee->title = g_strdup(title);
 413                         ee->auto_title = FALSE;
 414                         }
 415
 416                 ee->if_set = cdd->if_set;
 417
 418                 bar_pane_exif_entry_update_title(ee);
 419                 bar_pane_exif_update(ped);
 420                 }
 421 }
 422
 423 static void bar_pane_exif_conf_dialog(GtkWidget *widget)
 424 {
 425         ConfDialogData *cdd;
 426         GenericDialog *gd;
 427         GtkWidget *table;
 428
 429         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 430            we can decide it by the attached data */
 431         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 432
 433         cdd = g_new0(ConfDialogData, 1);
 434
 435         cdd->widget = widget;
 436
 437
 438         cdd->if_set = ee ? ee->if_set : TRUE;
 439
 440         cdd->gd = gd = generic_dialog_new(ee ? _("Configure entry") : _("Add entry"), "exif_entry_edit",
 441                                 widget, TRUE,
 442                                 bar_pane_exif_edit_cancel_cb, cdd);
 443         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 444                          G_CALLBACK(bar_pane_exif_edit_destroy_cb), cdd);
 445
 446         /* in case the entry is deleted during editing */
 447         g_signal_connect(G_OBJECT(widget), "destroy",
 448                          G_CALLBACK(bar_pane_exif_edit_close_cb), gd);
 449
 450         generic_dialog_add_message(gd, NULL, ee ? _("Configure entry") : _("Add entry"), NULL);
 451
 452         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
 453                                   bar_pane_exif_edit_ok_cb, TRUE);
 454
 455         table = pref_table_new(gd->vbox, 3, 2, FALSE, TRUE);
 456         pref_table_label(table, 0, 0, _("Key:"), 1.0);
 457
 458         cdd->key_entry = gtk_entry_new();
 459         gtk_widget_set_size_request(cdd->key_entry, 300, -1);
 460         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->key_entry), ee->key);
 461         gtk_table_attach_defaults(GTK_TABLE(table), cdd->key_entry, 1, 2, 0, 1);
 462         generic_dialog_attach_default(gd, cdd->key_entry);
 463         gtk_widget_show(cdd->key_entry);
 464
 465         pref_table_label(table, 0, 1, _("Title:"), 1.0);
 466
 467         cdd->title_entry = gtk_entry_new();
 468         gtk_widget_set_size_request(cdd->title_entry, 300, -1);
 469         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->title_entry), ee->title);
 470         gtk_table_attach_defaults(GTK_TABLE(table), cdd->title_entry, 1, 2, 1, 2);
 471         generic_dialog_attach_default(gd, cdd->title_entry);
 472         gtk_widget_show(cdd->title_entry);
 473
 474         pref_checkbox_new_int(gd->vbox, _("Show only if set"), cdd->if_set, &cdd->if_set);
 475
 476         gtk_widget_show(gd->dialog);
 477 }
 478
 479 static void bar_pane_exif_conf_dialog_cb(GtkWidget *menu_widget, gpointer data)
 480 {
 481         GtkWidget *widget = data;
 482         bar_pane_exif_conf_dialog(widget);
 483 }
 484
 485 static void bar_pane_exif_delete_entry_cb(GtkWidget *menu_widget, gpointer data)
 486 {
 487         GtkWidget *entry = data;
 488         gtk_widget_destroy(entry);
 489 }
 490
 491 static void bar_pane_exif_toggle_show_all_cb(GtkWidget *menu_widget, gpointer data)
 492 {
 493         PaneExifData *ped = data;
 494         ped->show_all = !ped->show_all;
 495         bar_pane_exif_update(ped);
 496 }
 497
 498 static void bar_pane_exif_menu_popup(GtkWidget *widget, PaneExifData *ped)
 499 {
 500         GtkWidget *menu;
 501         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 502            we can decide it by the attached data */
 503         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 504
 505         menu = popup_menu_short_lived();
 506
 507         if (ee)
 508                 {
 509                 /* for the entry */
 510                 gchar *conf = g_strdup_printf(_("Configure \"%s\""), ee->title);
 511                 gchar *del = g_strdup_printf(_("Delete \"%s\""), ee->title);
 512                 menu_item_add_stock(menu, conf, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_exif_conf_dialog_cb), widget);
 513                 menu_item_add_stock(menu, del, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_exif_delete_entry_cb), widget);
 514                 menu_item_add_divider(menu);
 515                 g_free(conf);
 516                 g_free(del);
 517                 }
 518         /* for the pane */
 519         menu_item_add_stock(menu, _("Add entry"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_exif_conf_dialog_cb), ped->widget);
 520         menu_item_add_check(menu, _("Show hidden entries"), ped->show_all, G_CALLBACK(bar_pane_exif_toggle_show_all_cb), ped);
 521
 522         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
 523 }
 524
 525
 526 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
 527 {
 528         PaneExifData *ped = data;
 529         if (bevent->button == MOUSE_BUTTON_RIGHT)
 530                 {
 531                 bar_pane_exif_menu_popup(widget, ped);
 532                 return TRUE;
 533                 }
 534         return FALSE;
 535 }
 536
 537
 538
 539
 540 static void bar_pane_exif_entry_write_config(GtkWidget *entry, GString *outstr, gint indent)
 541 {
 542         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 543         if (!ee) return;
 544
 545         WRITE_STRING("<entry\n");
 546         indent++;
 547         WRITE_CHAR(*ee, key);
 548         if (!ee->auto_title) WRITE_CHAR(*ee, title);
 549         WRITE_BOOL(*ee, if_set);
 550         indent--;
 551         WRITE_STRING("/>\n");
 552 }
 553
 554 static void bar_pane_exif_write_config(GtkWidget *pane, GString *outstr, gint indent)
 555 {
 556         PaneExifData *ped;
 557         GList *work, *list;
 558
 559         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 560         if (!ped) return;
 561
 562         WRITE_STRING("<pane_exif\n");
 563         indent++;
 564         write_char_option(outstr, indent, "pane.title", gtk_label_get_text(GTK_LABEL(ped->pane.title)));
 565         WRITE_BOOL(*ped, pane.expanded);
 566         indent--;
 567         WRITE_STRING(">\n");
 568         indent++;
 569
 570         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 571         work = list;
 572         while (work)
 573                 {
 574                 GtkWidget *entry = work->data;
 575                 work = work->next;
 576
 577                 bar_pane_exif_entry_write_config(entry, outstr, indent);
 578                 }
 579         g_list_free(list);
 580         indent--;
 581         WRITE_STRING("</pane_exif>\n");
 582 }
 583
 584
 585 void bar_pane_exif_close(GtkWidget *widget)
 586 {
 587         PaneExifData *ped;
 588
 589         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 590         if (!ped) return;
 591
 592         gtk_widget_destroy(ped->vbox);
 593 }
 594
 595 static void bar_pane_exif_destroy(GtkWidget *widget, gpointer data)
 596 {
 597         PaneExifData *ped = data;
 598
 599         g_object_unref(ped->size_group);
 600         file_data_unref(ped->fd);
 601         g_free(ped);
 602 }
 603
 604 static void bar_pane_exif_size_request(GtkWidget *pane, GtkRequisition *requisition, gpointer data)
 605 {
 606         PaneExifData *ped = data;
 607         if (requisition->height < ped->min_height)
 608                 {
 609                 requisition->height = ped->min_height;
 610                 }
 611 }
 612
 613 static void bar_pane_exif_size_allocate(GtkWidget *pane, GtkAllocation *alloc, gpointer data)
 614 {
 615         PaneExifData *ped = data;
 616         ped->min_height = alloc->height;
 617 }
 618
 619 GtkWidget *bar_pane_exif_new(const gchar *title, gboolean expanded, gboolean populate)
 620 {
 621         PaneExifData *ped;
 622
 623         ped = g_new0(PaneExifData, 1);
 624
 625         ped->pane.pane_set_fd = bar_pane_exif_set_fd;
 626         ped->pane.pane_write_config = bar_pane_exif_write_config;
 627         ped->pane.title = bar_pane_expander_title(title);
 628         ped->pane.expanded = expanded;
 629
 630         ped->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 631         ped->widget = gtk_event_box_new();;
 632         ped->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 633         gtk_container_add(GTK_CONTAINER(ped->widget), ped->vbox);
 634         gtk_widget_show(ped->vbox);
 635
 636         ped->min_height = MIN_HEIGHT;
 637         g_object_set_data(G_OBJECT(ped->widget), "pane_data", ped);
 638         g_signal_connect_after(G_OBJECT(ped->widget), "destroy",
 639                                G_CALLBACK(bar_pane_exif_destroy), ped);
 640         g_signal_connect(G_OBJECT(ped->widget), "size-request",
 641                          G_CALLBACK(bar_pane_exif_size_request), ped);
 642         g_signal_connect(G_OBJECT(ped->widget), "size-allocate",
 643                          G_CALLBACK(bar_pane_exif_size_allocate), ped);
 644
 645         bar_pane_exif_dnd_init(ped->widget);
 646         g_signal_connect(ped->widget, "button_press_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 647
 648         if (populate)
 649                 {
 650                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Camera"), NULL, TRUE);
 651                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("DateTime"), NULL, TRUE);
 652                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ShutterSpeed"), NULL, TRUE);
 653                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Aperture"), NULL, TRUE);
 654                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ExposureBias"), NULL, TRUE);
 655                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ISOSpeedRating"), NULL, TRUE);
 656                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("FocalLength"), NULL, TRUE);
 657                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("FocalLength35mmFilm"), NULL, TRUE);
 658                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Flash"), NULL, TRUE);
 659                 bar_pane_exif_add_entry(ped, "Exif.Photo.ExposureProgram", NULL, TRUE);
 660                 bar_pane_exif_add_entry(ped, "Exif.Photo.MeteringMode", NULL, TRUE);
 661                 bar_pane_exif_add_entry(ped, "Exif.Photo.LightSource", NULL, TRUE);
 662                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ColorProfile"), NULL, TRUE);
 663                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("SubjectDistance"), NULL, TRUE);
 664                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Resolution"), NULL, TRUE);
 665                 bar_pane_exif_add_entry(ped, "Exif.Image.Orientation", NULL, TRUE);
 666                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("GPSPosition"), NULL, TRUE);
 667                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("GPSAltitude"), NULL, TRUE);
 668                 bar_pane_exif_add_entry(ped, "Exif.Image.ImageDescription", NULL, TRUE);
 669                 bar_pane_exif_add_entry(ped, "Exif.Image.Copyright", NULL, TRUE);
 670                 }
 671
 672         gtk_widget_show(ped->widget);
 673
 674         return ped->widget;
 675 }
 676
 677 GtkWidget *bar_pane_exif_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
 678 {
 679         gchar *title = g_strdup(_("NoName"));
 680         gboolean expanded = TRUE;
 681
 682         while (*attribute_names)
 683                 {
 684                 const gchar *option = *attribute_names++;
 685                 const gchar *value = *attribute_values++;
 686
 687                 if (READ_CHAR_FULL("pane.title", title)) continue;
 688                 if (READ_BOOL_FULL("pane.expanded", expanded)) continue;
 689
 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
 717                 DEBUG_1("unknown attribute %s = %s", option, value);
 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: */