src/bar_exif.c

   1 /*
   2  * Copyright (C) 2004 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: Vladimir Nadvornik
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "main.h"
  23 #include "bar-exif.h"
  24
  25 #include "exif.h"
  26 #include "metadata.h"
  27 #include "filedata.h"
  28 #include "history-list.h"
  29 #include "misc.h"
  30 #include "ui-misc.h"
  31 #include "ui-menu.h"
  32 #include "bar.h"
  33 #include "rcfile.h"
  34 #include "dnd.h"
  35 #include "ui-utildlg.h"
  36 #include "layout.h"
  37
  38
  39 #include <math.h>
  40
  41 #define MIN_HEIGHT 25
  42 /*
  43  *-------------------------------------------------------------------
  44  * EXIF widget
  45  *-------------------------------------------------------------------
  46  */
  47
  48 typedef struct _ExifEntry ExifEntry;
  49 typedef struct _PaneExifData PaneExifData;
  50
  51 struct _ExifEntry
  52 {
  53         GtkWidget *ebox;
  54         GtkWidget *box;
  55         GtkWidget *title_label;
  56         GtkWidget *value_widget;
  57
  58         gchar *key;
  59         gchar *title;
  60         gboolean if_set;
  61         gboolean auto_title;
  62         gboolean editable;
  63
  64         PaneExifData *ped;
  65 };
  66
  67
  68 struct _PaneExifData
  69 {
  70         PaneData pane;
  71         GtkWidget *vbox;
  72         GtkWidget *widget;
  73         GtkSizeGroup *size_group;
  74
  75         gint min_height;
  76
  77         gboolean all_hidden;
  78         gboolean show_all;
  79
  80         FileData *fd;
  81 };
  82
  83 typedef struct _ConfDialogData ConfDialogData;
  84 struct _ConfDialogData
  85 {
  86         GtkWidget *widget; /* pane or entry, devidet by presenceof "pane_data" or "entry_data" */
  87
  88         /* dialog parts */
  89         GenericDialog *gd;
  90         GtkWidget *key_entry;
  91         GtkWidget *title_entry;
  92         gboolean if_set;
  93         gboolean editable;
  94 };
  95
  96 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry);
  97 static void bar_pane_exif_entry_update_title(ExifEntry *ee);
  98 static void bar_pane_exif_update(PaneExifData *ped);
  99 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data);
 100 static void bar_pane_exif_notify_cb(FileData *fd, NotifyType type, gpointer data);
 101 static gboolean bar_pane_exif_copy_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data);
 102
 103 static void bar_pane_exif_entry_changed(GtkEntry *UNUSED(text_entry), gpointer data)
 104 {
 105         ExifEntry *ee = data;
 106         gchar *text;
 107         if (!ee->ped->fd) return;
 108
 109         text = text_widget_text_pull(ee->value_widget);
 110         metadata_write_string(ee->ped->fd, ee->key, text);
 111         g_free(text);
 112 }
 113
 114 static void bar_pane_exif_entry_destroy(GtkWidget *UNUSED(widget), gpointer data)
 115 {
 116         ExifEntry *ee = data;
 117
 118         g_free(ee->key);
 119         g_free(ee->title);
 120         g_free(ee);
 121 }
 122
 123 static void bar_pane_exif_setup_entry_box(PaneExifData *ped, ExifEntry *ee)
 124 {
 125         gboolean horizontal = !ee->editable;
 126         gboolean editable = ee->editable;
 127
 128         if (ee->box) gtk_widget_destroy(ee->box);
 129
 130         ee->box = horizontal ? gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) : gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 131         gtk_container_add(GTK_CONTAINER(ee->ebox), ee->box);
 132         gtk_widget_show(ee->box);
 133
 134         ee->title_label = gtk_label_new(NULL);
 135         gtk_label_set_xalign(GTK_LABEL(ee->title_label), horizontal ? 1.0 : 0.0);
 136         gtk_label_set_yalign(GTK_LABEL(ee->title_label), 0.5);
 137         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 138         gtk_box_pack_start(GTK_BOX(ee->box), ee->title_label, FALSE, TRUE, 0);
 139         gtk_widget_show(ee->title_label);
 140
 141         if (editable)
 142                 {
 143                 ee->value_widget = gtk_entry_new();
 144                 g_signal_connect(G_OBJECT(ee->value_widget), "changed",
 145                          G_CALLBACK(bar_pane_exif_entry_changed), ee);
 146
 147                 }
 148         else
 149                 {
 150                 ee->value_widget = gtk_label_new(NULL);
 151 //              gtk_label_set_width_chars(GTK_LABEL(ee->value_widget), 20);
 152                 gtk_label_set_ellipsize(GTK_LABEL(ee->value_widget), PANGO_ELLIPSIZE_END);
 153 //              gtk_widget_set_size_request(ee->value_widget, 100, -1);
 154                 gtk_label_set_xalign(GTK_LABEL(ee->value_widget), 0.0);
 155                 gtk_label_set_yalign(GTK_LABEL(ee->value_widget), 0.5);
 156                 }
 157
 158         gtk_box_pack_start(GTK_BOX(ee->box), ee->value_widget, TRUE, TRUE, 1);
 159         gtk_widget_show(ee->value_widget);
 160 }
 161
 162 static GtkWidget *bar_pane_exif_add_entry(PaneExifData *ped, const gchar *key, const gchar *title, gboolean if_set, gboolean editable)
 163 {
 164         ExifEntry *ee = g_new0(ExifEntry, 1);
 165
 166         ee->key = g_strdup(key);
 167         if (title && title[0])
 168                 {
 169                 ee->title = g_strdup(title);
 170                 }
 171         else
 172                 {
 173                 ee->title = exif_get_description_by_key(key);
 174                 ee->auto_title = TRUE;
 175                 }
 176
 177         ee->if_set = if_set;
 178         ee->editable = editable;
 179
 180         ee->ped = ped;
 181
 182         ee->ebox = gtk_event_box_new();
 183         g_object_set_data(G_OBJECT(ee->ebox), "entry_data", ee);
 184         g_signal_connect_after(G_OBJECT(ee->ebox), "destroy",
 185                                G_CALLBACK(bar_pane_exif_entry_destroy), ee);
 186
 187         gtk_box_pack_start(GTK_BOX(ped->vbox), ee->ebox, FALSE, FALSE, 0);
 188
 189         bar_pane_exif_entry_dnd_init(ee->ebox);
 190         g_signal_connect(ee->ebox, "button_release_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 191         g_signal_connect(ee->ebox, "button_press_event", G_CALLBACK(bar_pane_exif_copy_cb), ped);
 192
 193         bar_pane_exif_setup_entry_box(ped, ee);
 194
 195         bar_pane_exif_entry_update_title(ee);
 196         bar_pane_exif_update(ped);
 197
 198         return ee->ebox;
 199 }
 200
 201 static void bar_pane_exif_reparent_entry(GtkWidget *entry, GtkWidget *pane)
 202 {
 203         PaneExifData *ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 204         PaneExifData *old_ped;
 205         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 206
 207         if (!ped || !ee) return;
 208
 209         old_ped = ee->ped;
 210
 211         g_object_ref(entry);
 212
 213         gtk_size_group_remove_widget(old_ped->size_group, ee->title_label);
 214         gtk_container_remove(GTK_CONTAINER(old_ped->vbox), entry);
 215
 216         ee->ped = ped;
 217         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 218         gtk_box_pack_start(GTK_BOX(ped->vbox), entry, FALSE, FALSE, 0);
 219 }
 220
 221 static void bar_pane_exif_entry_update_title(ExifEntry *ee)
 222 {
 223         gchar *markup;
 224
 225         markup = g_markup_printf_escaped("<span size='small'>%s:</span>", (ee->title) ? ee->title : _("<empty label, fixme>"));
 226         gtk_label_set_markup(GTK_LABEL(ee->title_label), markup);
 227         g_free(markup);
 228 }
 229
 230 static void bar_pane_exif_update_entry(PaneExifData *ped, GtkWidget *entry, gboolean update_title)
 231 {
 232         gchar *text;
 233         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 234         gshort rating;
 235
 236         if (!ee) return;
 237         if (g_strcmp0(ee->key, "Xmp.xmp.Rating") == 0)
 238                 {
 239                 rating = metadata_read_int(ee->ped->fd, ee->key, 0);
 240                 text = g_strdup_printf("%d", rating);
 241                 }
 242         else
 243                 {
 244                 text = metadata_read_string(ped->fd, ee->key, ee->editable ? METADATA_PLAIN : METADATA_FORMATTED);
 245                 }
 246
 247         if (!ped->show_all && ee->if_set && !ee->editable && (!text || !*text))
 248                 {
 249                 gtk_label_set_text(GTK_LABEL(ee->value_widget), NULL);
 250                 gtk_widget_hide(entry);
 251                 }
 252         else
 253                 {
 254                 if (ee->editable)
 255                         {
 256                         g_signal_handlers_block_by_func(ee->value_widget, (gpointer *)bar_pane_exif_entry_changed, ee);
 257                         gtk_entry_set_text(GTK_ENTRY(ee->value_widget), text ? text : "");
 258                         g_signal_handlers_unblock_by_func(ee->value_widget, (gpointer)bar_pane_exif_entry_changed, ee);
 259                         gtk_widget_set_tooltip_text(ee->box, NULL);
 260                         }
 261                 else
 262                         {
 263                         gtk_label_set_text(GTK_LABEL(ee->value_widget), text);
 264                         gtk_widget_set_tooltip_text(ee->box, text);
 265                         }
 266                 gtk_widget_show(entry);
 267                 ped->all_hidden = FALSE;
 268                 }
 269
 270         g_free(text);
 271
 272         if (update_title) bar_pane_exif_entry_update_title(ee);
 273 }
 274
 275 static void bar_pane_exif_update(PaneExifData *ped)
 276 {
 277         GList *list, *work;
 278
 279         ped->all_hidden = TRUE;
 280
 281         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 282         work = list;
 283         while (work)
 284                 {
 285                 GtkWidget *entry = work->data;
 286                 work = work->next;
 287
 288                 bar_pane_exif_update_entry(ped, entry, FALSE);
 289                 }
 290         g_list_free(list);
 291
 292         gtk_widget_set_sensitive(ped->pane.title, !ped->all_hidden);
 293 }
 294
 295 void bar_pane_exif_set_fd(GtkWidget *widget, FileData *fd)
 296 {
 297         PaneExifData *ped;
 298
 299         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 300         if (!ped) return;
 301
 302         file_data_unref(ped->fd);
 303         ped->fd = file_data_ref(fd);
 304
 305         bar_pane_exif_update(ped);
 306 }
 307
 308 gint bar_pane_exif_event(GtkWidget *bar, GdkEvent *event)
 309 {
 310         PaneExifData *ped;
 311         gboolean ret = FALSE;
 312         GList *list, *work;
 313
 314         ped = g_object_get_data(G_OBJECT(bar), "pane_data");
 315         if (!ped) return FALSE;
 316
 317         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 318         work = list;
 319         while (!ret && work)
 320                 {
 321                 GtkWidget *entry = work->data;
 322                 ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 323                 work = work->next;
 324
 325                 if (ee->editable && gtk_widget_has_focus(ee->value_widget)) ret = gtk_widget_event(ee->value_widget, event);
 326                 }
 327         g_list_free(list);
 328         return ret;
 329 }
 330
 331 static void bar_pane_exif_notify_cb(FileData *fd, NotifyType type, gpointer data)
 332 {
 333         PaneExifData *ped = data;
 334         if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE | NOTIFY_METADATA)) && fd == ped->fd)
 335                 {
 336                 DEBUG_1("Notify pane_exif: %s %04x", fd->path, type);
 337                 bar_pane_exif_update(ped);
 338                 }
 339 }
 340
 341
 342 /*
 343  *-------------------------------------------------------------------
 344  * dnd
 345  *-------------------------------------------------------------------
 346  */
 347
 348 static GtkTargetEntry bar_pane_exif_drag_types[] = {
 349         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 350         { "text/plain", 0, TARGET_TEXT_PLAIN }
 351 };
 352 static gint n_exif_entry_drag_types = 2;
 353
 354 static GtkTargetEntry bar_pane_exif_drop_types[] = {
 355         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 356         { "text/plain", 0, TARGET_TEXT_PLAIN }
 357 };
 358 static gint n_exif_entry_drop_types = 2;
 359
 360
 361 static void bar_pane_exif_entry_dnd_get(GtkWidget *entry, GdkDragContext *UNUSED(context),
 362                                      GtkSelectionData *selection_data, guint info,
 363                                      guint UNUSED(time), gpointer UNUSED(data))
 364 {
 365         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 366
 367         switch (info)
 368                 {
 369                 case TARGET_APP_EXIF_ENTRY:
 370                         gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
 371                                                8, (gpointer) &entry, sizeof(entry));
 372                         break;
 373
 374                 case TARGET_TEXT_PLAIN:
 375                 default:
 376                         gtk_selection_data_set_text(selection_data, ee->key, -1);
 377                         break;
 378                 }
 379
 380 }
 381
 382 static void bar_pane_exif_dnd_receive(GtkWidget *pane, GdkDragContext *UNUSED(context),
 383                                           gint x, gint y,
 384                                           GtkSelectionData *selection_data, guint info,
 385                                           guint UNUSED(time), gpointer UNUSED(data))
 386 {
 387         PaneExifData *ped;
 388         GList *work, *list;
 389         gint pos;
 390         GtkWidget *new_entry = NULL;
 391
 392         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 393         if (!ped) return;
 394
 395         switch (info)
 396                 {
 397                 case TARGET_APP_EXIF_ENTRY:
 398                         new_entry = *(gpointer *)gtk_selection_data_get_data(selection_data);
 399
 400                         if (gtk_widget_get_parent(new_entry) && gtk_widget_get_parent(new_entry) != ped->vbox) bar_pane_exif_reparent_entry(new_entry, pane);
 401
 402                         break;
 403                 default:
 404                         /** @FIXME this needs a check for valid exif keys */
 405                         new_entry = bar_pane_exif_add_entry(ped, (gchar *)gtk_selection_data_get_data(selection_data), NULL, TRUE, FALSE);
 406                         break;
 407                 }
 408
 409         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 410         work = list;
 411         pos = 0;
 412         while (work)
 413                 {
 414                 gint nx, ny;
 415                 GtkWidget *entry = work->data;
 416                 GtkAllocation allocation;
 417                 work = work->next;
 418
 419                 if (entry == new_entry) continue;
 420
 421                 gtk_widget_get_allocation(entry, &allocation);
 422
 423                 if (gtk_widget_is_drawable(entry) &&
 424                     gtk_widget_translate_coordinates(pane, entry, x, y, &nx, &ny) &&
 425                     ny < allocation.height / 2) break;
 426                 pos++;
 427                 }
 428         g_list_free(list);
 429
 430         gtk_box_reorder_child(GTK_BOX(ped->vbox), new_entry, pos);
 431 }
 432
 433 static void bar_pane_exif_entry_dnd_begin(GtkWidget *entry, GdkDragContext *context, gpointer UNUSED(data))
 434 {
 435         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 436
 437         if (!ee) return;
 438         dnd_set_drag_label(entry, context, ee->key);
 439 }
 440
 441 static void bar_pane_exif_entry_dnd_end(GtkWidget *UNUSED(widget), GdkDragContext *UNUSED(context), gpointer UNUSED(data))
 442 {
 443 }
 444
 445 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry)
 446 {
 447         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 448
 449         gtk_drag_source_set(entry, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 450                             bar_pane_exif_drag_types, n_exif_entry_drag_types,
 451                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 452         g_signal_connect(G_OBJECT(entry), "drag_data_get",
 453                          G_CALLBACK(bar_pane_exif_entry_dnd_get), ee);
 454
 455         g_signal_connect(G_OBJECT(entry), "drag_begin",
 456                          G_CALLBACK(bar_pane_exif_entry_dnd_begin), ee);
 457         g_signal_connect(G_OBJECT(entry), "drag_end",
 458                          G_CALLBACK(bar_pane_exif_entry_dnd_end), ee);
 459 }
 460
 461 static void bar_pane_exif_dnd_init(GtkWidget *pane)
 462 {
 463         gtk_drag_dest_set(pane,
 464                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
 465                           bar_pane_exif_drop_types, n_exif_entry_drop_types,
 466                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
 467         g_signal_connect(G_OBJECT(pane), "drag_data_received",
 468                          G_CALLBACK(bar_pane_exif_dnd_receive), NULL);
 469 }
 470
 471 static void bar_pane_exif_edit_close_cb(GtkWidget *UNUSED(widget), gpointer data)
 472 {
 473         GenericDialog *gd = data;
 474         generic_dialog_close(gd);
 475 }
 476
 477 static void bar_pane_exif_edit_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
 478 {
 479         ConfDialogData *cdd = data;
 480         g_signal_handlers_disconnect_by_func(cdd->widget, (gpointer)(bar_pane_exif_edit_close_cb), cdd->gd);
 481         g_free(cdd);
 482 }
 483
 484 static void bar_pane_exif_edit_cancel_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
 485 {
 486 }
 487
 488 static void bar_pane_exif_edit_ok_cb(GenericDialog *UNUSED(gd), gpointer data)
 489 {
 490         ConfDialogData *cdd = data;
 491
 492         /* either one or the other */
 493         PaneExifData *ped = g_object_get_data(G_OBJECT(cdd->widget), "pane_data");
 494         ExifEntry *ee = g_object_get_data(G_OBJECT(cdd->widget), "entry_data");
 495
 496         if (ped)
 497                 {
 498                 bar_pane_exif_add_entry(ped,
 499                                         gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)),
 500                                         gtk_entry_get_text(GTK_ENTRY(cdd->title_entry)),
 501                                         cdd->if_set, cdd->editable);
 502                 }
 503
 504         if (ee)
 505                 {
 506                 const gchar *title;
 507                 GtkWidget *pane = gtk_widget_get_parent(cdd->widget);
 508
 509                 while (pane)
 510                         {
 511                         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 512                         if (ped) break;
 513                         pane = gtk_widget_get_parent(pane);
 514                         }
 515
 516                 if (!pane) return;
 517
 518                 g_free(ee->key);
 519                 ee->key = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)));
 520                 title = gtk_entry_get_text(GTK_ENTRY(cdd->title_entry));
 521                 if (!title || strlen(title) == 0)
 522                         {
 523                         g_free(ee->title);
 524                         ee->title = exif_get_description_by_key(ee->key);
 525                         ee->auto_title = TRUE;
 526                         }
 527                 else if (!ee->title || strcmp(ee->title, title) != 0)
 528                         {
 529                         g_free(ee->title);
 530                         ee->title = g_strdup(title);
 531                         ee->auto_title = FALSE;
 532                         }
 533
 534                 ee->if_set = cdd->if_set;
 535                 ee->editable = cdd->editable;
 536
 537                 bar_pane_exif_setup_entry_box(ped, ee);
 538
 539                 bar_pane_exif_entry_update_title(ee);
 540                 bar_pane_exif_update(ped);
 541                 }
 542 }
 543
 544 static void bar_pane_exif_conf_dialog(GtkWidget *widget)
 545 {
 546         ConfDialogData *cdd;
 547         GenericDialog *gd;
 548         GtkWidget *table;
 549
 550         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 551            we can decide it by the attached data */
 552         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 553
 554         cdd = g_new0(ConfDialogData, 1);
 555
 556         cdd->widget = widget;
 557
 558
 559         cdd->if_set = ee ? ee->if_set : TRUE;
 560         cdd->editable = ee ? ee->editable : FALSE;
 561
 562         cdd->gd = gd = generic_dialog_new(ee ? _("Configure entry") : _("Add entry"), "exif_entry_edit",
 563                                 widget, TRUE,
 564                                 bar_pane_exif_edit_cancel_cb, cdd);
 565         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 566                          G_CALLBACK(bar_pane_exif_edit_destroy_cb), cdd);
 567
 568         /* in case the entry is deleted during editing */
 569         g_signal_connect(G_OBJECT(widget), "destroy",
 570                          G_CALLBACK(bar_pane_exif_edit_close_cb), gd);
 571
 572         generic_dialog_add_message(gd, NULL, ee ? _("Configure entry") : _("Add entry"), NULL, FALSE);
 573
 574         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
 575                                   bar_pane_exif_edit_ok_cb, TRUE);
 576
 577         table = pref_table_new(gd->vbox, 3, 2, FALSE, TRUE);
 578         pref_table_label(table, 0, 0, _("Key:"), 1.0);
 579
 580         cdd->key_entry = gtk_entry_new();
 581         gtk_widget_set_size_request(cdd->key_entry, 300, -1);
 582         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->key_entry), ee->key);
 583         gtk_table_attach_defaults(GTK_TABLE(table), cdd->key_entry, 1, 2, 0, 1);
 584         generic_dialog_attach_default(gd, cdd->key_entry);
 585         gtk_widget_show(cdd->key_entry);
 586
 587         pref_table_label(table, 0, 1, _("Title:"), 1.0);
 588
 589         cdd->title_entry = gtk_entry_new();
 590         gtk_widget_set_size_request(cdd->title_entry, 300, -1);
 591         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->title_entry), ee->title);
 592         gtk_table_attach_defaults(GTK_TABLE(table), cdd->title_entry, 1, 2, 1, 2);
 593         generic_dialog_attach_default(gd, cdd->title_entry);
 594         gtk_widget_show(cdd->title_entry);
 595
 596         pref_checkbox_new_int(gd->vbox, _("Show only if set"), cdd->if_set, &cdd->if_set);
 597         pref_checkbox_new_int(gd->vbox, _("Editable (supported only for XMP)"), cdd->editable, &cdd->editable);
 598
 599         gtk_widget_show(gd->dialog);
 600 }
 601
 602 static void bar_pane_exif_conf_dialog_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
 603 {
 604         GtkWidget *widget = data;
 605         bar_pane_exif_conf_dialog(widget);
 606 }
 607
 608 static void bar_pane_exif_delete_entry_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
 609 {
 610         GtkWidget *entry = data;
 611         gtk_widget_destroy(entry);
 612 }
 613
 614 static void bar_pane_exif_copy_entry_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
 615 {
 616         GtkWidget *widget = data;
 617         GtkClipboard *clipboard;
 618         const gchar *value;
 619         ExifEntry *ee;
 620
 621         ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 622         value = gtk_label_get_text(GTK_LABEL(ee->value_widget));
 623         clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 624         gtk_clipboard_set_text(clipboard, value, -1);
 625 }
 626
 627 static void bar_pane_exif_toggle_show_all_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
 628 {
 629         PaneExifData *ped = data;
 630         ped->show_all = !ped->show_all;
 631         bar_pane_exif_update(ped);
 632 }
 633
 634 static void bar_pane_exif_menu_popup(GtkWidget *widget, PaneExifData *ped)
 635 {
 636         GtkWidget *menu;
 637         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 638            we can decide it by the attached data */
 639         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 640
 641         menu = popup_menu_short_lived();
 642
 643         if (ee)
 644                 {
 645                 /* for the entry */
 646                 gchar *conf = g_strdup_printf(_("Configure \"%s\""), ee->title);
 647                 gchar *del = g_strdup_printf(_("Remove \"%s\""), ee->title);
 648                 gchar *copy = g_strdup_printf(_("Copy \"%s\""), ee->title);
 649
 650                 menu_item_add_stock(menu, conf, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_exif_conf_dialog_cb), widget);
 651                 menu_item_add_stock(menu, del, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_exif_delete_entry_cb), widget);
 652                 menu_item_add_stock(menu, copy, GTK_STOCK_COPY, G_CALLBACK(bar_pane_exif_copy_entry_cb), widget);
 653                 menu_item_add_divider(menu);
 654
 655                 g_free(conf);
 656                 g_free(del);
 657                 }
 658
 659         /* for the pane */
 660         menu_item_add_stock(menu, _("Add entry"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_exif_conf_dialog_cb), ped->widget);
 661         menu_item_add_check(menu, _("Show hidden entries"), ped->show_all, G_CALLBACK(bar_pane_exif_toggle_show_all_cb), ped);
 662
 663         gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
 664 }
 665
 666 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
 667 {
 668         PaneExifData *ped = data;
 669         if (bevent->button == MOUSE_BUTTON_RIGHT)
 670                 {
 671                 bar_pane_exif_menu_popup(widget, ped);
 672                 return TRUE;
 673                 }
 674         return FALSE;
 675 }
 676
 677 static gboolean bar_pane_exif_copy_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer UNUSED(data))
 678 {
 679         const gchar *value;
 680         GtkClipboard *clipboard;
 681         ExifEntry *ee;
 682
 683         if (bevent->button == MOUSE_BUTTON_LEFT)
 684                 {
 685                 ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 686                 value = gtk_label_get_text(GTK_LABEL(ee->value_widget));
 687                 clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
 688                 gtk_clipboard_set_text(clipboard, value, -1);
 689
 690                 return TRUE;
 691                 }
 692
 693         return FALSE;
 694 }
 695
 696
 697
 698 static void bar_pane_exif_entry_write_config(GtkWidget *entry, GString *outstr, gint indent)
 699 {
 700         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 701         if (!ee) return;
 702
 703         WRITE_NL(); WRITE_STRING("<entry ");
 704         WRITE_CHAR(*ee, key);
 705         if (!ee->auto_title) WRITE_CHAR(*ee, title);
 706         WRITE_BOOL(*ee, if_set);
 707         WRITE_BOOL(*ee, editable);
 708         WRITE_STRING("/>");
 709 }
 710
 711 static void bar_pane_exif_write_config(GtkWidget *pane, GString *outstr, gint indent)
 712 {
 713         PaneExifData *ped;
 714         GList *work, *list;
 715
 716         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 717         if (!ped) return;
 718
 719         WRITE_NL(); WRITE_STRING("<pane_exif ");
 720         write_char_option(outstr, indent, "id", ped->pane.id);
 721         write_char_option(outstr, indent, "title", gtk_label_get_text(GTK_LABEL(ped->pane.title)));
 722         WRITE_BOOL(ped->pane, expanded);
 723         WRITE_BOOL(*ped, show_all);
 724         WRITE_STRING(">");
 725         indent++;
 726
 727         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 728         work = list;
 729         while (work)
 730                 {
 731                 GtkWidget *entry = work->data;
 732                 work = work->next;
 733
 734                 bar_pane_exif_entry_write_config(entry, outstr, indent);
 735                 }
 736         g_list_free(list);
 737         indent--;
 738         WRITE_NL(); WRITE_STRING("</pane_exif>");
 739 }
 740
 741 GList * bar_pane_exif_list()
 742 {
 743         PaneExifData *ped;
 744         GList *list;
 745         GList *work_windows;
 746         GList *exif_list = NULL;
 747         LayoutWindow *lw;
 748         GtkWidget *bar;
 749         GtkWidget *pane;
 750         GtkWidget *entry;
 751         ExifEntry *ee;
 752
 753         work_windows = layout_window_list;
 754         lw = work_windows->data;
 755         bar = lw->bar;
 756         pane = bar_find_pane_by_id(bar, PANE_EXIF, "exif");
 757         if (pane)
 758                 {
 759                 ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 760
 761                 list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 762                 while (list)
 763                         {
 764                         entry = list->data;
 765                         list = list->next;
 766                         ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 767                         exif_list = g_list_append(exif_list, g_strdup(ee->title));
 768                         exif_list = g_list_append(exif_list, g_strdup(ee->key));
 769                         }
 770
 771                 g_list_free(list);
 772                 }
 773         return exif_list;
 774 }
 775
 776 void bar_pane_exif_close(GtkWidget *widget)
 777 {
 778         PaneExifData *ped;
 779
 780         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 781         if (!ped) return;
 782
 783         gtk_widget_destroy(ped->vbox);
 784 }
 785
 786 static void bar_pane_exif_destroy(GtkWidget *UNUSED(widget), gpointer data)
 787 {
 788         PaneExifData *ped = data;
 789
 790         file_data_unregister_notify_func(bar_pane_exif_notify_cb, ped);
 791         g_object_unref(ped->size_group);
 792         file_data_unref(ped->fd);
 793         g_free(ped->pane.id);
 794         g_free(ped);
 795 }
 796
 797 //~ static void bar_pane_exif_size_request(GtkWidget *UNUSED(pane), GtkRequisition *requisition, gpointer data)
 798 //~ {
 799         //~ PaneExifData *ped = data;
 800         //~ if (requisition->height < ped->min_height)
 801                 //~ {
 802                 //~ requisition->height = ped->min_height;
 803                 //~ }
 804 //~ }
 805
 806 static void bar_pane_exif_size_allocate(GtkWidget *UNUSED(pane), GtkAllocation *alloc, gpointer data)
 807 {
 808         PaneExifData *ped = data;
 809         ped->min_height = alloc->height;
 810         gtk_widget_set_size_request(ped->widget, -1, ped->min_height);
 811 }
 812
 813 static GtkWidget *bar_pane_exif_new(const gchar *id, const gchar *title, gboolean expanded, gboolean show_all)
 814 {
 815         PaneExifData *ped;
 816
 817         ped = g_new0(PaneExifData, 1);
 818
 819         ped->pane.pane_set_fd = bar_pane_exif_set_fd;
 820         ped->pane.pane_write_config = bar_pane_exif_write_config;
 821         ped->pane.pane_event = bar_pane_exif_event;
 822         ped->pane.title = bar_pane_expander_title(title);
 823         ped->pane.id = g_strdup(id);
 824         ped->pane.expanded = expanded;
 825         ped->pane.type = PANE_EXIF;
 826         ped->show_all = show_all;
 827
 828         ped->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 829         ped->widget = gtk_event_box_new();
 830         ped->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
 831         gtk_container_add(GTK_CONTAINER(ped->widget), ped->vbox);
 832         gtk_widget_show(ped->vbox);
 833
 834         ped->min_height = MIN_HEIGHT;
 835         g_object_set_data(G_OBJECT(ped->widget), "pane_data", ped);
 836         g_signal_connect_after(G_OBJECT(ped->widget), "destroy",
 837                                G_CALLBACK(bar_pane_exif_destroy), ped);
 838         gtk_widget_set_size_request(ped->widget, -1, ped->min_height);
 839         g_signal_connect(G_OBJECT(ped->widget), "size-allocate",
 840                          G_CALLBACK(bar_pane_exif_size_allocate), ped);
 841
 842         bar_pane_exif_dnd_init(ped->widget);
 843         g_signal_connect(ped->widget, "button_release_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 844
 845         file_data_register_notify_func(bar_pane_exif_notify_cb, ped, NOTIFY_PRIORITY_LOW);
 846
 847         gtk_widget_show(ped->widget);
 848
 849         return ped->widget;
 850 }
 851
 852 GtkWidget *bar_pane_exif_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
 853 {
 854         gchar *title = NULL;
 855         gchar *id = g_strdup("exif");
 856         gboolean expanded = TRUE;
 857         gboolean show_all = FALSE;
 858         GtkWidget *ret;
 859
 860         while (*attribute_names)
 861                 {
 862                 const gchar *option = *attribute_names++;
 863                 const gchar *value = *attribute_values++;
 864
 865                 if (READ_CHAR_FULL("id", id)) continue;
 866                 if (READ_CHAR_FULL("title", title)) continue;
 867                 if (READ_BOOL_FULL("expanded", expanded)) continue;
 868                 if (READ_BOOL_FULL("show_all", show_all)) continue;
 869
 870                 log_printf("unknown attribute %s = %s\n", option, value);
 871                 }
 872
 873         bar_pane_translate_title(PANE_EXIF, id, &title);
 874         ret = bar_pane_exif_new(id, title, expanded, show_all);
 875         g_free(title);
 876         g_free(id);
 877         return ret;
 878 }
 879
 880 void bar_pane_exif_update_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
 881 {
 882         PaneExifData *ped;
 883         gchar *title = NULL;
 884
 885         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 886         if (!ped) return;
 887
 888         while (*attribute_names)
 889                 {
 890                 const gchar *option = *attribute_names++;
 891                 const gchar *value = *attribute_values++;
 892
 893                 if (READ_CHAR_FULL("title", title)) continue;
 894                 if (READ_BOOL_FULL("expanded", ped->pane.expanded)) continue;
 895                 if (READ_BOOL_FULL("show_all", ped->show_all)) continue;
 896                 if (READ_CHAR_FULL("id", ped->pane.id)) continue;
 897
 898
 899                 log_printf("unknown attribute %s = %s\n", option, value);
 900                 }
 901
 902         if (title)
 903                 {
 904                 bar_pane_translate_title(PANE_EXIF, ped->pane.id, &title);
 905                 gtk_label_set_text(GTK_LABEL(ped->pane.title), title);
 906                 g_free(title);
 907                 }
 908
 909         bar_update_expander(pane);
 910         bar_pane_exif_update(ped);
 911 }
 912
 913
 914 void bar_pane_exif_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
 915 {
 916         PaneExifData *ped;
 917         gchar *key = NULL;
 918         gchar *title = NULL;
 919         gboolean if_set = TRUE;
 920         gboolean editable = FALSE;
 921
 922         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 923         if (!ped) return;
 924
 925         while (*attribute_names)
 926                 {
 927                 const gchar *option = *attribute_names++;
 928                 const gchar *value = *attribute_values++;
 929
 930                 if (READ_CHAR_FULL("key", key)) continue;
 931                 if (READ_CHAR_FULL("title", title)) continue;
 932                 if (READ_BOOL_FULL("if_set", if_set)) continue;
 933                 if (READ_BOOL_FULL("editable", editable)) continue;
 934
 935                 log_printf("unknown attribute %s = %s\n", option, value);
 936                 }
 937
 938         if (key && key[0]) bar_pane_exif_add_entry(ped, key, title, if_set, editable);
 939 }
 940
 941
 942 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */