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