* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include "main.h"
#include "preferences.h"
+#include <config.h>
+
+#include <cstdlib>
+#include <cstring>
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdk/gdk.h>
+#include <gio/gio.h>
+#include <glib-object.h>
+
+#if HAVE_SPELL
+#include <gspell/gspell.h>
+#endif
+
+#if HAVE_LCMS
+#if HAVE_LCMS2
+#include <lcms2.h>
+#else
+#include <lcms.h>
+#endif
+#endif
+
+#include <pango/pango.h>
+
+#include "archives.h"
#include "bar-keywords.h"
#include "cache.h"
+#include "color-man.h"
+#include "compat.h"
+#include "debug.h"
#include "editors.h"
#include "filedata.h"
#include "filefilter.h"
#include "fullscreen.h"
-#include "image.h"
#include "image-overlay.h"
-#include "color-man.h"
+#include "image.h"
#include "img-view.h"
+#include "intl.h"
#include "layout-util.h"
+#include "layout.h"
+#include "main-defines.h"
+#include "main.h"
#include "metadata.h"
#include "misc.h"
+#include "options.h"
#include "osd.h"
#include "pixbuf-util.h"
#include "rcfile.h"
#include "slideshow.h"
+#include "third-party/zonedetect.h"
#include "toolbar.h"
#include "trash.h"
-#include "utilops.h"
+#include "typedefs.h"
#include "ui-fileops.h"
#include "ui-misc.h"
-#include "ui-spinner.h"
#include "ui-tabcomp.h"
+#include "ui-utildlg.h"
+#include "utilops.h"
#include "window.h"
-#include "zonedetect.h"
-#ifdef HAVE_LCMS
-#ifdef HAVE_LCMS2
-#include <lcms2.h>
-#else
-#include <lcms.h>
-#endif
-#endif
+namespace
+{
-#ifdef HAVE_SPELL
-#include <gspell/gspell.h>
-#endif
+constexpr gint PRE_FORMATTED_COLUMNS = 5;
+constexpr gint KEYWORD_DIALOG_WIDTH = 400;
-#define EDITOR_NAME_MAX_LENGTH 32
-#define EDITOR_COMMAND_MAX_LENGTH 1024
+} // namespace
-static void image_overlay_set_text_colours();
+struct ZoneDetect;
+
+enum {
+ EDITOR_NAME_MAX_LENGTH = 32,
+ EDITOR_COMMAND_MAX_LENGTH = 1024
+};
+
+static void image_overlay_set_text_colors();
GtkWidget *keyword_text;
static void config_tab_keywords_save();
AE_ACTION,
AE_KEY,
AE_TOOLTIP,
- AE_ACCEL
+ AE_ACCEL,
+ AE_ICON
};
enum {
static GtkWidget *sidecar_ext_entry;
static GtkWidget *help_search_engine_entry;
+static GtkWidget *log_window_f1_entry;
-#define CONFIG_WINDOW_DEF_WIDTH 700
-#define CONFIG_WINDOW_DEF_HEIGHT 600
+
+enum {
+ CONFIG_WINDOW_DEF_WIDTH = 700,
+ CONFIG_WINDOW_DEF_HEIGHT = 600
+};
/*
*-----------------------------------------------------------------------------
*-----------------------------------------------------------------------------
*/
-static void zoom_increment_cb(GtkWidget *spin, gpointer UNUSED(data))
+static void zoom_increment_cb(GtkWidget *spin, gpointer)
{
c_options->image.zoom_increment = static_cast<gint>(gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) * 100.0 + 0.01);
}
-static void slideshow_delay_hours_cb(GtkWidget *spin, gpointer UNUSED(data))
+static void slideshow_delay_hours_cb(GtkWidget *spin, gpointer)
{
- gint mins_secs_tenths, delay;
+ gint mins_secs_tenths;
+ gint delay;
mins_secs_tenths = c_options->slideshow.delay %
(3600 * SLIDESHOW_SUBSECOND_PRECISION);
SLIDESHOW_SUBSECOND_PRECISION;
}
-static void slideshow_delay_minutes_cb(GtkWidget *spin, gpointer UNUSED(data))
+static void slideshow_delay_minutes_cb(GtkWidget *spin, gpointer)
{
- gint hours, secs_tenths, delay;
+ gint hours;
+ gint secs_tenths;
+ gint delay;
hours = c_options->slideshow.delay / (3600 * SLIDESHOW_SUBSECOND_PRECISION);
secs_tenths = c_options->slideshow.delay % (60 * SLIDESHOW_SUBSECOND_PRECISION);
SLIDESHOW_SUBSECOND_PRECISION;
}
-static void slideshow_delay_seconds_cb(GtkWidget *spin, gpointer UNUSED(data))
+static void slideshow_delay_seconds_cb(GtkWidget *spin, gpointer)
{
- gint hours_mins, delay;
+ gint hours_mins;
+ gint delay;
hours_mins = c_options->slideshow.delay / (60 * SLIDESHOW_SUBSECOND_PRECISION);
g_free(*option);
*option = nullptr;
- buf = gtk_entry_get_text(GTK_ENTRY(entry));
+ buf = gq_gtk_entry_get_text(GTK_ENTRY(entry));
if (buf && strlen(buf) > 0)
{
if (func)
}
-static gboolean accel_apply_cb(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer UNUSED(data))
+static gboolean accel_apply_cb(GtkTreeModel *model, GtkTreePath *, GtkTreeIter *iter, gpointer)
{
- gchar *accel_path, *accel;
+ gchar *accel_path;
+ gchar *accel;
gtk_tree_model_get(model, iter, AE_ACCEL, &accel_path, AE_KEY, &accel, -1);
static void config_window_apply()
{
gboolean refresh = FALSE;
-#ifdef HAVE_LCMS2
+#if HAVE_LCMS2
int i = 0;
#endif
if (options->file_filter.show_parent_directory != c_options->file_filter.show_parent_directory) refresh = TRUE;
if (options->file_filter.show_dot_directory != c_options->file_filter.show_dot_directory) refresh = TRUE;
if (options->file_sort.case_sensitive != c_options->file_sort.case_sensitive) refresh = TRUE;
- if (options->file_sort.natural != c_options->file_sort.natural) refresh = TRUE;
if (options->file_filter.disable_file_extension_checks != c_options->file_filter.disable_file_extension_checks) refresh = TRUE;
if (options->file_filter.disable != c_options->file_filter.disable) refresh = TRUE;
if (options->thumbnails.max_width != c_options->thumbnails.max_width
|| options->thumbnails.max_height != c_options->thumbnails.max_height
|| options->thumbnails.quality != c_options->thumbnails.quality)
- {
- thumb_format_changed = TRUE;
+ {
+ thumb_format_changed = TRUE;
refresh = TRUE;
options->thumbnails.max_width = c_options->thumbnails.max_width;
options->thumbnails.max_height = c_options->thumbnails.max_height;
options->file_filter.disable_file_extension_checks = c_options->file_filter.disable_file_extension_checks;
options->file_sort.case_sensitive = c_options->file_sort.case_sensitive;
- options->file_sort.natural = c_options->file_sort.natural;
options->file_filter.disable = c_options->file_filter.disable;
config_entry_to_option(sidecar_ext_entry, &options->sidecar.ext, nullptr);
if (options->image.use_custom_border_color != c_options->image.use_custom_border_color
|| options->image.use_custom_border_color_in_fullscreen != c_options->image.use_custom_border_color_in_fullscreen
- || !gdk_color_equal(&options->image.border_color, &c_options->image.border_color))
+ || !gdk_rgba_equal(&options->image.border_color, &c_options->image.border_color))
{
options->image.use_custom_border_color_in_fullscreen = c_options->image.use_custom_border_color_in_fullscreen;
options->image.use_custom_border_color = c_options->image.use_custom_border_color;
options->image_overlay.background_green = c_options->image_overlay.background_green;
options->image_overlay.background_blue = c_options->image_overlay.background_blue;
options->image_overlay.background_alpha = c_options->image_overlay.background_alpha;
+ options->image_overlay.font = c_options->image_overlay.font;
options->update_on_time_change = c_options->update_on_time_change;
options->duplicates_similarity_threshold = c_options->duplicates_similarity_threshold;
options->show_predefined_keyword_tree = c_options->show_predefined_keyword_tree;
options->expand_menu_toolbar = c_options->expand_menu_toolbar;
+ options->hamburger_menu = c_options->hamburger_menu;
+
+ options->selectable_bars.menu_bar = c_options->selectable_bars.menu_bar;
+ options->selectable_bars.tool_bar = c_options->selectable_bars.tool_bar;
+ options->selectable_bars.status_bar = c_options->selectable_bars.status_bar;
options->marks_save = c_options->marks_save;
options->with_rename = c_options->with_rename;
+ options->collections_duplicates = c_options->collections_duplicates;
options->collections_on_top = c_options->collections_on_top;
options->hide_window_in_fullscreen = c_options->hide_window_in_fullscreen;
config_entry_to_option(help_search_engine_entry, &options->help_search_engine, nullptr);
options->threads.duplicates = c_options->threads.duplicates > 0 ? c_options->threads.duplicates : -1;
+ options->alternate_similarity_algorithm.enabled = c_options->alternate_similarity_algorithm.enabled;
+ options->alternate_similarity_algorithm.grayscale = c_options->alternate_similarity_algorithm.grayscale;
+
#ifdef DEBUG
set_debug_level(debug_c);
+ config_entry_to_option(log_window_f1_entry, &options->log_window.action, nullptr);
#endif
-#ifdef HAVE_LCMS
+#if HAVE_LCMS
for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
{
config_entry_to_option(color_profile_input_name_entry[i], &options->color_profile.input_name[i], nullptr);
*-----------------------------------------------------------------------------
*/
-static void config_window_close_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
+static void config_window_close_cb(GtkWidget *, gpointer)
{
- gtk_widget_destroy(configwindow);
+ gq_gtk_widget_destroy(configwindow);
configwindow = nullptr;
filter_store = nullptr;
}
-static void config_window_help_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void config_window_help_cb(GtkWidget *, gpointer data)
{
auto notebook = static_cast<GtkWidget *>(data);
gint i;
help_window_show(html_section[i]);
}
-static gboolean config_window_delete(GtkWidget *UNUSED(widget), GdkEventAny *UNUSED(event), gpointer UNUSED(data))
+static gboolean config_window_delete(GtkWidget *, GdkEventAny *, gpointer)
{
config_window_close_cb(nullptr, nullptr);
return TRUE;
*option_c = option;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(quality_menu_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
*option_c = option;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(dnd_default_action_selection_menu_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
*option_c = option;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(clipboard_selection_menu_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
*option_c = option;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(zoom_style_selection_menu_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
-struct UseableMouseItems
-{
- const gchar *name; /* GtkActionEntry terminology */
- const gchar *label;
- const gchar *stock_id;
-};
-
-static const UseableMouseItems useable_mouse_items[] = {
- {"", "", nullptr},
- {"FirstImage", N_("First Image"), GTK_STOCK_GOTO_TOP},
- {"PrevImage", N_("Previous Image"), GTK_STOCK_GO_UP},
- {"NextImage", N_("Next Image"), GTK_STOCK_GO_DOWN},
- {"LastImage", N_("Last Image"), GTK_STOCK_GOTO_BOTTOM},
- {"Back", N_("Back"), GTK_STOCK_GO_BACK},
- {"Forward", N_("Forward"), GTK_STOCK_GO_FORWARD},
- {"Home", N_("Home"), GTK_STOCK_HOME},
- {"Up", N_("Up"), GTK_STOCK_GO_UP},
- {"FirstPage", N_("First page"), GTK_STOCK_MEDIA_PREVIOUS},
- {"LastPage", N_("Last Page"), GTK_STOCK_MEDIA_NEXT},
- {"NextPage", N_("Next page"), GTK_STOCK_MEDIA_FORWARD},
- {"PrevPage", N_("Previous Page"), GTK_STOCK_MEDIA_REWIND},
- {"NewWindow", N_("New _window"), GTK_STOCK_NEW},
- {"NewCollection", N_("New collection"), GTK_STOCK_INDEX},
- {"OpenCollection", N_("Open collection"), GTK_STOCK_OPEN},
- {"Search", N_("Search"), GTK_STOCK_FIND},
- {"FindDupes", N_("Find duplicates"), GTK_STOCK_FIND},
- {"NewFolder", N_("New folder"),GTK_STOCK_DIRECTORY},
- {"Copy", N_("Copy"), GTK_STOCK_COPY},
- {"Move", N_("Move"), PIXBUF_INLINE_ICON_MOVE},
- {"Rename", N_("Rename"), PIXBUF_INLINE_ICON_RENAME},
- {"Delete", N_("Delete"), GTK_STOCK_DELETE},
- {"CloseWindow", N_("Close Window"), GTK_STOCK_CLOSE},
- {"PanView", N_("Pan view"), PIXBUF_INLINE_ICON_PANORAMA},
- {"SelectAll", N_("Select all"), PIXBUF_INLINE_ICON_SELECT_ALL},
- {"SelectNone", N_("Select none"), PIXBUF_INLINE_ICON_SELECT_NONE},
- {"SelectInvert", N_("Select invert"), PIXBUF_INLINE_ICON_SELECT_INVERT},
- {"ShowFileFilter", N_("Show file filter"), PIXBUF_INLINE_ICON_FILE_FILTER},
- {"RectangularSelection", N_("Select rectangle"), PIXBUF_INLINE_ICON_SELECT_RECTANGLE},
- {"Print", N_("Print"), GTK_STOCK_PRINT},
- {"Preferences", N_("Preferences"), GTK_STOCK_PREFERENCES},
- {"LayoutConfig", N_("Configure this window"), GTK_STOCK_PREFERENCES},
- {"Maintenance", N_("Cache maintenance"), PIXBUF_INLINE_ICON_MAINTENANCE},
- {"RotateCW", N_("Rotate clockwise 90°"), PIXBUF_INLINE_ICON_CW},
- {"RotateCCW", N_("Rotate counterclockwise 90°"), PIXBUF_INLINE_ICON_CCW},
- {"Rotate180", N_("Rotate 180°"), PIXBUF_INLINE_ICON_180},
- {"Mirror", N_("Mirror"), PIXBUF_INLINE_ICON_MIRROR},
- {"Flip", N_("Flip"), PIXBUF_INLINE_ICON_FLIP},
- {"AlterNone", N_("Original state"), PIXBUF_INLINE_ICON_ORIGINAL},
- {"ZoomIn", N_("Zoom in"), GTK_STOCK_ZOOM_IN},
- {"ZoomOut", N_("Zoom out"), GTK_STOCK_ZOOM_OUT},
- {"Zoom100", N_("Zoom 1:1"), GTK_STOCK_ZOOM_100},
- {"ZoomFit", N_("Zoom to fit"), GTK_STOCK_ZOOM_FIT},
- {"ZoomFillHor", N_("Fit Horizontaly"), PIXBUF_INLINE_ICON_ZOOMFILLHOR},
- {"ZoomFillVert", N_("Fit vertically"), PIXBUF_INLINE_ICON_ZOOMFILLVERT},
- {"Zoom200", N_("Zoom 2:1"), GTK_STOCK_FILE},
- {"Zoom300", N_("Zoom 3:1"), GTK_STOCK_FILE},
- {"Zoom400", N_("Zoom 4:1"), GTK_STOCK_FILE},
- {"Zoom50", N_("Zoom 1:2"), GTK_STOCK_FILE},
- {"Zoom33", N_("Zoom1:3"), GTK_STOCK_FILE},
- {"Zoom25", N_("Zoom 1:4"), GTK_STOCK_FILE},
- {"ConnectZoomIn", N_("Connected Zoom in"), GTK_STOCK_ZOOM_IN},
- {"SplitPaneSync", N_("Split Pane Sync"), PIXBUF_INLINE_SPLIT_PANE_SYNC},
- {"Grayscale", N_("Grayscale"), PIXBUF_INLINE_ICON_GRAYSCALE},
- {"OverUnderExposed", N_("Over Under Exposed"), PIXBUF_INLINE_ICON_EXPOSURE},
- {"HideTools", N_("Hide file list"), PIXBUF_INLINE_ICON_HIDETOOLS},
- {"SlideShowPause", N_("Pause slideshow"), GTK_STOCK_MEDIA_PAUSE},
- {"SlideShowFaster", N_("Slideshow Faster"), GTK_STOCK_FILE},
- {"SlideShowSlower", N_("Slideshow Slower"), GTK_STOCK_FILE},
- {"Refresh", N_("Refresh"), GTK_STOCK_REFRESH},
- {"HelpContents", N_("Help"), GTK_STOCK_HELP},
- {"ExifWin", N_("Exif window"), PIXBUF_INLINE_ICON_EXIF},
- {"Thumbnails", N_("Show thumbnails"), PIXBUF_INLINE_ICON_THUMB},
- {"ShowMarks", N_("Show marks"), PIXBUF_INLINE_ICON_MARKS},
- {"DrawRectangle", N_("Draw Rectangle"), PIXBUF_INLINE_ICON_DRAW_RECTANGLE},
- {"FloatTools", N_("Float file list"), PIXBUF_INLINE_ICON_FLOAT},
- {"SBar", N_("Info sidebar"), PIXBUF_INLINE_ICON_INFO},
- {"SBarSort", N_("Sort manager"), PIXBUF_INLINE_ICON_SORT},
- {"Quit", N_("Quit"), GTK_STOCK_QUIT},
- {nullptr, nullptr, nullptr}
-};
-
static void mouse_buttons_selection_menu_cb(GtkWidget *combo, gpointer data)
{
+ ActionItem *action_item = nullptr;
auto option = static_cast<gchar **>(data);
gchar *label;
+ GList *list;
+ GList *work;
label = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
- const UseableMouseItems *list = useable_mouse_items;
+ list = get_action_items();
+ work = list;
- while (list->name)
+ while (work)
{
- if (g_strcmp0(list->label, label) == 0)
+ action_item = static_cast<ActionItem *>(work->data);
+ if (g_strcmp0(action_item->label, label) == 0)
{
break;
}
- list++;
+ work=work->next;
}
g_free(*option);
- *option = g_strdup(list->name);
+ *option = g_strdup(action_item->name);
g_free(label);
+ action_items_free(list);
}
-static void add_mouse_selection_menu(GtkWidget *table, gint column, gint row, const gchar *text,
- gchar *option, gchar **option_c)
+static void add_mouse_selection_menu(GtkWidget *table, gint column, gint row, const gchar *text, gchar *option, gchar **option_c)
{
- GtkWidget *combo;
+ ActionItem *action_item;
gint current = 0;
gint i = 0;
+ GList *list;
+ GList *work;
+ GtkWidget *combo;
*option_c = option;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
- const UseableMouseItems *list = useable_mouse_items;
-
- while (list->name)
+ list = get_action_items();
+ work = list;
+ while (work)
{
- gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), list->label);
- if (g_strcmp0(list->name, option) == 0)
+ action_item = static_cast<ActionItem *>(work->data);
+ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), action_item->label);
+
+ if (g_strcmp0(action_item->name, option) == 0)
{
current = i;
}
i++;
- list++;
+ work = work->next;
}
+ action_items_free(list);
+
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
- g_signal_connect(G_OBJECT(combo), "changed",
- G_CALLBACK(mouse_buttons_selection_menu_cb), option_c);
+ g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(mouse_buttons_selection_menu_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
-static void thumb_size_menu_cb(GtkWidget *combo, gpointer UNUSED(data))
+static void thumb_size_menu_cb(GtkWidget *combo, gpointer)
{
gint n;
c_options->thumbnails.max_width = options->thumbnails.max_width;
c_options->thumbnails.max_height = options->thumbnails.max_height;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
current = -1;
for (i = 0; static_cast<guint>(i) < sizeof(thumb_size_list) / sizeof(ThumbSize); i++)
{
- gint w, h;
+ gint w;
+ gint h;
gchar *buf;
w = thumb_size_list[i].w;
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(thumb_size_menu_cb), NULL);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
*option_c = option;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(stereo_mode_menu_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
*option_c = option;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
g_list_foreach(eds,video_menu_populate,combo);
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(video_menu_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
}
}
-static void filter_store_ext_edit_cb(GtkCellRendererText *UNUSED(cell), gchar *path_str,
- gchar *new_text, gpointer data)
+static void filter_store_ext_edit_cb(GtkCellRendererText *, gchar *path_str, gchar *new_text, gpointer data)
{
auto model = static_cast<GtkWidget *>(data);
auto fe = static_cast<FilterEntry *>(data);
filter_rebuild();
}
-static void filter_store_class_edit_cb(GtkCellRendererText *UNUSED(cell), gchar *path_str,
- gchar *new_text, gpointer data)
+static void filter_store_class_edit_cb(GtkCellRendererText *, gchar *path_str, gchar *new_text, gpointer data)
{
auto model = static_cast<GtkWidget *>(data);
auto fe = static_cast<FilterEntry *>(data);
filter_rebuild();
}
-static void filter_store_desc_edit_cb(GtkCellRendererText *UNUSED(cell), gchar *path_str,
- gchar *new_text, gpointer data)
+static void filter_store_desc_edit_cb(GtkCellRendererText *, gchar *path_str, gchar *new_text, gpointer data)
{
auto model = static_cast<GtkWidget *>(data);
FilterEntry *fe;
gtk_tree_path_free(tpath);
}
-static void filter_store_enable_cb(GtkCellRendererToggle *UNUSED(renderer),
- gchar *path_str, gpointer data)
+static void filter_store_enable_cb(GtkCellRendererToggle *, gchar *path_str, gpointer data)
{
auto model = static_cast<GtkWidget *>(data);
FilterEntry *fe;
filter_rebuild();
}
-static void filter_store_writable_cb(GtkCellRendererToggle *UNUSED(renderer),
- gchar *path_str, gpointer data)
+static void filter_store_writable_cb(GtkCellRendererToggle *, gchar *path_str, gpointer data)
{
auto model = static_cast<GtkWidget *>(data);
FilterEntry *fe;
filter_rebuild();
}
-static void filter_store_sidecar_cb(GtkCellRendererToggle *UNUSED(renderer),
- gchar *path_str, gpointer data)
+static void filter_store_sidecar_cb(GtkCellRendererToggle *, gchar *path_str, gpointer data)
{
auto model = static_cast<GtkWidget *>(data);
FilterEntry *fe;
filter_rebuild();
}
-static void filter_set_func(GtkTreeViewColumn *UNUSED(tree_column), GtkCellRenderer *cell,
+static void filter_set_func(GtkTreeViewColumn *, GtkCellRenderer *cell,
GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
{
FilterEntry *fe;
return(G_SOURCE_REMOVE);
}
-static void filter_add_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void filter_add_cb(GtkWidget *, gpointer data)
{
filter_add_unique("description", ".new", FORMAT_CLASS_IMAGE, TRUE, FALSE, TRUE);
filter_store_populate();
g_idle_add(static_cast<GSourceFunc>(filter_add_scroll), data);
}
-static void filter_remove_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void filter_remove_cb(GtkWidget *, gpointer data)
{
auto filter_view = static_cast<GtkWidget *>(data);
GtkTreeSelection *selection;
return(G_SOURCE_REMOVE);
}
-static void filter_default_ok_cb(GenericDialog *gd, gpointer UNUSED(data))
+static void filter_default_ok_cb(GenericDialog *gd, gpointer)
{
filter_reset();
filter_add_defaults();
g_idle_add(reinterpret_cast<GSourceFunc>(filter_default_ok_scroll), gd->data);
}
-static void dummy_cancel_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
+static void dummy_cancel_cb(GenericDialog *, gpointer)
{
/* no op, only so cancel button appears */
}
gd = generic_dialog_new(_("Reset filters"),
"reset_filter", widget, TRUE,
dummy_cancel_cb, data);
- generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Reset filters"),
+ generic_dialog_add_message(gd, GQ_ICON_DIALOG_QUESTION, _("Reset filters"),
_("This will reset the file filters to the defaults.\nContinue?"), TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, filter_default_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GQ_ICON_OK, "OK", filter_default_ok_cb, TRUE);
gtk_widget_show(gd->dialog);
}
!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
}
-static void safe_delete_view_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
+static void safe_delete_view_cb(GtkWidget *, gpointer)
{
- layout_set_path(nullptr, gtk_entry_get_text(GTK_ENTRY(safe_delete_path_entry)));
+ layout_set_path(nullptr, gq_gtk_entry_get_text(GTK_ENTRY(safe_delete_path_entry)));
}
-static void safe_delete_clear_ok_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
+static void safe_delete_clear_ok_cb(GenericDialog *, gpointer)
{
file_util_trash_clear();
}
-static void safe_delete_clear_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void safe_delete_clear_cb(GtkWidget *widget, gpointer)
{
GenericDialog *gd;
GtkWidget *entry;
gd = generic_dialog_new(_("Clear trash"),
"clear_trash", widget, TRUE,
dummy_cancel_cb, nullptr);
- generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Clear trash"),
+ generic_dialog_add_message(gd, GQ_ICON_DIALOG_QUESTION, _("Clear trash"),
_("This will remove the trash contents."), FALSE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, safe_delete_clear_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GQ_ICON_OK, "OK", safe_delete_clear_ok_cb, TRUE);
entry = gtk_entry_new();
gtk_widget_set_can_focus(entry, FALSE);
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
- if (options->file_ops.safe_delete_path) gtk_entry_set_text(GTK_ENTRY(entry), options->file_ops.safe_delete_path);
- gtk_box_pack_start(GTK_BOX(gd->vbox), entry, FALSE, FALSE, 0);
+ if (options->file_ops.safe_delete_path) gq_gtk_entry_set_text(GTK_ENTRY(entry), options->file_ops.safe_delete_path);
+ gq_gtk_box_pack_start(GTK_BOX(gd->vbox), entry, FALSE, FALSE, 0);
gtk_widget_show(entry);
gtk_widget_show(gd->dialog);
}
-static void image_overlay_template_view_changed_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void image_overlay_template_view_changed_cb(GtkWidget *, gpointer data)
{
GtkWidget *pTextView;
GtkTextBuffer *pTextBuffer;
gtk_text_buffer_get_text(pTextBuffer, &iStart, &iEnd, TRUE));
}
-static void image_overlay_default_template_ok_cb(GenericDialog *UNUSED(gd), gpointer data)
+static void image_overlay_default_template_ok_cb(GenericDialog *, gpointer data)
{
auto text_view = static_cast<GtkTextView *>(data);
GtkTextBuffer *buffer;
gd = generic_dialog_new(_("Reset image overlay template string"),
"reset_image_overlay_template_string", widget, TRUE,
dummy_cancel_cb, data);
- generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Reset image overlay template string"),
+ generic_dialog_add_message(gd, GQ_ICON_DIALOG_QUESTION, _("Reset image overlay template string"),
_("This will reset the image overlay template string to the default.\nContinue?"), TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, image_overlay_default_template_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GQ_ICON_OK, "OK", image_overlay_default_template_ok_cb, TRUE);
gtk_widget_show(gd->dialog);
}
-static void image_overlay_help_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
+static void image_overlay_help_cb(GtkWidget *, gpointer)
{
help_window_show("GuideOptionsOSD.html");
}
-static void image_overlay_set_font_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void font_activated_cb(GtkFontChooser *widget, gchar *fontname, gpointer)
{
- GtkWidget *dialog;
- char *font;
- PangoFontDescription *font_desc;
+ g_free(c_options->image_overlay.font);
+ c_options->image_overlay.font = g_strdup(fontname);
+ g_free(fontname);
- dialog = gtk_font_chooser_dialog_new("Image Overlay Font", GTK_WINDOW(gtk_widget_get_toplevel(widget)));
- gtk_font_chooser_set_font(GTK_FONT_CHOOSER(dialog), options->image_overlay.font);
+ gq_gtk_widget_destroy(GTK_WIDGET(widget));
+}
+
+static void font_response_cb(GtkDialog *dialog, gint response_id, gpointer)
+{
+ gchar *font;
+
+ g_free(c_options->image_overlay.font);
+ c_options->image_overlay.font = g_strdup(options->image_overlay.font);
- if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL)
+ if (response_id == GTK_RESPONSE_OK)
{
- font_desc = gtk_font_chooser_get_font_desc(GTK_FONT_CHOOSER(dialog));
- font = pango_font_description_to_string(font_desc);
+ font = gtk_font_chooser_get_font(GTK_FONT_CHOOSER(dialog));
g_free(c_options->image_overlay.font);
c_options->image_overlay.font = g_strdup(font);
g_free(font);
}
- gtk_widget_destroy(dialog);
+ gq_gtk_widget_destroy(GTK_WIDGET(dialog));
}
-static void image_overlay_set_text_colour_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void image_overlay_set_font_cb(GtkWidget *widget, gpointer)
{
GtkWidget *dialog;
- GdkRGBA colour;
-
- dialog = gtk_color_chooser_dialog_new("Image Overlay Text Colour", GTK_WINDOW(gtk_widget_get_toplevel(widget)));
- colour.red = options->image_overlay.text_red;
- colour.green = options->image_overlay.text_green;
- colour.blue = options->image_overlay.text_blue;
- colour.alpha = options->image_overlay.text_alpha;
- gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(dialog), &colour);
- gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(dialog), TRUE);
- if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL)
+ dialog = gtk_font_chooser_dialog_new(_("Image Overlay Font"), GTK_WINDOW(gtk_widget_get_toplevel(widget)));
+ gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
+ gtk_font_chooser_set_font(GTK_FONT_CHOOSER(dialog), options->image_overlay.font);
+
+ g_signal_connect(dialog, "font-activated", G_CALLBACK(font_activated_cb), nullptr);
+ g_signal_connect(dialog, "response", G_CALLBACK(font_response_cb), nullptr);
+
+ gtk_widget_show(dialog);
+}
+
+static void text_color_activated_cb(GtkColorChooser *chooser, GdkRGBA *color, gpointer)
+{
+ c_options->image_overlay.text_red = color->red * 255;
+ c_options->image_overlay.text_green = color->green * 255;
+ c_options->image_overlay.text_blue = color->blue * 255;
+ c_options->image_overlay.text_alpha = color->alpha * 255;
+
+ gq_gtk_widget_destroy(GTK_WIDGET(chooser));
+}
+
+static void text_color_response_cb(GtkDialog *dialog, gint response_id, gpointer)
+{
+ GdkRGBA color;
+
+ c_options->image_overlay.text_red = options->image_overlay.text_red;
+ c_options->image_overlay.text_green = options->image_overlay.text_green;
+ c_options->image_overlay.text_blue = options->image_overlay.text_blue;
+ c_options->image_overlay.text_alpha = options->image_overlay.text_alpha;
+
+ if (response_id == GTK_RESPONSE_OK)
{
- gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(dialog), &colour);
- c_options->image_overlay.text_red = colour.red*255;
- c_options->image_overlay.text_green = colour.green*255;
- c_options->image_overlay.text_blue = colour.blue*255;
- c_options->image_overlay.text_alpha = colour.alpha*255;
+ gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(dialog), &color);
+ c_options->image_overlay.text_red = color.red * 255;
+ c_options->image_overlay.text_green = color.green * 255;
+ c_options->image_overlay.text_blue = color.blue * 255;
+ c_options->image_overlay.text_alpha = color.alpha * 255;
}
- gtk_widget_destroy(dialog);
-}
+ gq_gtk_widget_destroy(GTK_WIDGET(dialog));
+}
-static void image_overlay_set_background_colour_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void image_overlay_set_text_color_cb(GtkWidget *widget, gpointer)
{
GtkWidget *dialog;
- GdkRGBA colour;
-
- dialog = gtk_color_chooser_dialog_new("Image Overlay Background Colour", GTK_WINDOW(gtk_widget_get_toplevel(widget)));
- colour.red = options->image_overlay.background_red;
- colour.green = options->image_overlay.background_green;
- colour.blue = options->image_overlay.background_blue;
- colour.alpha = options->image_overlay.background_alpha;
- gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(dialog), &colour);
+ GdkRGBA color;
+
+ dialog = gtk_color_chooser_dialog_new(_("Image Overlay Text Color"), GTK_WINDOW(gtk_widget_get_toplevel(widget)));
+ color.red = options->image_overlay.text_red;
+ color.green = options->image_overlay.text_green;
+ color.blue = options->image_overlay.text_blue;
+ color.alpha = options->image_overlay.text_alpha;
+ gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(dialog), &color);
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(dialog), TRUE);
- if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL)
+ g_signal_connect(dialog, "color-activated", G_CALLBACK(text_color_activated_cb), nullptr);
+ g_signal_connect(dialog, "response", G_CALLBACK(text_color_response_cb), nullptr);
+
+ gtk_widget_show(dialog);
+}
+
+static void bg_color_activated_cb(GtkColorChooser *chooser, GdkRGBA *color, gpointer)
+{
+ c_options->image_overlay.background_red = color->red * 255;
+ c_options->image_overlay.background_green = color->green * 255;
+ c_options->image_overlay.background_blue = color->blue * 255;
+ c_options->image_overlay.background_alpha = color->alpha * 255;
+
+ gq_gtk_widget_destroy(GTK_WIDGET(chooser));
+}
+
+static void bg_color_response_cb(GtkDialog *dialog, gint response_id, gpointer)
+{
+ GdkRGBA color;
+
+ c_options->image_overlay.background_red = options->image_overlay.background_red;
+ c_options->image_overlay.background_green = options->image_overlay.background_green;
+ c_options->image_overlay.background_blue = options->image_overlay.background_blue;
+ c_options->image_overlay.background_alpha = options->image_overlay.background_alpha;
+
+ if (response_id == GTK_RESPONSE_OK)
{
- gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(dialog), &colour);
- c_options->image_overlay.background_red = colour.red*255;
- c_options->image_overlay.background_green = colour.green*255;
- c_options->image_overlay.background_blue = colour.blue*255;
- c_options->image_overlay.background_alpha = colour.alpha*255;
+ gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(dialog), &color);
+ c_options->image_overlay.background_red = color.red * 255;
+ c_options->image_overlay.background_green = color.green * 255;
+ c_options->image_overlay.background_blue = color.blue * 255;
+ c_options->image_overlay.background_alpha = color.alpha * 255;
}
- gtk_widget_destroy(dialog);
+ gq_gtk_widget_destroy(GTK_WIDGET(dialog));
+}
+
+static void image_overlay_set_background_color_cb(GtkWidget *widget, gpointer)
+{
+ GtkWidget *dialog;
+ GdkRGBA color;
+
+ dialog = gtk_color_chooser_dialog_new(_("Image Overlay Background Color"), GTK_WINDOW(gtk_widget_get_toplevel(widget)));
+ color.red = options->image_overlay.background_red;
+ color.green = options->image_overlay.background_green;
+ color.blue = options->image_overlay.background_blue;
+ color.alpha = options->image_overlay.background_alpha;
+ gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(dialog), &color);
+ gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(dialog), TRUE);
+
+ g_signal_connect(dialog, "color-activated", G_CALLBACK(bg_color_activated_cb), nullptr);
+ g_signal_connect(dialog, "response", G_CALLBACK(bg_color_response_cb), nullptr);
+
+ gtk_widget_show(dialog);
}
static void accel_store_populate()
{
LayoutWindow *lw;
- GList *groups, *actions;
+ GList *groups;
+ GList *actions;
GtkAction *action;
const gchar *accel_path;
+ const gchar *icon_name;
GtkAccelKey key;
GtkTreeIter iter;
accel_path = gtk_action_get_accel_path(action);
if (accel_path && gtk_accel_map_lookup_entry(accel_path, &key))
{
- gchar *label, *label2, *tooltip, *accel;
+ gchar *label;
+ gchar *label2;
+ gchar *tooltip;
+ gchar *accel;
g_object_get(action,
"tooltip", &tooltip,
"label", &label,
}
accel = gtk_accelerator_name(key.accel_key, key.accel_mods);
+ icon_name = gtk_action_get_icon_name(action);
if (tooltip)
{
AE_KEY, accel,
AE_TOOLTIP, tooltip ? tooltip : "",
AE_ACCEL, accel_path,
+ AE_ICON, icon_name,
-1);
}
}
}
-static void accel_store_cleared_cb(GtkCellRendererAccel *UNUSED(accel), gchar *UNUSED(path_string), gpointer UNUSED(user_data))
+static void accel_store_cleared_cb(GtkCellRendererAccel *, gchar *, gpointer)
{
}
-static gboolean accel_remove_key_cb(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer data)
+static gboolean accel_remove_key_cb(GtkTreeModel *model, GtkTreePath *, GtkTreeIter *iter, gpointer data)
{
auto accel1 = static_cast<gchar *>(data);
gchar *accel2;
}
-static void accel_store_edited_cb(GtkCellRendererAccel *UNUSED(accel), gchar *path_string, guint accel_key, GdkModifierType accel_mods, guint UNUSED(hardware_keycode), gpointer UNUSED(user_data))
+static void accel_store_edited_cb(GtkCellRendererAccel *, gchar *path_string, guint accel_key, GdkModifierType accel_mods, guint, gpointer)
{
auto model = reinterpret_cast<GtkTreeModel *>(accel_store);
GtkTreeIter iter;
gchar *acc;
gchar *accel_path;
- GtkAccelKey old_key, key;
+ GtkAccelKey old_key;
+ GtkAccelKey key;
GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
gtk_tree_model_get_iter(model, &iter, path);
return(G_SOURCE_REMOVE);
}
-static void accel_default_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void accel_default_cb(GtkWidget *, gpointer data)
{
accel_store_populate();
g_idle_add(reinterpret_cast<GSourceFunc>(accel_default_scroll), data);
}
-void accel_clear_selection(GtkTreeModel *UNUSED(model), GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer UNUSED(data))
+void accel_clear_selection(GtkTreeModel *, GtkTreePath *, GtkTreeIter *iter, gpointer)
{
gtk_tree_store_set(accel_store, iter, AE_KEY, "", -1);
}
-void accel_reset_selection(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer UNUSED(data))
+void accel_reset_selection(GtkTreeModel *model, GtkTreePath *, GtkTreeIter *iter, gpointer)
{
GtkAccelKey key;
- gchar *accel_path, *accel;
+ gchar *accel_path;
+ gchar *accel;
gtk_tree_model_get(model, iter, AE_ACCEL, &accel_path, -1);
gtk_accel_map_lookup_entry(accel_path, &key);
g_free(accel);
}
-static void accel_clear_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void accel_clear_cb(GtkWidget *, gpointer data)
{
GtkTreeSelection *selection;
gtk_tree_selection_selected_foreach(selection, &accel_clear_selection, nullptr);
}
-static void accel_reset_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void accel_reset_cb(GtkWidget *, gpointer data)
{
GtkTreeSelection *selection;
GtkWidget *scrolled;
GtkWidget *viewport;
- scrolled = gtk_scrolled_window_new(nullptr, nullptr);
+ scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
gtk_container_set_border_width(GTK_CONTAINER(scrolled), PREF_PAD_BORDER);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
viewport = gtk_viewport_new(nullptr, nullptr);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
- gtk_container_add(GTK_CONTAINER(scrolled), viewport);
+ gq_gtk_container_add(GTK_WIDGET(scrolled), viewport);
gtk_widget_show(viewport);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add(GTK_CONTAINER(viewport), vbox);
+ gq_gtk_container_add(GTK_WIDGET(viewport), vbox);
gtk_widget_show(vbox);
return vbox;
}
-static void cache_standard_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void cache_standard_cb(GtkWidget *widget, gpointer)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
}
}
-static void cache_geeqie_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void cache_geeqie_cb(GtkWidget *widget, gpointer)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
}
}
-static void cache_local_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void cache_local_cb(GtkWidget *widget, gpointer)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
}
}
-static void help_search_engine_entry_icon_cb(GtkEntry *UNUSED(entry), GtkEntryIconPosition pos,
- GdkEvent *UNUSED(event), gpointer userdata)
+static void help_search_engine_entry_icon_cb(GtkEntry *, GtkEntryIconPosition pos, GdkEvent *, gpointer userdata)
{
if (pos == GTK_ENTRY_ICON_PRIMARY)
{
- gtk_entry_set_text(GTK_ENTRY(userdata), HELP_SEARCH_ENGINE);
+ gq_gtk_entry_set_text(GTK_ENTRY(userdata), HELP_SEARCH_ENGINE);
}
else
{
- gtk_entry_set_text(GTK_ENTRY(userdata), "");
+ gq_gtk_entry_set_text(GTK_ENTRY(userdata), "");
}
}
-static void star_rating_star_icon_cb(GtkEntry *UNUSED(entry), GtkEntryIconPosition pos,
- GdkEvent *UNUSED(event), gpointer userdata)
+static void star_rating_star_icon_cb(GtkEntry *, GtkEntryIconPosition pos, GdkEvent *, gpointer userdata)
{
gchar *rating_symbol;
if (pos == GTK_ENTRY_ICON_PRIMARY)
{
rating_symbol = g_strdup_printf("U+%X", STAR_RATING_STAR);
- gtk_entry_set_text(GTK_ENTRY(userdata), rating_symbol);
+ gq_gtk_entry_set_text(GTK_ENTRY(userdata), rating_symbol);
g_free(rating_symbol);
}
else
{
- gtk_entry_set_text(GTK_ENTRY(userdata), "U+");
+ gq_gtk_entry_set_text(GTK_ENTRY(userdata), "U+");
gtk_widget_grab_focus(GTK_WIDGET(userdata));
gtk_editable_select_region(GTK_EDITABLE(userdata), 2, 2);
}
}
-static void star_rating_rejected_icon_cb(GtkEntry *UNUSED(entry), GtkEntryIconPosition pos,
- GdkEvent *UNUSED(event), gpointer userdata)
+static void star_rating_rejected_icon_cb(GtkEntry *, GtkEntryIconPosition pos, GdkEvent *, gpointer userdata)
{
gchar *rating_symbol;
if (pos == GTK_ENTRY_ICON_PRIMARY)
{
rating_symbol = g_strdup_printf("U+%X", STAR_RATING_REJECTED);
- gtk_entry_set_text(GTK_ENTRY(userdata), rating_symbol);
+ gq_gtk_entry_set_text(GTK_ENTRY(userdata), rating_symbol);
g_free(rating_symbol);
}
else
{
- gtk_entry_set_text(GTK_ENTRY(userdata), "U+");
+ gq_gtk_entry_set_text(GTK_ENTRY(userdata), "U+");
gtk_widget_grab_focus(GTK_WIDGET(userdata));
gtk_editable_select_region(GTK_EDITABLE(userdata), 2, 2);
}
}
-static guint star_rating_symbol_test(GtkWidget *UNUSED(widget), gpointer data)
+static guint star_rating_symbol_test(GtkWidget *, gpointer data)
{
auto hbox = static_cast<GtkContainer *>(data);
GString *str = g_string_new(nullptr);
list = gtk_container_get_children(hbox);
hex_code_entry = static_cast<GtkEntry *>(g_list_nth_data(list, 2));
- hex_code_full = g_strdup(gtk_entry_get_text(hex_code_entry));
+ hex_code_full = g_strdup(gq_gtk_entry_get_text(hex_code_entry));
hex_code = g_strsplit(hex_code_full, "+", 2);
if (hex_code[0] && hex_code[1])
GtkWidget *ct_button;
GtkWidget *table;
GtkWidget *spin;
- gint hours, minutes, remainder;
+ gint hours;
+ gint minutes;
+ gint remainder;
gdouble seconds;
GtkWidget *star_rating_entry;
GString *str;
options->thumbnails.collection_preview, &c_options->thumbnails.collection_preview);
gtk_widget_set_tooltip_text(spin, _("The maximum number of thumbnails shown in a Collection preview montage"));
-#ifdef HAVE_FFMPEGTHUMBNAILER_METADATA
+#if HAVE_FFMPEGTHUMBNAILER_METADATA
pref_checkbox_new_int(group, _("Use embedded metadata in video files as thumbnails when available"),
options->thumbnails.use_ft_metadata, &c_options->thumbnails.use_ft_metadata);
#endif
pref_label_new(hbox, g_strdup(str->str));
rating_symbol = g_strdup_printf("U+%X", options->star_rating.star);
star_rating_entry = gtk_entry_new();
- gtk_entry_set_text(GTK_ENTRY(star_rating_entry), rating_symbol);
- gtk_box_pack_start(GTK_BOX(hbox), star_rating_entry, FALSE, FALSE, 0);
+ gq_gtk_entry_set_text(GTK_ENTRY(star_rating_entry), rating_symbol);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), star_rating_entry, FALSE, FALSE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(star_rating_entry), 15);
gtk_widget_show(star_rating_entry);
- button = pref_button_new(nullptr, nullptr, _("Set"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Set"),
G_CALLBACK(star_rating_star_test_cb), hbox);
gtk_widget_set_tooltip_text(button, _("Display selected character"));
- gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
gtk_widget_set_tooltip_text(star_rating_entry, _("Hexadecimal representation of a Unicode character. A list of all Unicode characters may be found on the Internet."));
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(star_rating_entry),
- GTK_ENTRY_ICON_SECONDARY, "edit-clear");
+ GTK_ENTRY_ICON_SECONDARY, GQ_ICON_CLEAR);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY(star_rating_entry),
GTK_ENTRY_ICON_SECONDARY, _("Clear"));
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(star_rating_entry),
- GTK_ENTRY_ICON_PRIMARY, "document-revert");
+ GTK_ENTRY_ICON_PRIMARY, GQ_ICON_REVERT);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY(star_rating_entry),
GTK_ENTRY_ICON_PRIMARY, _("Default"));
g_signal_connect(GTK_ENTRY(star_rating_entry), "icon-press",
pref_label_new(hbox, g_strdup(str->str));
rating_symbol = g_strdup_printf("U+%X", options->star_rating.rejected);
star_rating_entry = gtk_entry_new();
- gtk_entry_set_text(GTK_ENTRY(star_rating_entry), rating_symbol);
- gtk_box_pack_start(GTK_BOX(hbox), star_rating_entry, FALSE, FALSE, 0);
+ gq_gtk_entry_set_text(GTK_ENTRY(star_rating_entry), rating_symbol);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), star_rating_entry, FALSE, FALSE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(star_rating_entry), 15);
gtk_widget_show(star_rating_entry);
- button = pref_button_new(nullptr, nullptr, _("Set"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Set"),
G_CALLBACK(star_rating_rejected_test_cb), hbox);
gtk_widget_set_tooltip_text(button, _("Display selected character"));
- gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
gtk_widget_set_tooltip_text(star_rating_entry, _("Hexadecimal representation of a Unicode character. A list of all Unicode characters may be found on the Internet."));
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(star_rating_entry),
- GTK_ENTRY_ICON_SECONDARY, "edit-clear");
+ GTK_ENTRY_ICON_SECONDARY, GQ_ICON_CLEAR);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY(star_rating_entry),
GTK_ENTRY_ICON_SECONDARY, _("Clear"));
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(star_rating_entry),
- GTK_ENTRY_ICON_PRIMARY, "document-revert");
+ GTK_ENTRY_ICON_PRIMARY, GQ_ICON_REVERT);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY(star_rating_entry),
GTK_ENTRY_ICON_PRIMARY, _("Default"));
g_signal_connect(GTK_ENTRY(star_rating_entry), "icon-press",
pref_spacer(group, PREF_PAD_GROUP);
- group = pref_group_new(vbox, FALSE, _("Expand menu and toolbar"), GTK_ORIENTATION_VERTICAL);
+ group = pref_group_new(vbox, FALSE, _("Menu style"), GTK_ORIENTATION_VERTICAL);
+
+ pref_checkbox_new_int(group, _("☰ style menu button (NOTE! Geeqie must be restarted for change to take effect)"),
+ options->hamburger_menu, &c_options->hamburger_menu);
+ gtk_widget_set_tooltip_text(group, _("Use a ☰ style menu button instead of the classic style across the top of the frame"));
+
+ pref_spacer(group, PREF_PAD_GROUP);
+
+ group = pref_group_new(vbox, FALSE, _("Expand toolbar"), GTK_ORIENTATION_VERTICAL);
- pref_checkbox_new_int(group, _("Expand menu and toolbar (NOTE! Geeqie must be restarted for change to take effect)"),
+ pref_checkbox_new_int(group, _("Expand menu/toolbar (NOTE! Geeqie must be restarted for change to take effect)"),
options->expand_menu_toolbar, &c_options->expand_menu_toolbar);
- gtk_widget_set_tooltip_text(group, _("Expand the menu and toolbar to the full width of the window"));
+ gtk_widget_set_tooltip_text(group, _("Expand the menu/toolbar to the full width of the window"));
+
+ pref_spacer(group, PREF_PAD_GROUP);
+
+ group = pref_group_new(vbox, FALSE, _("Hide Selectable Bars"), GTK_ORIENTATION_VERTICAL);
+
+ pref_checkbox_new_int(group, _("Menu bar"),
+ options->selectable_bars.menu_bar, &c_options->selectable_bars.menu_bar);
+
+ pref_checkbox_new_int(group, _("Tool bar"),
+ options->selectable_bars.tool_bar, &c_options->selectable_bars.tool_bar);
+
+ pref_checkbox_new_int(group, _("Status bar"),
+ options->selectable_bars.status_bar, &c_options->selectable_bars.status_bar);
+ gtk_widget_set_tooltip_text(group, _("The Hide Selectable Bars menu item (default keystroke is control-backtick) will toggle the display of the bars selected here"));
pref_spacer(group, PREF_PAD_GROUP);
if (isfile(tz->timezone_database_user))
{
- button = pref_button_new(GTK_WIDGET(hbox), nullptr, _("Update"), FALSE, G_CALLBACK(timezone_database_install_cb), tz);
+ button = pref_button_new(GTK_WIDGET(hbox), nullptr, _("Update"), G_CALLBACK(timezone_database_install_cb), tz);
}
else
{
- button = pref_button_new(GTK_WIDGET(hbox), nullptr, _("Install"), FALSE, G_CALLBACK(timezone_database_install_cb), tz);
+ button = pref_button_new(GTK_WIDGET(hbox), nullptr, _("Install"), G_CALLBACK(timezone_database_install_cb), tz);
}
download_locn = g_strconcat(_("Download database from: "), TIMEZONE_DATABASE_WEB, NULL);
group = pref_group_new(vbox, FALSE, _("On-line help search engine"), GTK_ORIENTATION_VERTICAL);
help_search_engine_entry = gtk_entry_new();
- gtk_entry_set_text(GTK_ENTRY(help_search_engine_entry), options->help_search_engine);
- gtk_box_pack_start(GTK_BOX(group), help_search_engine_entry, FALSE, FALSE, 0);
+ gq_gtk_entry_set_text(GTK_ENTRY(help_search_engine_entry), options->help_search_engine);
+ gq_gtk_box_pack_start(GTK_BOX(group), help_search_engine_entry, FALSE, FALSE, 0);
gtk_widget_show(help_search_engine_entry);
gtk_widget_set_tooltip_text(help_search_engine_entry, _("The format varies between search engines, e.g the format may be:\nhttps://www.search_engine.com/search?q=site:geeqie.org/help\nhttps://www.search_engine.com/?q=site:geeqie.org/help"));
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(help_search_engine_entry),
- GTK_ENTRY_ICON_SECONDARY, "edit-clear");
+ GTK_ENTRY_ICON_SECONDARY, GQ_ICON_CLEAR);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY(help_search_engine_entry),
GTK_ENTRY_ICON_SECONDARY, _("Clear"));
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(help_search_engine_entry),
- GTK_ENTRY_ICON_PRIMARY, "document-revert");
+ GTK_ENTRY_ICON_PRIMARY, GQ_ICON_REVERT);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY(help_search_engine_entry),
GTK_ENTRY_ICON_PRIMARY, _("Default"));
g_signal_connect(GTK_ENTRY(help_search_engine_entry), "icon-press",
gtk_widget_set_tooltip_text(GTK_WIDGET(hbox), _("Enable this to allow Geeqie to increase the image size for images that are smaller than the current view area when the zoom is set to \"Fit image to window\". This value sets the maximum expansion permitted in percent i.e. 100% is full-size."));
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
- ct_button = pref_checkbox_new_int(hbox, _("Virtual window size (% of actual window):"),
+ ct_button = pref_checkbox_new_int(hbox, _("Virtual window size (%% of actual window):"),
options->image.limit_autofit_size, &c_options->image.limit_autofit_size);
spin = pref_spin_new_int(hbox, nullptr, nullptr,
10, 150, 1,
/* windows tab */
-static void save_default_window_layout_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
+static void save_default_window_layout_cb(GtkWidget *, gpointer)
{
LayoutWindow *lw = nullptr;
gchar *default_path;
layout_valid(&lw);
tmp_id = lw->options.id;
- lw->options.id = g_strdup("lw_default");
+ lw->options.id = g_strdup("");
default_path = g_build_filename(get_rc_dir(), DEFAULT_WINDOW_LAYOUT, NULL);
save_default_layout_options_to_file(default_path, options, lw);
return FALSE;
}
-static void default_layout_changed_cb(GtkWidget *UNUSED(button), GtkPopover *popover)
+static void default_layout_changed_cb(GtkWidget *, GtkPopover *popover)
{
gtk_popover_popup(popover);
popover = gtk_popover_new(parent);
gtk_popover_set_position(GTK_POPOVER (popover), pos);
- gtk_container_add (GTK_CONTAINER(popover), child);
+ gq_gtk_container_add(GTK_WIDGET(popover), child);
gtk_container_set_border_width(GTK_CONTAINER (popover), 6);
gtk_widget_show (child);
GtkWidget *group;
GtkWidget *subgroup;
GtkWidget *button;
+ GtkWidget *checkbox;
GtkWidget *ct_button;
GtkWidget *spin;
ct_button = pref_checkbox_new_int(group, _("Remember session"),
options->save_window_positions, &c_options->save_window_positions);
- button = pref_checkbox_new_int(group, _("Use saved window positions also for new windows"),
+ checkbox = pref_checkbox_new_int(group, _("Use saved window positions also for new windows"),
options->use_saved_window_positions_for_new_windows, &c_options->use_saved_window_positions_for_new_windows);
- pref_checkbox_link_sensitivity(ct_button, button);
+ pref_checkbox_link_sensitivity(ct_button, checkbox);
- button = pref_checkbox_new_int(group, _("Remember window workspace"),
+ checkbox = pref_checkbox_new_int(group, _("Remember window workspace"),
options->save_window_workspace, &c_options->save_window_workspace);
- pref_checkbox_link_sensitivity(ct_button, button);
+ pref_checkbox_link_sensitivity(ct_button, checkbox);
pref_checkbox_new_int(group, _("Remember tool state (float/hidden)"),
options->tools_restore_state, &c_options->tools_restore_state);
subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(subgroup, _("Use current layout for default: "));
- button = pref_button_new(subgroup, nullptr, _("Set"), FALSE, G_CALLBACK(save_default_window_layout_cb), nullptr);
+ button = pref_button_new(subgroup, nullptr, _("Set"), G_CALLBACK(save_default_window_layout_cb), nullptr);
GtkWidget *popover;
c_options->fullscreen.screen = options->fullscreen.screen;
c_options->fullscreen.above = options->fullscreen.above;
hbox = fullscreen_prefs_selection_new(_("Location:"), &c_options->fullscreen.screen, &c_options->fullscreen.above);
- gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
pref_checkbox_new_int(group, _("Smooth image flip"),
options->fullscreen.disable_saver, &c_options->fullscreen.disable_saver);
}
-#define PRE_FORMATTED_COLUMNS 5
static void config_tab_osd(GtkWidget *notebook)
{
GtkWidget *hbox;
scrolled_pre_formatted = osd_new(PRE_FORMATTED_COLUMNS, image_overlay_template_view);
gtk_widget_set_size_request(scrolled_pre_formatted, 200, 150);
- gtk_box_pack_start(GTK_BOX(subgroup), scrolled_pre_formatted, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(subgroup), scrolled_pre_formatted, FALSE, FALSE, 0);
gtk_widget_show(scrolled_pre_formatted);
gtk_widget_show(subgroup);
pref_label_new(group, _("Image overlay template"));
- scrolled = gtk_scrolled_window_new(nullptr, nullptr);
+ scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
gtk_widget_set_size_request(scrolled, 200, 150);
- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
+ gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
- gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 5);
+ gq_gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 5);
gtk_widget_show(scrolled);
gtk_widget_set_tooltip_markup(image_overlay_template_view,
_("Extensive formatting options are shown in the Help file"));
- gtk_container_add(GTK_CONTAINER(scrolled), image_overlay_template_view);
+ gq_gtk_container_add(GTK_WIDGET(scrolled), image_overlay_template_view);
gtk_widget_show(image_overlay_template_view);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(nullptr, GTK_STOCK_SELECT_FONT, _("Font"), FALSE,
+ button = pref_button_new(nullptr, GQ_ICON_SELECT_FONT, _("Font"),
G_CALLBACK(image_overlay_set_font_cb), notebook);
- gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(nullptr, GTK_STOCK_COLOR_PICKER, _("Text"), FALSE,
- G_CALLBACK(image_overlay_set_text_colour_cb), nullptr);
- gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ button = pref_button_new(nullptr, GQ_ICON_SELECT_COLOR, _("Text"), G_CALLBACK(image_overlay_set_text_color_cb), nullptr);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(nullptr, GTK_STOCK_COLOR_PICKER, _("Background"), FALSE,
- G_CALLBACK(image_overlay_set_background_colour_cb), nullptr);
- gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ button = pref_button_new(nullptr, GQ_ICON_SELECT_COLOR, _("Background"), G_CALLBACK(image_overlay_set_background_color_cb), nullptr);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- image_overlay_set_text_colours();
+ image_overlay_set_text_colors();
- button = pref_button_new(nullptr, nullptr, _("Defaults"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Defaults"),
G_CALLBACK(image_overlay_default_template_cb), image_overlay_template_view);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(nullptr, GTK_STOCK_HELP, nullptr, FALSE,
+ button = pref_button_new(nullptr, GQ_ICON_HELP, _("Help"),
G_CALLBACK(image_overlay_help_cb), nullptr);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(image_overlay_template_view));
group = pref_group_new(vbox, FALSE, _("Exif, XMP or IPTC tags"), GTK_ORIENTATION_VERTICAL);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
label = gtk_label_new(_("%Exif.Image.Orientation%"));
- gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
gtk_widget_show(label);
pref_spacer(group,TRUE);
group = pref_group_new(vbox, FALSE, _("Field separators"), GTK_ORIENTATION_VERTICAL);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
label = gtk_label_new(_("Separator shown only if both fields are non-null:\n%formatted.ShutterSpeed%|%formatted.ISOSpeedRating%"));
- gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
gtk_widget_show(label);
pref_spacer(group,TRUE);
group = pref_group_new(vbox, FALSE, _("Field maximum length"), GTK_ORIENTATION_VERTICAL);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
label = gtk_label_new(_("%path:39%"));
- gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
gtk_widget_show(label);
pref_spacer(group,TRUE);
group = pref_group_new(vbox, FALSE, _("Pre- and post- text"), GTK_ORIENTATION_VERTICAL);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
label = gtk_label_new(_("Text shown only if the field is non-null:\n%formatted.Aperture:F no. * setting%\n %formatted.Aperture:10:F no. * setting%"));
- gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
gtk_widget_show(label);
pref_spacer(group,TRUE);
group = pref_group_new(vbox, FALSE, _("Pango markup"), GTK_ORIENTATION_VERTICAL);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
label = gtk_label_new(_("<b>bold</b>\n<u>underline</u>\n<i>italic</i>\n<s>strikethrough</s>"));
- gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
gtk_widget_show(label);
}
return ret;
}
-static gboolean search_function_cb(GtkTreeModel *model, gint UNUSED(column), const gchar *key, GtkTreeIter *iter, gpointer UNUSED(search_data))
+static gboolean search_function_cb(GtkTreeModel *model, gint, const gchar *key, GtkTreeIter *iter, gpointer)
{
FilterEntry *fe;
gboolean ret = TRUE;
options->file_filter.show_hidden_files, &c_options->file_filter.show_hidden_files);
pref_checkbox_new_int(group, _("Show parent folder (..)"),
options->file_filter.show_parent_directory, &c_options->file_filter.show_parent_directory);
- pref_checkbox_new_int(group, _("Case sensitive sort"),
- options->file_sort.case_sensitive, &c_options->file_sort.case_sensitive);
- pref_checkbox_new_int(group, _("Natural sort order - Requires restart"),
- options->file_sort.natural, &c_options->file_sort.natural);
+ pref_checkbox_new_int(group, _("Case sensitive sort (Search and Collection windows, and tab completion)"), options->file_sort.case_sensitive, &c_options->file_sort.case_sensitive);
pref_checkbox_new_int(group, _("Disable file extension checks"),
options->file_filter.disable_file_extension_checks, &c_options->file_filter.disable_file_extension_checks);
group = pref_group_new(vbox, FALSE, _("Grouping sidecar extensions"), GTK_ORIENTATION_VERTICAL);
sidecar_ext_entry = gtk_entry_new();
- gtk_entry_set_text(GTK_ENTRY(sidecar_ext_entry), options->sidecar.ext);
- gtk_box_pack_start(GTK_BOX(group), sidecar_ext_entry, FALSE, FALSE, 0);
+ gq_gtk_entry_set_text(GTK_ENTRY(sidecar_ext_entry), options->sidecar.ext);
+ gq_gtk_box_pack_start(GTK_BOX(group), sidecar_ext_entry, FALSE, FALSE, 0);
gtk_widget_show(sidecar_ext_entry);
group = pref_group_new(vbox, TRUE, _("File types"), GTK_ORIENTATION_VERTICAL);
G_CALLBACK(filter_disable_cb), frame);
gtk_widget_set_sensitive(frame, !options->file_filter.disable);
- scrolled = gtk_scrolled_window_new(nullptr, nullptr);
- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
+ scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
+ gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
- gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
filter_store = gtk_list_store_new(1, G_TYPE_POINTER);
gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_SIDECAR);
filter_store_populate();
- gtk_container_add(GTK_CONTAINER(scrolled), filter_view);
+ gq_gtk_container_add(GTK_WIDGET(scrolled), filter_view);
gtk_widget_show(filter_view);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(nullptr, nullptr, _("Defaults"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Defaults"),
G_CALLBACK(filter_default_cb), filter_view);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(nullptr, GTK_STOCK_REMOVE, nullptr, FALSE,
+ button = pref_button_new(nullptr, GQ_ICON_REMOVE, _("Remove"),
G_CALLBACK(filter_remove_cb), filter_view);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(nullptr, GTK_STOCK_ADD, nullptr, FALSE,
+ button = pref_button_new(nullptr, GQ_ICON_ADD, _("Add"),
G_CALLBACK(filter_add_cb), filter_view);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
}
group = pref_group_new(vbox, FALSE, _("Metadata writing sequence"), GTK_ORIENTATION_VERTICAL);
-#ifndef HAVE_EXIV2
+#if !HAVE_EXIV2
label = pref_label_new(group, _("Warning: Geeqie is built without Exiv2. Some options are disabled."));
#endif
label = pref_label_new(group, _("When writing metadata, Geeqie will follow these steps, if selected. This process will stop when the first successful write occurs."));
gtk_widget_set_tooltip_markup(ct_button, markup);
g_free(markup);
-#ifndef HAVE_EXIV2
+#if !HAVE_EXIV2
gtk_widget_set_sensitive(ct_button, FALSE);
#endif
gtk_label_set_xalign(GTK_LABEL(label), 0.0);
gtk_label_set_yalign(GTK_LABEL(label), 0.5);
- gtk_misc_set_padding(GTK_MISC(label), 22, 0);
+ gtk_widget_set_margin_start(label, 22);
pref_spacer(group, PREF_PAD_GROUP);
group = pref_group_new(vbox, FALSE, _("Step 1 Options:"), GTK_ORIENTATION_VERTICAL);
-#ifndef HAVE_EXIV2
+#if !HAVE_EXIV2
gtk_widget_set_sensitive(group, FALSE);
#endif
pref_spacer(group, PREF_PAD_GROUP);
group = pref_group_new(vbox, FALSE, _("Steps 2 and 3 Option:"), GTK_ORIENTATION_VERTICAL);
-#ifndef HAVE_EXIV2
+#if !HAVE_EXIV2
gtk_widget_set_sensitive(group, FALSE);
#endif
ct_button = pref_checkbox_new_int(group, _("Write altered image orientation to the metadata"), options->metadata.write_orientation, &c_options->metadata.write_orientation);
gtk_widget_set_tooltip_text(ct_button, _("If checked, the results of orientation commands (Rotate, Mirror and Flip) issued on an image will be written to metadata\nNote: If this option is not checked, the results of orientation commands will be lost when Geeqie closes"));
-#ifndef HAVE_EXIV2
+#if !HAVE_EXIV2
gtk_widget_set_sensitive(ct_button, FALSE);
#endif
pref_spacer(group, PREF_PAD_GROUP);
-#ifdef HAVE_SPELL
+#if HAVE_SPELL
group = pref_group_new(vbox, FALSE, _("Spelling checks"), GTK_ORIENTATION_VERTICAL);
ct_button = pref_checkbox_new_int(group, _("Check spelling - Requires restart"), options->metadata.check_spelling, &c_options->metadata.check_spelling);
guint idle_id; /* event source id */
};
-#define KEYWORD_DIALOG_WIDTH 400
-
static void keywords_find_folder(KeywordFindData *kfd, FileData *dir_fd)
{
GList *list_d = nullptr;
kfd->list_dir = nullptr;
}
-static void keywords_find_close_cb(GenericDialog *UNUSED(fd), gpointer data)
+static void keywords_find_close_cb(GenericDialog *, gpointer data)
{
auto kfd = static_cast<KeywordFindData *>(data);
{
keywords_find_reset(kfd);
- gtk_entry_set_text(GTK_ENTRY(kfd->progress), _("done"));
- spinner_set_interval(kfd->spinner, -1);
+ gq_gtk_entry_set_text(GTK_ENTRY(kfd->progress), _("done"));
+ gtk_spinner_stop(GTK_SPINNER(kfd->spinner));
gtk_widget_set_sensitive(kfd->group, TRUE);
gtk_widget_set_sensitive(kfd->button_start, TRUE);
gtk_widget_set_sensitive(kfd->button_close, TRUE);
}
-static void keywords_find_stop_cb(GenericDialog *UNUSED(fd), gpointer data)
+static void keywords_find_stop_cb(GenericDialog *, gpointer data)
{
auto kfd = static_cast<KeywordFindData *>(data);
keywords = keywords->next;
}
- gtk_entry_set_text(GTK_ENTRY(kfd->progress), fd->path);
+ gq_gtk_entry_set_text(GTK_ENTRY(kfd->progress), fd->path);
file_data_unref(fd);
g_list_free_full(keywords, g_free);
return (G_SOURCE_CONTINUE);
}
- else if (kfd->list_dir)
+
+ if (kfd->list_dir)
{
FileData *fd;
return G_SOURCE_REMOVE;
}
-static void keywords_find_start_cb(GenericDialog *UNUSED(fd), gpointer data)
+static void keywords_find_start_cb(GenericDialog *, gpointer data)
{
auto kfd = static_cast<KeywordFindData *>(data);
gchar *path;
if (kfd->list || !gtk_widget_get_sensitive(kfd->button_start)) return;
- path = remove_trailing_slash((gtk_entry_get_text(GTK_ENTRY(kfd->entry))));
+ path = remove_trailing_slash((gq_gtk_entry_get_text(GTK_ENTRY(kfd->entry))));
parse_out_relatives(path);
if (!isdir(path))
{
warning_dialog(_("Invalid folder"),
_("The specified folder can not be found."),
- GTK_STOCK_DIALOG_WARNING, kfd->gd->dialog);
+ GQ_ICON_DIALOG_WARNING, kfd->gd->dialog);
}
else
{
gtk_widget_set_sensitive(kfd->button_start, FALSE);
gtk_widget_set_sensitive(kfd->button_stop, TRUE);
gtk_widget_set_sensitive(kfd->button_close, FALSE);
- spinner_set_interval(kfd->spinner, SPINNER_SPEED);
+ gtk_spinner_start(GTK_SPINNER(kfd->spinner));
dir_fd = file_data_new_dir(path);
keywords_find_folder(kfd, dir_fd);
nullptr, kfd);
gtk_window_set_default_size(GTK_WINDOW(kfd->gd->dialog), KEYWORD_DIALOG_WIDTH, -1);
kfd->gd->cancel_cb = keywords_find_close_cb;
- kfd->button_close = generic_dialog_add_button(kfd->gd, GTK_STOCK_CLOSE, nullptr,
+ kfd->button_close = generic_dialog_add_button(kfd->gd, GQ_ICON_CLOSE, _("Close"),
keywords_find_close_cb, FALSE);
- kfd->button_start = generic_dialog_add_button(kfd->gd, GTK_STOCK_OK, _("S_tart"),
+ kfd->button_start = generic_dialog_add_button(kfd->gd, GQ_ICON_OK, _("S_tart"),
keywords_find_start_cb, FALSE);
- kfd->button_stop = generic_dialog_add_button(kfd->gd, GTK_STOCK_STOP, nullptr,
+ kfd->button_stop = generic_dialog_add_button(kfd->gd, GQ_ICON_STOP, _("Stop"),
keywords_find_stop_cb, FALSE);
gtk_widget_set_sensitive(kfd->button_stop, FALSE);
label = tab_completion_new(&kfd->entry, path, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(kfd->entry,_("Select folder") , TRUE);
- gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
pref_checkbox_new_int(kfd->group, _("Include subfolders"), FALSE, &kfd->recurse);
kfd->progress = gtk_entry_new();
gtk_widget_set_can_focus(kfd->progress, FALSE);
gtk_editable_set_editable(GTK_EDITABLE(kfd->progress), FALSE);
- gtk_entry_set_text(GTK_ENTRY(kfd->progress), _("click start to begin"));
- gtk_box_pack_start(GTK_BOX(hbox), kfd->progress, TRUE, TRUE, 0);
+ gq_gtk_entry_set_text(GTK_ENTRY(kfd->progress), _("click start to begin"));
+ gq_gtk_box_pack_start(GTK_BOX(hbox), kfd->progress, TRUE, TRUE, 0);
gtk_widget_show(kfd->progress);
- kfd->spinner = spinner_new(nullptr, -1);
- gtk_box_pack_start(GTK_BOX(hbox), kfd->spinner, FALSE, FALSE, 0);
+ kfd->spinner = gtk_spinner_new();
+ gq_gtk_box_pack_start(GTK_BOX(hbox), kfd->spinner, FALSE, FALSE, 0);
gtk_widget_show(kfd->spinner);
kfd->list = nullptr;
gtk_widget_show(kfd->gd->dialog);
}
-static void keywords_find_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void keywords_find_cb(GtkWidget *widget, gpointer)
{
const gchar *path = layout_get_path(nullptr);
static void config_tab_keywords_save()
{
- GtkTextIter start, end;
+ GtkTextIter start;
+ GtkTextIter end;
GtkTextBuffer *buffer;
GList *kw_list = nullptr;
GList *work;
GtkTextIter iter;
GtkTextBuffer *buffer;
gchar *tmp;
-#ifdef HAVE_SPELL
+#if HAVE_SPELL
GspellTextView *gspell_view;
#endif
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(hbox, GTK_STOCK_EXECUTE, _("Search"), FALSE,
+ button = pref_button_new(hbox, GQ_ICON_RUN, _("Search"),
G_CALLBACK(keywords_find_cb), keyword_text);
- gtk_widget_set_tooltip_text(button, "Search for existing keywords");
+ gtk_widget_set_tooltip_text(button, _("Search for existing keywords"));
keyword_text = gtk_text_view_new();
gtk_widget_set_size_request(keyword_text, 20, 20);
- scrolled = gtk_scrolled_window_new(nullptr, nullptr);
- gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
+ scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
+ gq_gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
-#ifdef HAVE_SPELL
+#if HAVE_SPELL
if (options->metadata.check_spelling)
{
gspell_view = gspell_text_view_get_from_gtk_text_view(GTK_TEXT_VIEW(keyword_text));
}
#endif
- gtk_container_add(GTK_CONTAINER(scrolled), keyword_text);
+ gq_gtk_container_add(GTK_WIDGET(scrolled), keyword_text);
gtk_widget_show(keyword_text);
gtk_text_view_set_editable(GTK_TEXT_VIEW(keyword_text), TRUE);
}
/* metadata tab */
-#ifdef HAVE_LCMS
+#if HAVE_LCMS
static void intent_menu_cb(GtkWidget *combo, gpointer data)
{
auto option = static_cast<gint *>(data);
*option_c = option;
- pref_table_label(table, column, row, text, 0.0);
+ pref_table_label(table, column, row, text, GTK_ALIGN_START);
combo = gtk_combo_box_text_new();
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
- gtk_widget_set_tooltip_text(combo,"Refer to the lcms documentation for the defaults used when the selected Intent is not available");
+ gtk_widget_set_tooltip_text(combo,_("Refer to the lcms documentation for the defaults used when the selected Intent is not available"));
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(intent_menu_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(combo);
}
#endif
vbox = scrolled_notebook_page(notebook, _("Color management"));
group = pref_group_new(vbox, FALSE, _("Input profiles"), GTK_ORIENTATION_VERTICAL);
-#ifndef HAVE_LCMS
+#if !HAVE_LCMS
gtk_widget_set_sensitive(pref_group_parent(group), FALSE);
#endif
table = pref_table_new(group, 3, COLOR_PROFILE_INPUTS + 1, FALSE, FALSE);
- gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
+ gtk_grid_set_column_spacing(GTK_GRID(table), PREF_PAD_GAP);
- label = pref_table_label(table, 0, 0, _("Type"), 0.0);
+ label = pref_table_label(table, 0, 0, _("Type"), GTK_ALIGN_START);
pref_label_bold(label, TRUE, FALSE);
- label = pref_table_label(table, 1, 0, _("Menu name"), 0.0);
+ label = pref_table_label(table, 1, 0, _("Menu name"), GTK_ALIGN_START);
pref_label_bold(label, TRUE, FALSE);
- label = pref_table_label(table, 2, 0, _("File"), 0.0);
+ label = pref_table_label(table, 2, 0, _("File"), GTK_ALIGN_START);
pref_label_bold(label, TRUE, FALSE);
for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
gchar *buf;
buf = g_strdup_printf(_("Input %d:"), i + COLOR_PROFILE_FILE);
- pref_table_label(table, 0, i + 1, buf, 1.0);
+ pref_table_label(table, 0, i + 1, buf, GTK_ALIGN_END);
g_free(buf);
entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), EDITOR_NAME_MAX_LENGTH);
if (options->color_profile.input_name[i])
{
- gtk_entry_set_text(GTK_ENTRY(entry), options->color_profile.input_name[i]);
+ gq_gtk_entry_set_text(GTK_ENTRY(entry), options->color_profile.input_name[i]);
}
- gtk_table_attach(GTK_TABLE(table), entry, 1, 2, i + 1, i + 2,
- static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), entry, 1, 2, i + 1, i + 2, static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(entry);
color_profile_input_name_entry[i] = entry;
tabcomp = tab_completion_new(&entry, options->color_profile.input_file[i], nullptr, ".icc", "ICC Files", nullptr);
tab_completion_add_select_button(entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(entry, 160, -1);
- gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3, i + 1, i + 2,
- static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), tabcomp, 2, 3, i + 1, i + 2, static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(tabcomp);
color_profile_input_file_entry[i] = entry;
}
group = pref_group_new(vbox, FALSE, _("Screen profile"), GTK_ORIENTATION_VERTICAL);
-#ifndef HAVE_LCMS
+#if !HAVE_LCMS
gtk_widget_set_sensitive(pref_group_parent(group), FALSE);
#endif
pref_checkbox_new_int(group, _("Use system screen profile if available"),
table = pref_table_new(group, 2, 1, FALSE, FALSE);
- pref_table_label(table, 0, 0, _("Screen:"), 1.0);
+ pref_table_label(table, 0, 0, _("Screen:"), GTK_ALIGN_END);
tabcomp = tab_completion_new(&color_profile_screen_file_entry,
options->color_profile.screen_file, nullptr, ".icc", "ICC Files", nullptr);
tab_completion_add_select_button(color_profile_screen_file_entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(color_profile_screen_file_entry, 160, -1);
-#ifdef HAVE_LCMS
+#if HAVE_LCMS
add_intent_menu(table, 0, 1, _("Render Intent:"), options->color_profile.render_intent, &c_options->color_profile.render_intent);
#endif
- gtk_table_attach(GTK_TABLE(table), tabcomp, 1, 2,
- 0, 1,
- static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(0), 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), tabcomp, 1, 2, 0, 1, static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(tabcomp);
}
/* advanced entry tab */
-static void use_geeqie_trash_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void use_geeqie_trash_cb(GtkWidget *widget, gpointer)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
}
}
-static void use_system_trash_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void use_system_trash_cb(GtkWidget *widget, gpointer)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
}
}
-static void use_no_cache_cb(GtkWidget *widget, gpointer UNUSED(data))
+static void use_no_cache_cb(GtkWidget *widget, gpointer)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
tabcomp = tab_completion_new(&safe_delete_path_entry, options->file_ops.safe_delete_path, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(safe_delete_path_entry, nullptr, TRUE);
- gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
spin = pref_spin_new_int(hbox, _("Maximum size:"), _("MiB"),
0, 2048, 1, options->file_ops.safe_delete_folder_maxsize, &c_options->file_ops.safe_delete_folder_maxsize);
gtk_widget_set_tooltip_markup(spin, _("Set to 0 for unlimited size"));
- button = pref_button_new(nullptr, nullptr, _("View"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("View"),
G_CALLBACK(safe_delete_view_cb), nullptr);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(nullptr, GTK_STOCK_CLEAR, nullptr, FALSE,
+ button = pref_button_new(nullptr, GQ_ICON_CLEAR, nullptr,
G_CALLBACK(safe_delete_clear_cb), nullptr);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
c_options->file_ops.no_trash = options->file_ops.no_trash;
c_options->file_ops.use_system_trash = options->file_ops.use_system_trash;
marks = pref_checkbox_new_int(group, _("Save marks on exit"),
options->marks_save, &c_options->marks_save);
- gtk_widget_set_tooltip_text(marks,"Note that marks linked to a keyword will be saved irrespective of this setting");
+ gtk_widget_set_tooltip_text(marks,_("Note that marks linked to a keyword will be saved irrespective of this setting"));
with_rename = pref_checkbox_new_int(group, _("Use \"With Rename\" as default for Copy/Move dialogs"),
options->with_rename, &c_options->with_rename);
gtk_widget_set_tooltip_text(with_rename,"Change the default button for Copy/Move dialogs");
+ collections_on_top = pref_checkbox_new_int(group, _("Permit duplicates in Collections"),
+ options->collections_duplicates, &c_options->collections_duplicates);
+ gtk_widget_set_tooltip_text(collections_on_top, _("Allow the same image to be in a Collection more than once"));
+
collections_on_top = pref_checkbox_new_int(group, _("Open collections on top"),
options->collections_on_top, &c_options->collections_on_top);
- gtk_widget_set_tooltip_text(collections_on_top,"Open collections window on top");
+ gtk_widget_set_tooltip_text(collections_on_top, _("Open collections window on top"));
hide_window_in_fullscreen = pref_checkbox_new_int(group, _("Hide window in fullscreen"),
options->hide_window_in_fullscreen, &c_options->hide_window_in_fullscreen);
checkbox = pref_checkbox_new_int(group, _("Override disable GPU"),
options->override_disable_gpu, &c_options->override_disable_gpu);
- gtk_widget_set_tooltip_text(checkbox, "Contact the developers for usage");
+ gtk_widget_set_tooltip_text(checkbox, _("Contact the developers for usage"));
#ifdef DEBUG
pref_spacer(group, PREF_PAD_GROUP);
pref_spin_new_int(group, _("Log Window max. lines:"), nullptr,
1, 99999, 1, options->log_window_lines, &options->log_window_lines);
+
+ hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
+ pref_label_new(hbox, _("Log Window F1 command: "));
+ log_window_f1_entry = gtk_entry_new();
+ gq_gtk_entry_set_text(GTK_ENTRY(log_window_f1_entry), options->log_window.action);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), log_window_f1_entry, FALSE, FALSE, 0);
+ gtk_entry_set_width_chars(GTK_ENTRY(log_window_f1_entry), 15);
+ gtk_widget_show(log_window_f1_entry);
#endif
}
/* accelerators tab */
-static gboolean accel_search_function_cb(GtkTreeModel *model, gint column, const gchar *key, GtkTreeIter *iter, gpointer UNUSED(data))
+static gboolean accel_search_function_cb(GtkTreeModel *model, gint column, const gchar *key, GtkTreeIter *iter, gpointer)
{
gboolean ret = TRUE;
gchar *key_nocase;
return ret;
}
-static void accel_row_activated_cb(GtkTreeView *tree_view, GtkTreePath *UNUSED(path), GtkTreeViewColumn *column, gpointer UNUSED(user_data))
+static void accel_row_activated_cb(GtkTreeView *tree_view, GtkTreePath *, GtkTreeViewColumn *column, gpointer)
{
GList *list;
gint col_num = 0;
group = pref_group_new(vbox, TRUE, _("Accelerators"), GTK_ORIENTATION_VERTICAL);
- scrolled = gtk_scrolled_window_new(nullptr, nullptr);
- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
+ scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
+ gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
- gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
- accel_store = gtk_tree_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
+ accel_store = gtk_tree_store_new(5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
accel_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(accel_store));
g_object_unref(accel_store);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(accel_view), column);
+ column = gtk_tree_view_column_new_with_attributes("Icon",
+ renderer,
+ "text", AE_ICON,
+ NULL);
+
+ gtk_tree_view_column_set_sort_column_id(column, AE_ICON);
+ gtk_tree_view_column_set_resizable(column, TRUE);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(accel_view), column);
+
/* Search on text in column */
gtk_tree_view_set_activate_on_single_click(GTK_TREE_VIEW(accel_view), TRUE);
g_signal_connect(accel_view, "row_activated", G_CALLBACK(accel_row_activated_cb), accel_store);
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(accel_view), accel_search_function_cb, nullptr, nullptr);
accel_store_populate();
- gtk_container_add(GTK_CONTAINER(scrolled), accel_view);
+ gq_gtk_container_add(GTK_WIDGET(scrolled), accel_view);
gtk_widget_show(accel_view);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(nullptr, nullptr, _("Defaults"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Defaults"),
G_CALLBACK(accel_default_cb), accel_view);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(nullptr, nullptr, _("Reset selected"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Reset selected"),
G_CALLBACK(accel_reset_cb), accel_view);
gtk_widget_set_tooltip_text(button, _("Will only reset changes made before the settings are saved"));
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(nullptr, nullptr, _("Clear selected"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Clear selected"),
G_CALLBACK(accel_clear_cb), accel_view);
- gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
}
vbox = scrolled_notebook_page(notebook, _("Toolbar Main"));
toolbardata = toolbar_select_new(lw, TOOLBAR_MAIN);
- gtk_box_pack_start(GTK_BOX(vbox), toolbardata, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(vbox), toolbardata, TRUE, TRUE, 0);
gtk_widget_show(vbox);
}
vbox = scrolled_notebook_page(notebook, _("Toolbar Status"));
toolbardata = toolbar_select_new(lw, TOOLBAR_STATUS);
- gtk_box_pack_start(GTK_BOX(vbox), toolbardata, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(vbox), toolbardata, TRUE, TRUE, 0);
gtk_widget_show(vbox);
}
static void config_tab_advanced(GtkWidget *notebook)
{
- GtkWidget *vbox;
- GtkWidget *group;
- GSList *formats_list;
- GList *extensions_list = nullptr;
gchar **extensions;
- GtkWidget *tabcomp;
GdkPixbufFormat *fm;
gint i;
+ GList *extensions_list = nullptr;
+ GSList *formats_list;
GString *types_string = g_string_new(nullptr);
- GtkWidget *types_string_label;
- GtkWidget *threads_string_label;
+ GtkWidget *alternate_checkbox;
GtkWidget *dupes_threads_spin;
+ GtkWidget *group;
+ GtkWidget *subgroup;
+ GtkWidget *tabcomp;
+ GtkWidget *threads_string_label;
+ GtkWidget *types_string_label;
+ GtkWidget *vbox;
vbox = scrolled_notebook_page(notebook, _("Advanced"));
group = pref_group_new(vbox, FALSE, _("External preview extraction"), GTK_ORIENTATION_VERTICAL);
external_preview_select_entry = gtk_entry_new();
tabcomp = tab_completion_new(&external_preview_select_entry, options->external_preview.select, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(external_preview_select_entry, _("Select file identification tool"), FALSE);
- gtk_box_pack_start(GTK_BOX(group), tabcomp, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
group = pref_group_new(vbox, FALSE, _("Preview extraction tool"), GTK_ORIENTATION_VERTICAL);
external_preview_extract_entry = gtk_entry_new();
tabcomp = tab_completion_new(&external_preview_extract_entry, options->external_preview.extract, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(external_preview_extract_entry, _("Select preview extraction tool"), FALSE);
- gtk_box_pack_start(GTK_BOX(group), tabcomp, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(group), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
gtk_widget_show(vbox);
pref_line(vbox, PREF_PAD_SPACE);
group = pref_group_new(vbox, FALSE, _("Thread pool limits"), GTK_ORIENTATION_VERTICAL);
- threads_string_label = pref_label_new(group, "This option limits the number of threads (or cpu cores)\nthat Geeqie will use when running duplicate checks. The default value is 0, which means all available cores will be used.");
+ threads_string_label = pref_label_new(group, _("This option limits the number of threads (or cpu cores) that Geeqie will use when running duplicate checks.\nThe value 0 means all available cores will be used."));
gtk_label_set_line_wrap(GTK_LABEL(threads_string_label), TRUE);
pref_spacer(vbox, PREF_PAD_GROUP);
dupes_threads_spin = pref_spin_new_int(vbox, _("Duplicate check:"), _("max. threads"), 0, get_cpu_cores(), 1, options->threads.duplicates, &c_options->threads.duplicates);
gtk_widget_set_tooltip_markup(dupes_threads_spin, _("Set to 0 for unlimited"));
+
+ pref_spacer(group, PREF_PAD_GROUP);
+
+ pref_line(vbox, PREF_PAD_SPACE);
+
+ group = pref_group_new(vbox, FALSE, _("Alternate similarity alogorithm"), GTK_ORIENTATION_VERTICAL);
+
+ alternate_checkbox = pref_checkbox_new_int(group, _("Enable alternate similarity algorithm"), options->alternate_similarity_algorithm.enabled, &c_options->alternate_similarity_algorithm.enabled);
+
+ subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
+ pref_checkbox_link_sensitivity(alternate_checkbox, subgroup);
+
+ alternate_checkbox = pref_checkbox_new_int(subgroup, _("Use grayscale"), options->alternate_similarity_algorithm.grayscale, &c_options->alternate_similarity_algorithm.grayscale);
+ gtk_widget_set_tooltip_text(alternate_checkbox, _("Reduce fingerprint to grayscale"));
}
/* stereo tab */
if (!c_options) c_options = init_options(nullptr);
- configwindow = window_new(GTK_WINDOW_TOPLEVEL, "preferences", PIXBUF_INLINE_ICON_CONFIG, nullptr, _("Preferences"));
+ configwindow = window_new("preferences", PIXBUF_INLINE_ICON_CONFIG, nullptr, _("Preferences"));
DEBUG_NAME(configwindow);
gtk_window_set_type_hint(GTK_WINDOW(configwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT(configwindow), "delete_event",
if (options->save_dialog_window_positions)
{
gtk_window_resize(GTK_WINDOW(configwindow), lw->options.preferences_window.w, lw->options.preferences_window.h);
- gtk_window_move(GTK_WINDOW(configwindow), lw->options.preferences_window.x, lw->options.preferences_window.y);
+ gq_gtk_window_move(GTK_WINDOW(configwindow), lw->options.preferences_window.x, lw->options.preferences_window.y);
}
else
{
gtk_container_set_border_width(GTK_CONTAINER(configwindow), PREF_PAD_BORDER);
win_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_SPACE);
- gtk_container_add(GTK_CONTAINER(configwindow), win_vbox);
+ gq_gtk_container_add(GTK_WIDGET(configwindow), win_vbox);
gtk_widget_show(win_vbox);
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
- gtk_box_pack_start(GTK_BOX(win_vbox), notebook, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(win_vbox), notebook, TRUE, TRUE, 0);
config_tab_general(notebook);
config_tab_image(notebook);
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), lw->options.preferences_window.page_number);
- hbox = gtk_hbutton_box_new();
+ hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
- gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
+ gq_gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
- button = pref_button_new(nullptr, GTK_STOCK_HELP, nullptr, FALSE,
+ button = pref_button_new(nullptr, GQ_ICON_HELP, _("Help"),
G_CALLBACK(config_window_help_cb), notebook);
- gtk_container_add(GTK_CONTAINER(hbox), button);
+ gq_gtk_container_add(GTK_WIDGET(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- button = pref_button_new(nullptr, GTK_STOCK_OK, nullptr, FALSE,
+ button = pref_button_new(nullptr, GQ_ICON_OK, "OK",
G_CALLBACK(config_window_ok_cb), notebook);
- gtk_container_add(GTK_CONTAINER(hbox), button);
+ gq_gtk_container_add(GTK_WIDGET(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_grab_default(button);
gtk_widget_show(button);
ct_button = button;
- button = pref_button_new(nullptr, GTK_STOCK_CANCEL, nullptr, FALSE,
+ button = pref_button_new(nullptr, GQ_ICON_CANCEL, _("Cancel"),
G_CALLBACK(config_window_close_cb), nullptr);
- gtk_container_add(GTK_CONTAINER(hbox), button);
+ gq_gtk_container_add(GTK_WIDGET(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
gchar *artists[2];
gchar *author_line;
gchar *authors[1000];
- gchar *authors_path;
gchar *comment;
gchar *timezone_path;
gchar *translators;
- gchar *translators_path;
gint i_authors = 0;
gint n = 0;
gsize bytes_read;
gsize size;
guint32 flags;
- copyright = g_string_new(nullptr);
- copyright = g_string_append(copyright, "This program comes with absolutely no warranty.\nGNU General Public License, version 2 or later.\nSee https://www.gnu.org/licenses/old-licenses/gpl-2.0.html\n\n");
+ copyright = g_string_new(_("This program comes with absolutely no warranty.\nGNU General Public License, version 2 or later.\nSee https://www.gnu.org/licenses/old-licenses/gpl-2.0.html\n\n"));
timezone_path = g_build_filename(get_rc_dir(), TIMEZONE_DATABASE_FILE, NULL);
if (g_file_test(timezone_path, G_FILE_TEST_EXISTS))
}
g_free(timezone_path);
- authors_path = g_build_filename(GQ_RESOURCE_PATH_CREDITS, "authors", NULL);
+ copyright = g_string_append(copyright, _("\n\nSome icons by https://www.flaticon.com"));
- in_stream_authors = g_resources_open_stream(authors_path, G_RESOURCE_LOOKUP_FLAGS_NONE, nullptr);
+ in_stream_authors = g_resources_open_stream(GQ_RESOURCE_PATH_CREDITS "/authors", G_RESOURCE_LOOKUP_FLAGS_NONE, nullptr);
data_stream = g_data_input_stream_new(in_stream_authors);
g_input_stream_close(in_stream_authors, nullptr, nullptr);
- translators_path = g_build_filename(GQ_RESOURCE_PATH_CREDITS, "translators", NULL);
+ constexpr auto translators_path = GQ_RESOURCE_PATH_CREDITS "/translators";
g_resources_get_info(translators_path, G_RESOURCE_LOOKUP_FLAGS_NONE, &size, &flags, nullptr);
g_input_stream_read_all(in_stream_translators, translators, size, &bytes_read, nullptr, nullptr);
g_input_stream_close(in_stream_translators, nullptr, nullptr);
- comment = g_strconcat("Project created by John Ellis\nGQview 1998\nGeeqie 2007\n\n\nDevelopment and bug reports:\n", GQ_EMAIL_ADDRESS, "\nhttps://github.com/BestImageViewer/geeqie/issues",NULL);
+ comment = g_strconcat(_("Project created by John Ellis\nGQview 1998\nGeeqie 2007\n\n\nDevelopment and bug reports:\n"), GQ_EMAIL_ADDRESS, _("\nhttps://github.com/BestImageViewer/geeqie/issues"), NULL);
artists[0] = g_strdup("Néstor Díaz Valencia <nestor@estudionexos.com>");
artists[1] = nullptr;
"logo", pixbuf_logo,
"icon", pixbuf_icon,
"website", GQ_WEBSITE,
- "website-label", "Website",
+ "website-label", _("Website"),
"comments", comment,
"artists", artists,
"authors", authors,
}
g_free(artists[0]);
- g_free(authors_path);
g_free(comment);
g_free(translators);
- g_free(translators_path);
g_object_unref(data_stream);
g_object_unref(in_stream_authors);
g_object_unref(in_stream_translators);
}
-static void image_overlay_set_text_colours()
+static void image_overlay_set_text_colors()
{
c_options->image_overlay.text_red = options->image_overlay.text_red;
c_options->image_overlay.text_green = options->image_overlay.text_green;
}
else
{
- warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
+ warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GQ_ICON_DIALOG_WARNING, nullptr);
}
g_free(timezone_bin);
}
else
{
- warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
+ warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GQ_ICON_DIALOG_WARNING, nullptr);
}
g_free(tmp_filename);
file_data_unref(fd);
}
else
{
- file_util_warning_dialog(_("Error: Timezone database download failed"), error->message, GTK_STOCK_DIALOG_ERROR, nullptr);
+ file_util_warning_dialog(_("Error: Timezone database download failed"), error->message, GQ_ICON_DIALOG_ERROR, nullptr);
}
g_file_delete(tz->tmp_g_file, nullptr, &error);
}
}
-static void timezone_cancel_button_cb(GenericDialog *UNUSED(gd), gpointer data)
+static void timezone_cancel_button_cb(GenericDialog *, gpointer data)
{
auto tz = static_cast<TZData *>(data);
if (error)
{
- file_util_warning_dialog(_("Timezone database download failed"), error->message, GTK_STOCK_DIALOG_ERROR, nullptr);
+ file_util_warning_dialog(_("Timezone database download failed"), error->message, GQ_ICON_DIALOG_ERROR, nullptr);
log_printf("Error: Download timezone database failed:\n%s", error->message);
g_error_free(error);
g_object_unref(tz->tmp_g_file);
tz->gd = generic_dialog_new(_("Timezone database"), "download_timezone_database", nullptr, TRUE, timezone_cancel_button_cb, tz);
- generic_dialog_add_message(tz->gd, GTK_STOCK_DIALOG_INFO, _("Downloading timezone database"), nullptr, FALSE);
+ generic_dialog_add_message(tz->gd, GQ_ICON_DIALOG_INFO, _("Downloading timezone database"), nullptr, FALSE);
tz->progress = gtk_progress_bar_new();
- gtk_box_pack_start(GTK_BOX(tz->gd->vbox), tz->progress, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(tz->gd->vbox), tz->progress, FALSE, FALSE, 0);
gtk_widget_show(tz->progress);
gtk_widget_show(tz->gd->dialog);