* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include <stdlib.h>
-#include <string.h>
-
-#include "main.h"
#include "ui-misc.h"
-#include "history-list.h"
-
#include <langinfo.h>
+#include <cstdlib>
+#include <cstring>
+
+#include <pango/pango.h>
+
+#include <config.h>
+
+#include "compat.h"
+#include "debug.h"
+#include "history-list.h"
+#include "layout.h"
+#include "main-defines.h"
+#include "misc.h"
+#include "options.h"
+#include "typedefs.h"
+#include "utilops.h"
+
/*
*-----------------------------------------------------------------------------
* widget and layout utilities
box = gtk_box_new(GTK_ORIENTATION_VERTICAL, padding);
}
- gtk_box_pack_start(GTK_BOX(parent_box), box, fill, fill, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), box, fill, fill, 0);
gtk_widget_show(box);
return box;
g_list_free(list);
}
- gtk_box_pack_start(GTK_BOX(parent_box), vbox, fill, fill, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), vbox, fill, fill, 0);
gtk_widget_show(vbox);
label = gtk_label_new(text);
gtk_label_set_yalign(GTK_LABEL(label), 0.5);
pref_label_bold(label, TRUE, FALSE);
- gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_INDENT);
- gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
/* indent using empty box */
{
box = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
}
- gtk_box_pack_start(GTK_BOX(hbox), box, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), box, TRUE, TRUE, 0);
gtk_widget_show(box);
g_object_set_data(G_OBJECT(box), "pref_group", vbox);
{
GtkWidget *group;
- group = g_object_get_data(G_OBJECT(parent), "pref_group");
+ group = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(parent), "pref_group"));
if (group && GTK_IS_WIDGET(group)) return group;
parent = gtk_widget_get_parent(parent);
GtkOrientation orientation, gboolean padding)
{
GtkWidget *box;
- GtkWidget *frame = NULL;
+ GtkWidget *frame = nullptr;
frame = gtk_frame_new(text);
- gtk_box_pack_start(GTK_BOX(parent_box), frame, fill, fill, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), frame, fill, fill, 0);
gtk_widget_show(frame);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
box = gtk_box_new(GTK_ORIENTATION_VERTICAL, padding);
}
- gtk_container_add(GTK_CONTAINER(frame), box);
+ gq_gtk_container_add(GTK_WIDGET(frame), box);
gtk_container_set_border_width(GTK_CONTAINER(box), PREF_PAD_BORDER);
gtk_widget_show(box);
GtkWidget *spacer;
spacer = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_box_pack_start(GTK_BOX(parent_box), spacer, FALSE, FALSE, padding / 2);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), spacer, FALSE, FALSE, padding / 2);
gtk_widget_show(spacer);
return spacer;
{
GtkWidget *spacer;
- if (GTK_IS_HBOX(parent_box))
- {
- spacer = gtk_vseparator_new();
- }
- else
- {
- spacer = gtk_hseparator_new();
- }
-
- gtk_box_pack_start(GTK_BOX(parent_box), spacer, FALSE, FALSE, padding / 2);
+ spacer = gtk_separator_new(GTK_IS_HBOX(parent_box) ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), spacer, FALSE, FALSE, padding / 2);
gtk_widget_show(spacer);
return spacer;
GtkWidget *label;
label = gtk_label_new(text);
- gtk_box_pack_start(GTK_BOX(parent_box), label, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
return label;
label = gtk_label_new_with_mnemonic(text);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), widget);
- gtk_box_pack_start(GTK_BOX(parent_box), label, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
return label;
pango_attr_list_unref(pal);
}
-GtkWidget *pref_button_new(GtkWidget *parent_box, const gchar *stock_id,
- const gchar *text, gboolean hide_stock_text,
- GCallback func, gpointer data)
+GtkWidget *pref_button_new(GtkWidget *parent_box, const gchar *icon_name,
+ const gchar *text, GCallback func, gpointer data)
{
GtkWidget *button;
- if (stock_id && !text && !hide_stock_text)
+ if (icon_name)
{
- button = gtk_button_new_from_stock(stock_id);
+ button = gtk_button_new_from_icon_name(icon_name, GTK_ICON_SIZE_BUTTON);
}
else
{
- GtkWidget *image = NULL;
- GtkWidget *label = NULL;
-
button = gtk_button_new();
+ }
- if (stock_id) image = gtk_image_new_from_icon_name(stock_id, GTK_ICON_SIZE_BUTTON);
- if (text)
- {
- label = gtk_label_new_with_mnemonic(text);
- gtk_label_set_xalign(GTK_LABEL(label), 0.5);
- gtk_label_set_yalign(GTK_LABEL(label), 0.5);
- gtk_label_set_mnemonic_widget(GTK_LABEL(label), button);
- }
-
- if (image && label)
- {
- GtkWidget *align;
- GtkWidget *hbox;
-
- hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_ICON_GAP);
-
- align = gtk_alignment_new(0.5, 0.5, 0.0, 0.0);
- gtk_container_add(GTK_CONTAINER(button), align);
- gtk_widget_show(align);
-
- gtk_container_add(GTK_CONTAINER(align), hbox);
- gtk_widget_show(hbox);
-
- gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
- gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0);
- }
- else
- {
- if (image)
- {
- gtk_container_add(GTK_CONTAINER(button), image);
- }
- else if (label)
- {
- gtk_container_add(GTK_CONTAINER(button), label);
- }
- }
-
- if (image) gtk_widget_show(image);
- if (label) gtk_widget_show(label);
+ if (text)
+ {
+ gtk_button_set_use_underline(GTK_BUTTON(button), TRUE);
+ gtk_button_set_label(GTK_BUTTON(button), text);
}
if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
if (parent_box)
{
- gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
gtk_widget_show(button);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
- gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
gtk_widget_show(button);
return button;
return real_pref_checkbox_new(parent_box, text, FALSE, active, func, data);
}
-//GtkWidget *pref_checkbox_new_mnemonic(GtkWidget *parent_box, const gchar *text, gboolean active,
- //GCallback func, gpointer data)
-//{
- //return real_pref_checkbox_new(parent_box, text, TRUE, active, func, data);
-//}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+GtkWidget *pref_checkbox_new_mnemonic_unused(GtkWidget *parent_box, const gchar *text, gboolean active,
+ GCallback func, gpointer data)
+{
+ return real_pref_checkbox_new(parent_box, text, TRUE, active, func, data);
+}
+#pragma GCC diagnostic pop
static void pref_checkbox_int_cb(GtkWidget *widget, gpointer data)
{
- gboolean *result = data;
+ auto result = static_cast<gboolean *>(data);
*result = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
}
static void pref_checkbox_link_sensitivity_cb(GtkWidget *button, gpointer data)
{
- GtkWidget *widget = data;
+ auto widget = static_cast<GtkWidget *>(data);
gtk_widget_set_sensitive(widget, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
}
pref_checkbox_link_sensitivity_cb(button, widget);
}
-static void pref_checkbox_link_sensitivity_swap_cb(GtkWidget *button, gpointer data)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+static void pref_checkbox_link_sensitivity_swap_cb_unused(GtkWidget *button, gpointer data)
{
- GtkWidget *widget = data;
+ auto *widget = static_cast<GtkWidget *>(data);
gtk_widget_set_sensitive(widget, !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
}
-//void pref_checkbox_link_sensitivity_swap(GtkWidget *button, GtkWidget *widget)
-//{
- //g_signal_connect(G_OBJECT(button), "toggled",
- //G_CALLBACK(pref_checkbox_link_sensitivity_swap_cb), widget);
+void pref_checkbox_link_sensitivity_swap_unused(GtkWidget *button, GtkWidget *widget)
+{
+ g_signal_connect(G_OBJECT(button), "toggled",
+ G_CALLBACK(pref_checkbox_link_sensitivity_swap_cb_unused), widget);
- //pref_checkbox_link_sensitivity_swap_cb(button, widget);
-//}
+ pref_checkbox_link_sensitivity_swap_cb_unused(button, widget);
+}
+#pragma GCC diagnostic pop
static GtkWidget *real_pref_radiobutton_new(GtkWidget *parent_box, GtkWidget *sibling,
const gchar *text, gboolean mnemonic_text, gboolean active,
GCallback func, gpointer data)
{
GtkWidget *button;
+#if HAVE_GTK4
+ GtkToggleButton *group;;
+#else
GSList *group;
+#endif
if (sibling)
{
+#if HAVE_GTK4
+ group = sibling;
+#else
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(sibling));
+#endif
}
else
{
- group = NULL;
+ group = nullptr;
}
if (mnemonic_text)
{
+#if HAVE_GTK4
+ button = gtk_toggle_button_new_with_mnemonic(text);
+ gtk_toggle_button_set_group(button, group);
+#else
button = gtk_radio_button_new_with_mnemonic(group, text);
+#endif
}
else
{
+#if HAVE_GTK4
+ button = gtk_toggle_button_new_with_label(text);
+ gtk_toggle_button_set_group(button, group);
+#else
button = gtk_radio_button_new_with_label(group, text);
+#endif
}
if (active) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
- gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
gtk_widget_show(button);
return button;
return real_pref_radiobutton_new(parent_box, sibling, text, FALSE, active, func, data);
}
-//GtkWidget *pref_radiobutton_new_mnemonic(GtkWidget *parent_box, GtkWidget *sibling,
- //const gchar *text, gboolean active,
- //GCallback func, gpointer data)
-//{
- //return real_pref_radiobutton_new(parent_box, sibling, text, TRUE, active, func, data);
-//}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+GtkWidget *pref_radiobutton_new_mnemonic_unused(GtkWidget *parent_box, GtkWidget *sibling,
+ const gchar *text, gboolean active,
+ GCallback func, gpointer data)
+{
+ return real_pref_radiobutton_new(parent_box, sibling, text, TRUE, active, func, data);
+}
#define PREF_RADIO_VALUE_KEY "pref_radio_value"
-static void pref_radiobutton_int_cb(GtkWidget *widget, gpointer data)
+static void pref_radiobutton_int_cb_unused(GtkWidget *widget, gpointer data)
{
- gboolean *result = data;
+ auto *result = static_cast<gboolean *>(data);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
}
}
-//GtkWidget *pref_radiobutton_new_int(GtkWidget *parent_box, GtkWidget *sibling,
- //const gchar *text, gboolean active,
- //gboolean *result, gboolean value,
- //GCallback UNUSED(func), gpointer UNUSED(data))
-//{
- //GtkWidget *button;
+GtkWidget *pref_radiobutton_new_int_unused(GtkWidget *parent_box, GtkWidget *sibling,
+ const gchar *text, gboolean active,
+ gboolean *result, gboolean value,
+ GCallback, gpointer)
+{
+ GtkWidget *button;
- //button = pref_radiobutton_new(parent_box, sibling, text, active,
- //G_CALLBACK(pref_radiobutton_int_cb), result);
- //g_object_set_data(G_OBJECT(button), PREF_RADIO_VALUE_KEY, GINT_TO_POINTER(value));
- //if (active) *result = value;
+ button = pref_radiobutton_new(parent_box, sibling, text, active,
+ G_CALLBACK(pref_radiobutton_int_cb_unused), result);
+ g_object_set_data(G_OBJECT(button), PREF_RADIO_VALUE_KEY, GINT_TO_POINTER(value));
+ if (active) *result = value;
- //return button;
-//}
+ return button;
+}
+#pragma GCC diagnostic pop
static GtkWidget *real_pref_spin_new(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
gboolean mnemonic_text,
pref_link_sensitivity(label, spin);
}
- gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
gtk_widget_show(spin);
/* perhaps this should only be PREF_PAD_GAP distance from spinbutton ? */
min, max, step, digits, value, func, data);
}
-//GtkWidget *pref_spin_new_mnemonic(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
- //gdouble min, gdouble max, gdouble step, gint digits,
- //gdouble value,
- //GCallback func, gpointer data)
-//{
- //return real_pref_spin_new(parent_box, text, suffix, TRUE,
- //min, max, step, digits, value, func, data);
-//}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+GtkWidget *pref_spin_new_mnemonic_unused(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
+ gdouble min, gdouble max, gdouble step, gint digits,
+ gdouble value,
+ GCallback func, gpointer data)
+{
+ return real_pref_spin_new(parent_box, text, suffix, TRUE,
+ min, max, step, digits, value, func, data);
+}
+#pragma GCC diagnostic pop
static void pref_spin_int_cb(GtkWidget *widget, gpointer data)
{
- gint *var = data;
+ auto var = static_cast<gint *>(data);
*var = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
}
{
*value_var = value;
return pref_spin_new(parent_box, text, suffix,
- (gdouble)min, (gdouble)max, (gdouble)step, 0,
+ static_cast<gdouble>(min), static_cast<gdouble>(max), static_cast<gdouble>(step), 0,
value,
G_CALLBACK(pref_spin_int_cb), value_var);
}
-static void pref_link_sensitivity_cb(GtkWidget *watch, GtkStateType UNUSED(prev_state), gpointer data)
+static void pref_link_sensitivity_cb(GtkWidget *watch, GtkStateType, gpointer data)
{
- GtkWidget *widget = data;
+ auto widget = static_cast<GtkWidget *>(data);
gtk_widget_set_sensitive(widget, gtk_widget_is_sensitive(watch));
}
void pref_signal_block_data(GtkWidget *widget, gpointer data)
{
g_signal_handlers_block_matched(widget, G_SIGNAL_MATCH_DATA,
- 0, 0, NULL, NULL, data);
+ 0, 0, nullptr, nullptr, data);
}
void pref_signal_unblock_data(GtkWidget *widget, gpointer data)
{
g_signal_handlers_unblock_matched(widget, G_SIGNAL_MATCH_DATA,
- 0, 0, NULL, NULL, data);
+ 0, 0, nullptr, nullptr, data);
}
-GtkWidget *pref_table_new(GtkWidget *parent_box, gint columns, gint rows,
- gboolean homogeneous, gboolean fill)
+GtkWidget *pref_table_new(GtkWidget *parent_box, gint, gint, gboolean, gboolean fill)
{
GtkWidget *table;
- table = gtk_table_new(rows, columns, homogeneous);
- gtk_table_set_row_spacings(GTK_TABLE(table), PREF_PAD_GAP);
- gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_SPACE);
+ table = gtk_grid_new();
+ gtk_grid_set_row_spacing(GTK_GRID(table), PREF_PAD_GAP);
+ gtk_grid_set_column_spacing(GTK_GRID(table), PREF_PAD_SPACE);
if (parent_box)
{
- gtk_box_pack_start(GTK_BOX(parent_box), table, fill, fill, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), table, fill, fill, 0);
gtk_widget_show(table);
}
shell = box;
}
- gtk_table_attach(GTK_TABLE(table), shell, column, column + 1, row, row + 1,
- GTK_EXPAND | GTK_FILL, 0, 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), shell, column, column + 1, row, row + 1, static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(shell);
}
GtkWidget *pref_table_label(GtkWidget *table, gint column, gint row,
- const gchar *text, gfloat alignment)
+ const gchar *text, GtkAlign alignment)
{
GtkWidget *label;
- GtkWidget *align;
- align = gtk_alignment_new(alignment, 0.50, 0.0, 0.0);
- gtk_table_attach(GTK_TABLE(table), align, column, column + 1, row, row + 1,
- GTK_FILL, 0, 0, 0);
- gtk_widget_show(align);
label = gtk_label_new(text);
- gtk_container_add(GTK_CONTAINER(align), label);
+ gtk_widget_set_halign(label, alignment);
+ gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
+ gq_gtk_grid_attach(GTK_GRID(table), label, column, column + 1, row, row + 1, GTK_FILL, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(label);
return label;
}
GtkWidget *pref_table_button(GtkWidget *table, gint column, gint row,
- const gchar *stock_id, const gchar *text, gboolean hide_stock_text,
+ const gchar *stock_id, const gchar *text,
GCallback func, gpointer data)
{
GtkWidget *button;
- button = pref_button_new(NULL, stock_id, text, hide_stock_text, func, data);
- gtk_table_attach(GTK_TABLE(table), button, column, column + 1, row, row + 1,
- GTK_FILL, 0, 0, 0);
+ button = pref_button_new(nullptr, stock_id, text, func, data);
+ gq_gtk_grid_attach(GTK_GRID(table), button, column, column + 1, row, row + 1, GTK_FILL, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(button);
return button;
if (text)
{
- label = pref_table_label(table, column, row, text, 1.0);
+ label = pref_table_label(table, column, row, text, GTK_ALIGN_END);
pref_link_sensitivity(label, spin);
column++;
}
if (suffix)
{
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
- gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
gtk_widget_show(spin);
label = pref_label_new(box, suffix);
box = spin;
}
- gtk_table_attach(GTK_TABLE(table), box, column, column + 1, row, row + 1,
- GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
+ gq_gtk_grid_attach(GTK_GRID(table), box, column, column + 1, row, row + 1, static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), 0, 0);
gtk_widget_show(box);
return spin;
*value_var = value;
return pref_table_spin(table, column, row,
text, suffix,
- (gdouble)min, (gdouble)max, (gdouble)step, 0,
+ static_cast<gdouble>(min), static_cast<gdouble>(max), static_cast<gdouble>(step), 0,
value,
G_CALLBACK(pref_spin_int_cb), value_var);
}
-GtkWidget *pref_toolbar_new(GtkWidget *parent_box, GtkToolbarStyle style)
+GtkWidget *pref_toolbar_new(GtkWidget *parent_box)
{
GtkWidget *tbar;
- tbar = gtk_toolbar_new();
- gtk_toolbar_set_style(GTK_TOOLBAR(tbar), style);
+ tbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
if (parent_box)
{
- gtk_box_pack_start(GTK_BOX(parent_box), tbar, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), tbar, FALSE, FALSE, 0);
gtk_widget_show(tbar);
}
return tbar;
}
GtkWidget *pref_toolbar_button(GtkWidget *toolbar,
- const gchar *stock_id, const gchar *label, gboolean toggle,
+ const gchar *icon_name, const gchar *label, gboolean toggle,
const gchar *description,
GCallback func, gpointer data)
{
GtkWidget *item;
- if (toggle)
+ if (toggle) // TODO: TG seems no function uses toggle now
{
- if (stock_id)
- {
- item = GTK_WIDGET(gtk_toggle_tool_button_new_from_stock(stock_id));
- }
- else
- {
- item = GTK_WIDGET(gtk_toggle_tool_button_new());
- }
+ item = GTK_WIDGET(gtk_toggle_tool_button_new());
+ if (icon_name) gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(item), icon_name);
+ if (label) gtk_tool_button_set_label(GTK_TOOL_BUTTON(item), label);
}
else
{
- if (stock_id)
- {
- item = GTK_WIDGET(gtk_tool_button_new_from_stock(stock_id));
- }
- else
+ GtkWidget *icon = nullptr;
+ if (icon_name)
{
- item = GTK_WIDGET(gtk_tool_button_new(NULL, NULL));
+ icon = gtk_image_new_from_icon_name(icon_name, GTK_ICON_SIZE_LARGE_TOOLBAR); // TODO: TG which size?
+ gtk_widget_show(icon);
}
+ item = GTK_WIDGET(gtk_tool_button_new(icon, label));
}
gtk_tool_button_set_use_underline(GTK_TOOL_BUTTON(item), TRUE);
- if (label) gtk_tool_button_set_label(GTK_TOOL_BUTTON(item), label);
-
if (func) g_signal_connect(item, "clicked", func, data);
- gtk_container_add(GTK_CONTAINER(toolbar), item);
+ gq_gtk_container_add(GTK_WIDGET(toolbar), item);
gtk_widget_show(item);
if (description)
return item;
}
-//void pref_toolbar_button_set_icon(GtkWidget *button, GtkWidget *widget, const gchar *stock_id)
-//{
- //if (widget)
- //{
- //gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button), widget);
- //}
- //else if (stock_id)
- //{
- //gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(button), stock_id);
- //}
-//}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+void pref_toolbar_button_set_icon_unused(GtkWidget *button, GtkWidget *widget, const gchar *stock_id)
+{
+ if (widget)
+ {
+ gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button), widget);
+ }
+ else if (stock_id)
+ {
+ gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(button), stock_id);
+ }
+}
-//GtkWidget *pref_toolbar_spacer(GtkWidget *toolbar)
-//{
- //GtkWidget *item;
+GtkWidget *pref_toolbar_spacer_unused(GtkWidget *toolbar)
+{
+ GtkWidget *item;
- //item = GTK_WIDGET(gtk_separator_tool_item_new());
- //gtk_container_add(GTK_CONTAINER(toolbar), item);
- //gtk_widget_show(item);
+ item = GTK_WIDGET(gtk_separator_tool_item_new());
+ gq_gtk_container_add(GTK_WIDGET(toolbar), item);
+ gtk_widget_show(item);
- //return item;
-//}
+ return item;
+}
+#pragma GCC diagnostic pop
/*
#define DATE_SELECION_KEY "date_selection_data"
-typedef struct _DateSelection DateSelection;
-struct _DateSelection
+struct DateSelection
{
GtkWidget *box;
gtk_widget_hide(ds->window);
- gtk_widget_destroy(ds->window);
- ds->window = NULL;
- ds->calendar = NULL;
+ gq_gtk_widget_destroy(ds->window);
+ ds->window = nullptr;
+ ds->calendar = nullptr;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ds->button), FALSE);
}
-static gboolean date_selection_popup_release_cb(GtkWidget *UNUSED(widget), GdkEventButton *UNUSED(event), gpointer data)
+static gboolean date_selection_popup_release_cb(GtkWidget *, GdkEventButton *, gpointer data)
{
- DateSelection *ds = data;
+ auto ds = static_cast<DateSelection *>(data);
date_selection_popup_hide(ds);
return TRUE;
}
-static gboolean date_selection_popup_press_cb(GtkWidget *UNUSED(widget), GdkEventButton *event, gpointer data)
+static gboolean date_selection_popup_press_cb(GtkWidget *, GdkEventButton *event, gpointer data)
{
- DateSelection *ds = data;
- gint x, y;
- gint w, h;
- gint xr, yr;
+ auto ds = static_cast<DateSelection *>(data);
+ gint x;
+ gint y;
+ gint w;
+ gint h;
+ gint xr;
+ gint yr;
GdkWindow *window;
- xr = (gint)event->x_root;
- yr = (gint)event->y_root;
+ xr = static_cast<gint>(event->x_root);
+ yr = static_cast<gint>(event->y_root);
window = gtk_widget_get_window(ds->window);
gdk_window_get_origin(window, &x, &y);
static void date_selection_popup_sync(DateSelection *ds)
{
- guint day, month, year;
+ guint day;
+ guint month;
+ guint year;
+#if HAVE_GTK4
+ GDateTime *date_selected;
+
+ date_selected = gtk_calendar_get_date(GTK_CALENDAR(ds->calendar));
+ g_date_time_get_ymd(date_selected, static_cast<guint>(&year), static_cast<guint>(&month), static_cast<guint>(&day));
+
+ g_date_time_unref(date_selected);
+#else
gtk_calendar_get_date(GTK_CALENDAR(ds->calendar), &year, &month, &day);
- date_selection_set(ds->box, day, month + 1, year);
+ /* month is range 0 to 11 */
+ month = month + 1;
+#endif
+ date_selection_set(ds->box, day, month, year);
}
-static gboolean date_selection_popup_keypress_cb(GtkWidget *UNUSED(widget), GdkEventKey *event, gpointer data)
+static gboolean date_selection_popup_keypress_cb(GtkWidget *, GdkEventKey *event, gpointer data)
{
- DateSelection *ds = data;
+ auto ds = static_cast<DateSelection *>(data);
switch (event->keyval)
{
return FALSE;
}
-static void date_selection_day_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void date_selection_day_cb(GtkWidget *, gpointer data)
{
- DateSelection *ds = data;
+ auto ds = static_cast<DateSelection *>(data);
date_selection_popup_sync(ds);
}
-static void date_selection_doubleclick_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void date_selection_doubleclick_cb(GtkWidget *, gpointer data)
{
- DateSelection *ds = data;
+ auto ds = static_cast<DateSelection *>(data);
date_selection_popup_hide(ds);
}
static void date_selection_popup(DateSelection *ds)
{
- gint x, y;
- gint wx, wy;
- gint day, month, year;
+ GDateTime *date;
+ gint wx;
+ gint wy;
+ gint x;
+ gint y;
GtkAllocation button_allocation;
GtkAllocation window_allocation;
G_CALLBACK(date_selection_popup_keypress_cb), ds);
ds->calendar = gtk_calendar_new();
- gtk_container_add(GTK_CONTAINER(ds->window), ds->calendar);
+ gq_gtk_container_add(GTK_WIDGET(ds->window), ds->calendar);
gtk_widget_show(ds->calendar);
- date_selection_get(ds->box, &day, &month, &year);
- gtk_calendar_select_month(GTK_CALENDAR(ds->calendar), month - 1, year);
- gtk_calendar_select_day(GTK_CALENDAR(ds->calendar), day);
+ date = date_selection_get(ds->box);
+#if HAVE_GTK4
+ gtk_calendar_select_day(GTK_CALENDAR(ds->calendar), date);
+#else
+ gtk_calendar_select_month(GTK_CALENDAR(ds->calendar), g_date_time_get_month(date), g_date_time_get_year(date));
+ gtk_calendar_select_day(GTK_CALENDAR(ds->calendar), g_date_time_get_day_of_month(date));
+#endif
+ g_date_time_unref(date);
g_signal_connect(G_OBJECT(ds->calendar), "day_selected",
G_CALLBACK(date_selection_day_cb), ds);
if (x < 0) x = 0;
if (y < 0) y = 0;
- gtk_window_move(GTK_WINDOW(ds->window), x, y);
+ gq_gtk_window_move(GTK_WINDOW(ds->window), x, y);
gtk_widget_show(ds->window);
gtk_widget_grab_focus(ds->calendar);
gdk_pointer_grab(gtk_widget_get_window(ds->window), TRUE,
- GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK,
- NULL, NULL, GDK_CURRENT_TIME);
+ static_cast<GdkEventMask>(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK),
+ nullptr, nullptr, GDK_CURRENT_TIME);
gdk_keyboard_grab(gtk_widget_get_window(ds->window), TRUE, GDK_CURRENT_TIME);
gtk_grab_add(ds->window);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ds->button), TRUE);
}
-static void date_selection_button_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void date_selection_button_cb(GtkWidget *, gpointer data)
{
- DateSelection *ds = data;
+ auto ds = static_cast<DateSelection *>(data);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ds->button)) == (!ds->window))
{
static void button_size_allocate_cb(GtkWidget *button, GtkAllocation *allocation, gpointer data)
{
- GtkWidget *spin = data;
+ auto spin = static_cast<GtkWidget *>(data);
GtkRequisition spin_requisition;
gtk_widget_get_requisition(spin, &spin_requisition);
gtk_widget_set_size_request(spin, req.width + value, -1);
}
-static void date_selection_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
+static void date_selection_destroy_cb(GtkWidget *, gpointer data)
{
- DateSelection *ds = data;
+ auto ds = static_cast<DateSelection *>(data);
date_selection_popup_hide(ds);
g_free(ds);
}
-GtkWidget *date_selection_new(void)
+GtkWidget *date_selection_new()
{
DateSelection *ds;
- GtkWidget *arrow;
+ GtkWidget *icon;
ds = g_new0(DateSelection, 1);
gchar *date_format;
switch (date_format[i])
{
case 'd':
- ds->spin_d = pref_spin_new(ds->box, NULL, NULL, 1, 31, 1, 0, 1, NULL, NULL);
+ ds->spin_d = pref_spin_new(ds->box, nullptr, nullptr, 1, 31, 1, 0, 1, nullptr, nullptr);
break;
case 'm':
- ds->spin_m = pref_spin_new(ds->box, NULL, NULL, 1, 12, 1, 0, 1, NULL, NULL);
+ ds->spin_m = pref_spin_new(ds->box, nullptr, nullptr, 1, 12, 1, 0, 1, nullptr, nullptr);
break;
case 'y': case 'Y':
- ds->spin_y = pref_spin_new(ds->box, NULL, NULL, 1900, 9999, 1, 0, 1900, NULL, NULL);
+ ds->spin_y = pref_spin_new(ds->box, nullptr, nullptr, 1900, 9999, 1, 0, 1900, nullptr, nullptr);
break;
default:
log_printf("Warning: Date locale %s is unknown", date_format);
}
else
{
- ds->spin_m = pref_spin_new(ds->box, NULL, NULL, 1, 12, 1, 0, 1, NULL, NULL);
- ds->spin_d = pref_spin_new(ds->box, NULL, NULL, 1, 31, 1, 0, 1, NULL, NULL);
- ds->spin_y = pref_spin_new(ds->box, NULL, NULL, 1900, 9999, 1, 0, 1900, NULL, NULL);
+ ds->spin_m = pref_spin_new(ds->box, nullptr, nullptr, 1, 12, 1, 0, 1, nullptr, nullptr);
+ ds->spin_d = pref_spin_new(ds->box, nullptr, nullptr, 1, 31, 1, 0, 1, nullptr, nullptr);
+ ds->spin_y = pref_spin_new(ds->box, nullptr, nullptr, 1900, 9999, 1, 0, 1900, nullptr, nullptr);
}
spin_increase(ds->spin_y, 5);
g_signal_connect(G_OBJECT(ds->button), "size_allocate",
G_CALLBACK(button_size_allocate_cb), ds->spin_y);
- arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
- gtk_container_add(GTK_CONTAINER(ds->button), arrow);
- gtk_widget_show(arrow);
+ icon = gtk_image_new_from_icon_name(GQ_ICON_PAN_DOWN, GTK_ICON_SIZE_BUTTON);
+ gq_gtk_container_add(GTK_WIDGET(ds->button), icon);
+ gtk_widget_show(icon);
- gtk_box_pack_start(GTK_BOX(ds->box), ds->button, FALSE, FALSE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(ds->box), ds->button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(ds->button), "clicked",
G_CALLBACK(date_selection_button_cb), ds);
gtk_widget_show(ds->button);
{
DateSelection *ds;
- ds = g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY);
+ ds = static_cast<DateSelection *>(g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY));
if (!ds) return;
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_d), (gdouble)day);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_m), (gdouble)month);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_y), (gdouble)year);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_d), static_cast<gdouble>(day));
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_m), static_cast<gdouble>(month));
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_y), static_cast<gdouble>(year));
}
-
-void date_selection_get(GtkWidget *widget, gint *day, gint *month, gint *year)
+/**
+ * @brief Returns date structure set to value of spin buttons
+ * @param widget #DateSelection
+ * @returns
+ *
+ * Free returned structure with g_date_time_unref();
+ */
+GDateTime *date_selection_get(GtkWidget *widget)
{
DateSelection *ds;
+ gint day;
+ gint month;
+ gint year;
+ GDateTime *date;
- ds = g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY);
- if (!ds) return;
+ ds = static_cast<DateSelection *>(g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY));
+ if (!ds)
+ {
+ return nullptr;
+ }
+
+ day = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_d));
+ month = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_m));
+ year = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_y));
+
+ date = g_date_time_new_local(year, month, day, 0, 0, 0);
- if (day) *day = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_d));
- if (month) *month = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_m));
- if (year) *year = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_y));
+ return date;
}
void date_selection_time_set(GtkWidget *widget, time_t t)
date_selection_set(widget, lt->tm_mday, lt->tm_mon + 1, lt->tm_year + 1900);
}
-//time_t date_selection_time_get(GtkWidget *widget)
-//{
- //struct tm lt;
- //gint day = 0;
- //gint month = 0;
- //gint year = 0;
-
- //date_selection_get(widget, &day, &month ,&year);
-
- //lt.tm_sec = 0;
- //lt.tm_min = 0;
- //lt.tm_hour = 0;
- //lt.tm_mday = day;
- //lt.tm_mon = month - 1;
- //lt.tm_year = year - 1900;
- //lt.tm_isdst = 0;
-
- //return mktime(<);
-//}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+time_t date_selection_time_get_unused(GtkWidget *widget)
+{
+ struct tm lt;
+ gint day = 0;
+ gint month = 0;
+ gint year = 0;
+
+ date_selection_get(widget);
+
+ lt.tm_sec = 0;
+ lt.tm_min = 0;
+ lt.tm_hour = 0;
+ lt.tm_mday = day;
+ lt.tm_mon = month - 1;
+ lt.tm_year = year - 1900;
+ lt.tm_isdst = 0;
+
+ return mktime(<);
+}
+#pragma GCC diagnostic pop
/*
*-----------------------------------------------------------------------------
work = history_list_get_by_key(group);
while (work)
{
- const gchar *text = work->data;
+ auto text = static_cast<const gchar *>(work->data);
if (strncmp(text, token, l) == 0) return work;
work = work->next;
}
- return NULL;
+ return nullptr;
}
static gboolean pref_list_get(const gchar *group, const gchar *key, const gchar *marker, const gchar **result)
if (!group || !key || !marker)
{
- *result = NULL;
+ *result = nullptr;
return FALSE;
}
work = pref_list_find(group, token);
if (work)
{
- *result = (const gchar *)work->data + strlen(token);
- if (strlen(*result) == 0) *result = NULL;
+ *result = static_cast<const gchar *>(work->data) + strlen(token);
+ if (strlen(*result) == 0) *result = nullptr;
ret = TRUE;
}
else
{
- *result = NULL;
+ *result = nullptr;
ret = FALSE;
}
work = pref_list_find(group, token);
if (work)
{
- gchar *old_path = work->data;
+ auto old_path = static_cast<gchar *>(work->data);
if (text)
{
work->data = path;
- path = NULL;
+ path = nullptr;
g_free(old_path);
}
if (pref_list_get(group, key, PREF_LIST_MARKER_INT, &text) && text)
{
- *result = (gint)strtol(text, NULL, 10);
+ *result = static_cast<gint>(strtol(text, nullptr, 10));
return TRUE;
}
return FALSE;
}
-//void pref_list_double_set(const gchar *group, const gchar *key, gdouble value)
-//{
- //gchar text[G_ASCII_DTOSTR_BUF_SIZE];
-
- //g_ascii_dtostr(text, sizeof(text), value);
- //pref_list_set(group, key, PREF_LIST_MARKER_DOUBLE, text);
-//}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+void pref_list_double_set_unused(const gchar *group, const gchar *key, gdouble value)
+{
+ gchar text[G_ASCII_DTOSTR_BUF_SIZE];
-//gboolean pref_list_double_get(const gchar *group, const gchar *key, gdouble *result)
-//{
- //const gchar *text;
+ g_ascii_dtostr(text, sizeof(text), value);
+ pref_list_set(group, key, PREF_LIST_MARKER_DOUBLE, text);
+}
- //if (!group || !key)
- //{
- //*result = 0;
- //return FALSE;
- //}
+gboolean pref_list_double_get_unused(const gchar *group, const gchar *key, gdouble *result)
+{
+ const gchar *text;
- //if (pref_list_get(group, key, PREF_LIST_MARKER_DOUBLE, &text) && text)
- //{
- //*result = g_ascii_strtod(text, NULL);
- //return TRUE;
- //}
+ if (!group || !key)
+ {
+ *result = 0;
+ return FALSE;
+ }
- //*result = 0;
- //return FALSE;
-//}
+ if (pref_list_get(group, key, PREF_LIST_MARKER_DOUBLE, &text) && text)
+ {
+ *result = g_ascii_strtod(text, nullptr);
+ return TRUE;
+ }
-//void pref_list_string_set(const gchar *group, const gchar *key, const gchar *value)
-//{
- //pref_list_set(group, key, PREF_LIST_MARKER_STRING, value);
-//}
+ *result = 0;
+ return FALSE;
+}
-//gboolean pref_list_string_get(const gchar *group, const gchar *key, const gchar **result)
-//{
- //return pref_list_get(group, key, PREF_LIST_MARKER_STRING, result);
-//}
+void pref_list_string_set_unused(const gchar *group, const gchar *key, const gchar *value)
+{
+ pref_list_set(group, key, PREF_LIST_MARKER_STRING, value);
+}
+gboolean pref_list_string_get_unused(const gchar *group, const gchar *key, const gchar **result)
+{
+ return pref_list_get(group, key, PREF_LIST_MARKER_STRING, result);
+}
+#pragma GCC diagnostic pop
void pref_color_button_set_cb(GtkWidget *widget, gpointer data)
{
- GdkColor *color = data;
+ auto color = static_cast<GdkRGBA *>(data);
- gtk_color_button_get_color(GTK_COLOR_BUTTON(widget), color);
+ gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), color);
}
-GtkWidget *pref_color_button_new(GtkWidget *parent_box,
- const gchar *title, const GdkColor *color,
- GCallback func, gpointer data)
+GtkWidget *pref_color_button_new(GtkWidget *parent_box, const gchar *title, GdkRGBA *color, GCallback func, gpointer data)
{
GtkWidget *button;
if (color)
{
- button = gtk_color_button_new_with_color(color);
+ button = gtk_color_button_new_with_rgba(color);
}
else
{
label = gtk_label_new(title);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_box_pack_start(GTK_BOX(parent_box), hbox, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(parent_box), hbox, TRUE, TRUE, 0);
- gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
- gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
+ gq_gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
- gtk_widget_show_all(hbox);
+ gq_gtk_widget_show_all(hbox);
}
else
{
if (GTK_IS_TEXT_VIEW(text_widget))
{
GtkTextBuffer *buffer;
- GtkTextIter start, end;
+ GtkTextIter start;
+ GtkTextIter end;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_widget));
gtk_text_buffer_get_bounds(buffer, &start, &end);
return gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
}
- else if (GTK_IS_ENTRY(text_widget))
- {
- return g_strdup(gtk_entry_get_text(GTK_ENTRY(text_widget)));
- }
- else
+
+ if (GTK_IS_ENTRY(text_widget))
{
- return NULL;
+ return g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(text_widget)));
}
+ return nullptr;
+
+
}
gchar *text_widget_text_pull_selected(GtkWidget *text_widget)
if (GTK_IS_TEXT_VIEW(text_widget))
{
GtkTextBuffer *buffer;
- GtkTextIter start, end;
+ GtkTextIter start;
+ GtkTextIter end;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_widget));
gtk_text_buffer_get_bounds(buffer, &start, &end);
return gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
}
- else if (GTK_IS_ENTRY(text_widget))
+
+ if (GTK_IS_ENTRY(text_widget))
{
- return g_strdup(gtk_entry_get_text(GTK_ENTRY(text_widget)));
+ return g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(text_widget)));
}
- else
+
+ return nullptr;
+
+}
+
+static gint simple_sort_cb(gconstpointer a, gconstpointer b)
+{
+ const ActionItem *a_action;
+ const ActionItem *b_action;
+
+ a_action = static_cast<const ActionItem *>(a);
+ b_action = static_cast<const ActionItem *>(b);
+
+ return g_strcmp0(a_action->name, b_action->name);
+}
+
+void free_action_items_cb(gpointer data)
+{
+ ActionItem *action_item;
+
+ action_item = static_cast<ActionItem *>(data);
+ g_free((gchar *)action_item->icon_name);
+ g_free((gchar *)action_item->name);
+ g_free((gchar *)action_item->label);
+ g_free(action_item);
+}
+
+void action_items_free(GList *list)
+{
+ g_list_free_full(list, free_action_items_cb);
+}
+
+/**
+ * @brief Get a list of menu actions
+ * @param
+ * @returns GList ActionItem
+ *
+ * Free returned list with action_items_free(list)
+ *
+ * The list generated is used in the --remote --action-list command and
+ * programmable mouse buttons 8 and 9.
+ */
+GList* get_action_items()
+{
+ ActionItem *action_item;
+ const gchar *accel_path;
+ gboolean duplicate;
+ gchar *action_name;
+ gchar *label;
+ gchar *tooltip;
+ GList *actions;
+ GList *groups;
+ GList *list_duplicates = nullptr;
+ GList *list_unique = nullptr;
+ GList *work1;
+ GList *work2;
+ GtkAction *action;
+ LayoutWindow *lw = nullptr;
+
+ if (!layout_valid(&lw))
+ {
+ return nullptr;
+ }
+
+ groups = gtk_ui_manager_get_action_groups(lw->ui_manager);
+ while (groups)
+ {
+ actions = gtk_action_group_list_actions(GTK_ACTION_GROUP(groups->data));
+ while (actions)
+ {
+ action = GTK_ACTION(actions->data);
+ accel_path = gtk_action_get_accel_path(action);
+
+ if (accel_path && gtk_accel_map_lookup_entry(accel_path, nullptr))
+ {
+ g_object_get(action, "tooltip", &tooltip, "label", &label, NULL);
+
+ action_name = g_path_get_basename(accel_path);
+
+ /* Menu actions are irrelevant */
+ if (g_strstr_len(action_name, -1, "Menu") == nullptr)
+ {
+ action_item = g_new0(ActionItem, 1);
+
+ /* .desktop items need the program name, Geeqie menu items need the tooltip */
+ if (g_strstr_len(action_name, -1, ".desktop") == nullptr)
+ {
+
+ /* Tooltips with newlines affect output format */
+ if (tooltip && (g_strstr_len(tooltip, -1, "\n") == nullptr) )
+ {
+ action_item->label = g_strdup(tooltip);
+ }
+ else
+ {
+ action_item->label = g_strdup(label);
+ }
+ }
+ else
+ {
+ action_item->label = g_strdup(label);
+ }
+
+ action_item->name = action_name;
+ action_item->icon_name = g_strdup(gtk_action_get_stock_id(action));
+
+ list_duplicates = g_list_prepend(list_duplicates, action_item);
+ }
+ }
+ actions = actions->next;
+ }
+
+ groups = groups->next;
+ }
+
+ /* Use the shortest name i.e. ignore -Alt versions. Sort makes the shortest first in the list */
+ list_duplicates = g_list_sort(list_duplicates, simple_sort_cb);
+
+ /* Ignore duplicate entries */
+ work1 = list_duplicates;
+ while (work1)
{
- return NULL;
+ duplicate = FALSE;
+ work2 = list_unique;
+ /* The first entry must be unique, list_unique is null so control bypasses the while */
+ while (work2)
+ {
+ if (g_strcmp0(static_cast<ActionItem *>(work2->data)->label, static_cast<ActionItem *>(work1->data)->label) == 0)
+ {
+ duplicate = TRUE;
+ break;
+ }
+ work2 = work2->next;
+ }
+
+ if (!duplicate)
+ {
+ action_item = g_new0(ActionItem, 1);
+ action_item->name = g_strdup(static_cast<ActionItem *>(work1->data)->name);
+ action_item->label = g_strdup(static_cast<ActionItem *>(work1->data)->label);
+ action_item->icon_name = g_strdup(static_cast<ActionItem *>(work1->data)->icon_name);
+ list_unique = g_list_append(list_unique, action_item);
+ }
+ work1 = work1->next;
}
+
+ g_list_free_full(list_duplicates, free_action_items_cb);
+
+ return list_unique;
}
-gboolean defined_mouse_buttons(GtkWidget *UNUSED(widget), GdkEventButton *event, gpointer data)
+gboolean defined_mouse_buttons(GtkWidget *, GdkEventButton *event, gpointer data)
{
- LayoutWindow *lw = data;
+ auto lw = static_cast<LayoutWindow *>(data);
GtkAction *action;
gboolean ret = FALSE;
case MOUSE_BUTTON_8:
if (options->mouse_button_8)
{
- action = gtk_action_group_get_action(lw->action_group, options->mouse_button_8);
- if (action)
+ if (g_strstr_len(options->mouse_button_8, -1, ".desktop") != nullptr)
{
- gtk_action_activate(action);
+ file_util_start_editor_from_filelist(options->mouse_button_8, layout_selection_list(lw), layout_get_path(lw), lw->window);
+ ret = TRUE;
+ }
+ else
+ {
+ action = gtk_action_group_get_action(lw->action_group, options->mouse_button_8);
+ if (action)
+ {
+ gtk_action_activate(action);
+ }
+ ret = TRUE;
}
- ret = TRUE;
}
- break;
+ break;
case MOUSE_BUTTON_9:
if (options->mouse_button_9)
{
- action = gtk_action_group_get_action(lw->action_group, options->mouse_button_9);
- if (action)
+ if (g_strstr_len(options->mouse_button_9, -1, ".desktop") != nullptr)
+ {
+ file_util_start_editor_from_filelist(options->mouse_button_9, layout_selection_list(lw), layout_get_path(lw), lw->window);
+ }
+ else
{
- gtk_action_activate(action);
+ action = gtk_action_group_get_action(lw->action_group, options->mouse_button_9);
+ ret = TRUE;
+ if (action)
+ {
+ gtk_action_activate(action);
+ }
+ ret = TRUE;
}
- ret = TRUE;
}
break;
default:
return ret;
}
+GdkPixbuf *gq_gtk_icon_theme_load_icon_copy(GtkIconTheme *icon_theme, const gchar *icon_name, gint size, GtkIconLookupFlags flags)
+{
+ GError *error = nullptr;
+ GdkPixbuf *icon = gtk_icon_theme_load_icon(icon_theme, icon_name, size, flags, &error);
+ if (error) return nullptr;
+
+ GdkPixbuf *pixbuf = gdk_pixbuf_copy(icon);
+ g_object_unref(icon);
+ return pixbuf;
+}
+
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
projects / geeqie.git / blobdiff