static void
gtk_switch_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkSwitch *sw = GTK_SWITCH (gobject);
switch (prop_id)
{
case PROP_ACTIVE:
gtk_switch_set_active (sw, g_value_get_boolean (value));
break;
case PROP_STATE:
gtk_switch_set_state (sw, g_value_get_boolean (value));
break;
case PROP_ACTION_NAME:
gtk_switch_set_action_name (GTK_ACTIONABLE (sw), g_value_get_string (value));
break;
case PROP_ACTION_TARGET:
gtk_switch_set_action_target_value (GTK_ACTIONABLE (sw), g_value_get_variant (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
}
static void
photos_zoom_controls_update_buttons (PhotosZoomControls *self)
{
GtkWidget *image;
gboolean zoom_best_fit_enabled;
gboolean zoom_out_enabled;
const gchar *icon_name;
zoom_best_fit_enabled = g_action_get_enabled (self->zoom_best_fit_action);
zoom_out_enabled = g_action_get_enabled (self->zoom_out_action);
g_return_if_fail (zoom_best_fit_enabled == zoom_out_enabled);
gtk_revealer_set_reveal_child (GTK_REVEALER (self->revealer), zoom_out_enabled);
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->zoom_toggle_button), NULL);
gtk_actionable_set_action_target_value (GTK_ACTIONABLE (self->zoom_toggle_button), NULL);
if (zoom_out_enabled)
{
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->zoom_toggle_button), "app.zoom-best-fit");
}
else
{
GVariant *target_value = NULL;
target_value = photos_utils_create_zoom_target_value (1.0, PHOTOS_ZOOM_EVENT_MOUSE_CLICK);
gtk_actionable_set_action_target_value (GTK_ACTIONABLE (self->zoom_toggle_button), target_value);
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->zoom_toggle_button), "app.zoom-in");
}
icon_name = zoom_out_enabled ? "zoom-fit-best-symbolic" : "zoom-in-symbolic";
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_INVALID);
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
gtk_button_set_image (GTK_BUTTON (self->zoom_toggle_button), image);
}
static GtkWidget *
create_toolbar (void)
{
GtkWidget *toolbar;
GtkToolItem *item;
toolbar = gtk_toolbar_new ();
item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-new", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
gtk_tool_item_set_tooltip_markup (item, "Open another one of these windows");
gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.new");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
gtk_tool_item_set_tooltip_markup (item, "This is a demo button that locks up the demo");
gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.lock");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
gtk_tool_item_set_tooltip_markup (item, "This is a demo button that toggles window decorations");
gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.decorations");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
gtk_tool_item_set_tooltip_markup (item, "This is a demo button that locks the aspect ratio using a hint");
gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.ratio");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_icon_name ("gtk-quit", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL);
gtk_tool_item_set_tooltip_markup (item, "This is a demo button with a 'quit' icon");
gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.quit");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
return toolbar;
}
static void
photos_tool_filter_button_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
PhotosToolFilterButton *self = PHOTOS_TOOL_FILTER_BUTTON (object);
switch (prop_id)
{
case PROP_ACTION_NAME:
{
const gchar *action_name;
action_name = photos_tool_filter_button_get_action_name (GTK_ACTIONABLE (self));
g_value_set_string (value, action_name);
break;
}
case PROP_ACTION_TARGET:
{
GVariant *action_target;
action_target = photos_tool_filter_button_get_action_target_value (GTK_ACTIONABLE (self));
g_value_set_variant (value, action_target);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkButton *button = GTK_BUTTON (object);
switch (prop_id)
{
case PROP_LABEL:
gtk_button_set_label (button, g_value_get_string (value));
break;
case PROP_RELIEF:
gtk_button_set_relief (button, g_value_get_enum (value));
break;
case PROP_USE_UNDERLINE:
gtk_button_set_use_underline (button, g_value_get_boolean (value));
break;
case PROP_ICON_NAME:
gtk_button_set_icon_name (button, g_value_get_string (value));
break;
case PROP_ACTION_NAME:
gtk_button_set_action_name (GTK_ACTIONABLE (button), g_value_get_string (value));
break;
case PROP_ACTION_TARGET:
gtk_button_set_action_target_value (GTK_ACTIONABLE (button), g_value_get_variant (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gb_preferences_switch_update_settings (GbPreferencesSwitch *self)
{
g_assert (GB_IS_PREFERENCES_SWITCH (self));
if ((self->settings != NULL) && (self->settings_schema_key != NULL))
{
GSimpleActionGroup *group;
GAction *action;
gchar *name;
action = g_settings_create_action (self->settings, self->settings_schema_key);
group = g_simple_action_group_new ();
g_action_map_add_action (G_ACTION_MAP (group), G_ACTION (action));
gtk_widget_insert_action_group (GTK_WIDGET (self), "settings", G_ACTION_GROUP (group));
g_object_unref (action);
name = g_strdup_printf ("settings.%s", self->settings_schema_key);
if (self->is_radio)
{
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->settings_radio), name);
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->settings_switch), NULL);
}
else
{
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->settings_radio), NULL);
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->settings_switch), name);
}
g_free (name);
}
}
static void
schema_browser_perspective_customize (BrowserPerspective *perspective, GtkToolbar *toolbar, GtkHeaderBar *header)
{
g_print ("%s ()\n", __FUNCTION__);
customization_data_init (G_OBJECT (perspective), toolbar, header);
/* add perspective's actions */
customization_data_add_actions (G_OBJECT (perspective), win_entries, G_N_ELEMENTS (win_entries));
/* add to toolbar */
GtkToolItem *titem;
titem = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "user-bookmarks-symbolic");
gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Show favorites"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.show-favorites");
gtk_widget_show (GTK_WIDGET (titem));
customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem));
#ifdef HAVE_GOOCANVAS
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "tab-new-symbolic");
gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Create a new diagram"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.action-diagram-new");
gtk_widget_show (GTK_WIDGET (titem));
customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem));
#endif
}
void TableofcontentsNoteAddin::get_toc_popover_items(std::vector<Gtk::Widget*> & items) const
{
std::vector<TocItem> toc_items;
get_toc_items(toc_items);
if(toc_items.size()) {
auto item = dynamic_cast<Gtk::ModelButton*>(gnote::utils::create_popover_button("win.tableofcontents-goto-heading", ""));
Gtk::Label *label = (Gtk::Label*)item->get_child();
label->set_markup("<b>" + get_note()->get_title() + "</b>");
gtk_actionable_set_action_target_value(GTK_ACTIONABLE(item->gobj()), g_variant_new_int32(0));
item->property_role() = Gtk::BUTTON_ROLE_NORMAL;
item->property_inverted() = true;
item->property_centered() = false;
items.push_back(item);
}
for(auto & toc_item : toc_items) {
if(toc_item.heading_level == Heading::Level_2) {
toc_item.heading = "→ " + toc_item.heading;
}
auto item = dynamic_cast<Gtk::ModelButton*>(gnote::utils::create_popover_button("win.tableofcontents-goto-heading", toc_item.heading));
if(toc_item.heading_level == Heading::Level_1) {
item->set_image(*manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_MENU)));
}
gtk_actionable_set_action_target_value(GTK_ACTIONABLE(item->gobj()), g_variant_new_int32(toc_item.heading_position));
item->property_role() = Gtk::BUTTON_ROLE_NORMAL;
item->property_inverted() = true;
item->property_centered() = false;
items.push_back(item);
}
}
static void
gb_preferences_switch_set_settings_schema_value (GbPreferencesSwitch *self,
GVariant *variant)
{
g_return_if_fail (GB_IS_PREFERENCES_SWITCH (self));
gtk_actionable_set_action_target_value (GTK_ACTIONABLE (self->settings_switch), variant);
gtk_actionable_set_action_target_value (GTK_ACTIONABLE (self->settings_radio), variant);
}
static GVariant *
gtk_tool_button_get_action_target_value (GtkActionable *actionable)
{
GtkToolButton *button = GTK_TOOL_BUTTON (actionable);
return gtk_actionable_get_action_target_value (GTK_ACTIONABLE (button->priv->button));
}
static const gchar *
gtk_tool_button_get_action_name (GtkActionable *actionable)
{
GtkToolButton *button = GTK_TOOL_BUTTON (actionable);
return gtk_actionable_get_action_name (GTK_ACTIONABLE (button->priv->button));
}
static GtkWidget *
action_editor (GObject *object,
GtkInspectorPropEditor *editor)
{
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *box;
GtkWidget *button;
GObject *owner;
gchar *text;
owner = find_action_owner (GTK_ACTIONABLE (object));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
if (owner)
{
label = gtk_label_new (_("Action"));
gtk_widget_set_margin_top (label, 10);
gtk_container_add (GTK_CONTAINER (vbox), label);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
text = g_strdup_printf (_("Defined at: %p (%s)"),
owner, g_type_name_from_instance ((GTypeInstance *)owner));
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (text));
g_free (text);
button = gtk_button_new_with_label (_("Properties"));
g_object_set_data (G_OBJECT (button), "owner", owner);
g_signal_connect (button, "clicked",
G_CALLBACK (show_action_owner), editor);
gtk_container_add (GTK_CONTAINER (box), button);
gtk_container_add (GTK_CONTAINER (vbox), box);
gtk_widget_show_all (vbox);
}
return vbox;
}
static void
tm_populate(GtkWidget * toolbar, BalsaToolbarModel * model)
{
gboolean style_is_both;
gboolean make_two_line;
GArray *current;
guint j;
GActionMap *action_map =
g_object_get_data(G_OBJECT(toolbar), BALSA_TOOLBAR_ACTION_MAP);
style_is_both = (model->style == GTK_TOOLBAR_BOTH
|| (model->style == (GtkToolbarStyle) - 1
&& tm_default_style() == GTK_TOOLBAR_BOTH));
make_two_line = style_is_both && tm_has_second_line(model);
current = balsa_toolbar_model_get_current(model);
for (j = 0; j < current->len; j++) {
BalsaToolbarEntry *entry;
GtkToolItem *item;
entry = &g_array_index(current, BalsaToolbarEntry, j);
if (!*entry->action) {
item = gtk_separator_tool_item_new();
} else {
GtkWidget *icon;
GAction *action;
const GVariantType *type;
gchar *prefixed_action;
icon = gtk_image_new_from_icon_name
(balsa_icon_id(entry->icon), GTK_ICON_SIZE_SMALL_TOOLBAR);
action = g_action_map_lookup_action(action_map, entry->action);
if (action &&
(type = g_action_get_state_type(action)) &&
g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) {
item = gtk_toggle_tool_button_new();
g_object_set(G_OBJECT(item), "icon-widget", icon,
"label", entry->action, NULL);
} else {
item = gtk_tool_button_new(icon, entry->action);
}
tm_set_tool_item_label(GTK_TOOL_ITEM(item), entry->icon,
make_two_line);
prefixed_action =
g_strconcat(action ? "win." : "app.", entry->action, NULL);
gtk_actionable_set_action_name(GTK_ACTIONABLE(item),
prefixed_action);
g_free(prefixed_action);
}
gtk_toolbar_insert((GtkToolbar *) toolbar, item, -1);
}
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),
model->style != (GtkToolbarStyle) (-1) ?
model->style : tm_default_style());
gtk_widget_show_all(toolbar);
}
static void
pnl_tab_strip_child_position_changed (PnlTabStrip *self,
GParamSpec *pspec,
GtkWidget *child)
{
GVariant *state;
GtkWidget *parent;
PnlTab *tab;
guint position;
g_assert (PNL_IS_TAB_STRIP (self));
g_assert (GTK_IS_WIDGET (child));
tab = g_object_get_data (G_OBJECT (child), "PNL_TAB");
if (!tab || !PNL_IS_TAB (tab))
return;
parent = gtk_widget_get_parent (child);
gtk_container_child_get (GTK_CONTAINER (parent), child,
"position", &position,
NULL);
gtk_container_child_set (GTK_CONTAINER (self), GTK_WIDGET (tab),
"position", position,
NULL);
state = g_variant_new_int32 (position);
gtk_actionable_set_action_target_value (GTK_ACTIONABLE (tab), state);
}
static void
gtk_tool_button_set_action_name (GtkActionable *actionable,
const gchar *action_name)
{
GtkToolButton *button = GTK_TOOL_BUTTON (actionable);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button->priv->button), action_name);
}
static void
gtk_tool_button_set_action_target_value (GtkActionable *actionable,
GVariant *action_target)
{
GtkToolButton *button = GTK_TOOL_BUTTON (actionable);
gtk_actionable_set_action_target_value (GTK_ACTIONABLE (button->priv->button), action_target);
}
static void
ekiga_window_init_actions_toolbar (EkigaWindow *mw)
{
GtkWidget *image = NULL;
GtkWidget *button = NULL;
GtkWidget *switcher = NULL;
g_return_if_fail (EKIGA_IS_WINDOW (mw));
mw->priv->actions_toolbar = gtk_header_bar_new ();
gtk_window_set_titlebar (GTK_WINDOW (mw), mw->priv->actions_toolbar);
/* Start packing buttons */
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("call-start-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (button), image);
gtk_widget_set_tooltip_text (GTK_WIDGET (button),
_("Call the selected contact"));
gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (button), "win.call");
gtk_header_bar_pack_start (GTK_HEADER_BAR (mw->priv->actions_toolbar), button);
mw->priv->preview_button = gtk_toggle_button_new ();
image = gtk_image_new_from_icon_name ("camera-web-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (mw->priv->preview_button), image);
gtk_widget_set_tooltip_text (GTK_WIDGET (mw->priv->preview_button),
_("Display images from your camera device"));
gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (mw->priv->preview_button),
"win.enable-preview");
gtk_header_bar_pack_start (GTK_HEADER_BAR (mw->priv->actions_toolbar), mw->priv->preview_button);
switcher = gtk_stack_switcher_new ();
gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER (switcher), GTK_STACK (mw->priv->main_stack));
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (mw->priv->actions_toolbar), switcher);
gtk_widget_set_margin_end (GTK_WIDGET (switcher), 6);
mw->priv->menu_button = gtk_menu_button_new ();
g_object_set (G_OBJECT (mw->priv->menu_button), "use-popover", true, NULL);
image = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (mw->priv->menu_button), image);
gtk_header_bar_pack_end (GTK_HEADER_BAR (mw->priv->actions_toolbar), mw->priv->menu_button);
gtk_widget_show_all (mw->priv->actions_toolbar);
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (mw->priv->actions_toolbar), TRUE);
}
static GtkWidget *
photos_import_dialog_create_collection_button (PhotosBaseItem *collection)
{
GtkWidget *collection_button;
GtkWidget *collection_label;
const gchar *id;
const gchar *name;
id = photos_filterable_get_id (PHOTOS_FILTERABLE (collection));
name = photos_base_item_get_name (collection);
collection_button = photos_model_button_new ();
gtk_actionable_set_action_name (GTK_ACTIONABLE (collection_button), "dialog.add-existing");
gtk_actionable_set_action_target (GTK_ACTIONABLE (collection_button), "s", id);
collection_label = gtk_label_new (name);
gtk_widget_set_halign (collection_label, GTK_ALIGN_START);
gtk_widget_set_hexpand (collection_label, TRUE);
gtk_container_add (GTK_CONTAINER (collection_button), collection_label);
return collection_button;
}
static void
setup_header_bar (GtkWidget *window,
VteTerminal *vtterm,
gboolean show_maximized_title)
{
/*
* Using the default GtkHeaderBar title/subtitle widget makes the bar
* too thick to look nice for a terminal, so set a custom widget.
*/
GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
const gchar *title = gtk_window_get_title (GTK_WINDOW (window));
GtkWidget *label = gtk_label_new (title ? title : "dwt");
g_object_bind_property (G_OBJECT (vtterm), "window-title",
G_OBJECT (label), "label",
G_BINDING_DEFAULT);
GtkWidget *header = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header), TRUE);
gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header), FALSE);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (header), label);
GtkWidget *button = gtk_button_new_from_icon_name ("tab-new-symbolic",
GTK_ICON_SIZE_BUTTON);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button), "app.new-terminal");
gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button);
GtkWidget *revealer = gtk_revealer_new ();
gtk_container_add (GTK_CONTAINER (revealer),
gtk_image_new_from_icon_name ("software-update-urgent-symbolic",
GTK_ICON_SIZE_BUTTON));
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 500);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer),
GTK_REVEALER_TRANSITION_TYPE_CROSSFADE);
gtk_header_bar_pack_end (GTK_HEADER_BAR (header), revealer);
g_signal_connect (G_OBJECT (vtterm), "bell",
G_CALLBACK (header_bar_term_beeped), revealer);
g_object_bind_property (G_OBJECT (window), "urgency-hint",
G_OBJECT (revealer), "reveal-child",
G_BINDING_DEFAULT);
gtk_window_set_titlebar (GTK_WINDOW (window), header);
/* Hide the header bar when the window is maximized. */
if (!show_maximized_title) {
g_object_bind_property (G_OBJECT (window), "is-maximized",
G_OBJECT (header), "visible",
G_BINDING_INVERT_BOOLEAN);
}
}
NiepceWindow::NiepceWindow()
: fwk::AppFrame("mainWindow-frame")
, m_vbox(Gtk::ORIENTATION_VERTICAL)
, m_hbox(Gtk::ORIENTATION_HORIZONTAL)
{
// headerbar.
Gtk::HeaderBar *header = Gtk::manage(new Gtk::HeaderBar);
header->set_show_close_button(true);
header->set_has_subtitle(true);
Gtk::MenuButton* menu_btn = Gtk::manage(new Gtk::MenuButton);
menu_btn->set_direction(Gtk::ARROW_NONE);
m_main_menu = Gio::Menu::create();
menu_btn->set_menu_model(m_main_menu);
header->pack_end(*menu_btn);
// Undo redo buttons
Gtk::Box *button_box = Gtk::manage(new Gtk::Box);
button_box->get_style_context()->add_class("linked");
Gtk::Button *undo_button = Gtk::manage(new Gtk::Button);
undo_button->set_image_from_icon_name("edit-undo-symbolic");
undo_button->set_label(_("Undo"));
undo_button->set_always_show_image(true);
gtk_actionable_set_action_name(GTK_ACTIONABLE(undo_button->gobj()), "win.Undo");
Gtk::Button *redo_button = Gtk::manage(new Gtk::Button);
redo_button->set_image_from_icon_name("edit-redo-symbolic");
gtk_actionable_set_action_name(GTK_ACTIONABLE(redo_button->gobj()), "win.Redo");
button_box->pack_start(*undo_button, false, false, 0);
button_box->pack_start(*redo_button, false, false, 0);
header->pack_start(*button_box);
Gtk::Button *import_button = Gtk::manage(new Gtk::Button);
import_button->set_label(_("Import..."));
gtk_actionable_set_action_name(GTK_ACTIONABLE(import_button->gobj()), "workspace.Import");
header->pack_start(*import_button);
setHeaderBar(header);
}
void BacklinksNoteAddin::get_backlink_menu_items(std::list<Gtk::Widget*> & items) const
{
gnote::NoteBase::List notes = get_note()->manager().get_notes_linking_to(get_note()->get_title());
FOREACH(const gnote::NoteBase::Ptr & note, notes) {
if(note != get_note()) { // don't match ourself
auto button = manage(gnote::utils::create_popover_button("win.backlinks-open-note", note->get_title()));
gtk_actionable_set_action_target_value(GTK_ACTIONABLE(button->gobj()),
Glib::Variant<Glib::ustring>::create(note->uri()).gobj());
items.push_back(button);
}
}
items.sort([](Gtk::Widget *x, Gtk::Widget *y)
{
return dynamic_cast<Gtk::ModelButton*>(x)->get_label() < dynamic_cast<Gtk::ModelButton*>(y)->get_label();
});
}
GtkWidget *
_gtk_header_bar_create_image_button (const char *icon_name,
const char *tooltip,
const char *action_name)
{
GtkWidget *button;
g_return_val_if_fail (icon_name != NULL, NULL);
g_return_val_if_fail (action_name != NULL, NULL);
button = _gtk_image_button_new_for_header_bar (icon_name);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button), action_name);
if (tooltip != NULL)
gtk_widget_set_tooltip_text (button, tooltip);
gtk_widget_show (button);
return button;
}
static void
query_console_customize (BrowserPage *page, GtkToolbar *toolbar, GtkHeaderBar *header)
{
g_print ("%s ()\n", __FUNCTION__);
customization_data_init (G_OBJECT (page), toolbar, header);
/* add perspective's actions */
customization_data_add_actions (G_OBJECT (page), win_entries, G_N_ELEMENTS (win_entries));
/* add to toolbar */
GtkToolItem *titem;
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "system-run-symbolic");
gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Execute query"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.ExecuteQuery");
gtk_widget_show (GTK_WIDGET (titem));
customization_data_add_part (G_OBJECT (page), G_OBJECT (titem));
}
static void
set_accel (GtkApplication *app, GtkWidget *widget)
{
GtkWidget *accel_label;
const gchar *action;
gchar **accels;
guint key;
GdkModifierType mods;
accel_label = gtk_bin_get_child (GTK_BIN (widget));
g_assert (GTK_IS_ACCEL_LABEL (accel_label));
action = gtk_actionable_get_action_name (GTK_ACTIONABLE (widget));
accels = gtk_application_get_accels_for_action (app, action);
gtk_accelerator_parse (accels[0], &key, &mods);
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (accel_label), key, mods);
g_strfreev (accels);
}
GtkWidget *
_gtk_header_bar_create_image_toggle_button (const char *icon_name,
const char *tooltip,
const char *action_name)
{
GtkWidget *button;
g_return_val_if_fail (icon_name != NULL, NULL);
g_return_val_if_fail (action_name != NULL, NULL);
button = gtk_toggle_button_new ();
gtk_container_add (GTK_CONTAINER (button), gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU));
_gtk_menu_button_set_style_for_header_bar (button);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button), action_name);
if (tooltip != NULL)
gtk_widget_set_tooltip_text (button, tooltip);
gtk_widget_show_all (button);
return button;
}
static void
relations_diagram_customize (BrowserPage *page, GtkToolbar *toolbar, GtkHeaderBar *header)
{
g_print ("%s ()\n", __FUNCTION__);
customization_data_init (G_OBJECT (page), toolbar, header);
/* add perspective's actions */
customization_data_add_actions (G_OBJECT (page), win_entries, G_N_ELEMENTS (win_entries));
/* add to toolbar */
GtkToolItem *titem;
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "go-jump-symbolic");
gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Manage data in selected tables"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.ViewContents");
gtk_widget_show (GTK_WIDGET (titem));
customization_data_add_part (G_OBJECT (page), G_OBJECT (titem));
}
GtkWidget *
_gtk_header_bar_create_text_button (const char *label,
const char *tooltip,
const char *action_name)
{
GtkWidget *button;
g_return_val_if_fail (label != NULL, NULL);
g_return_val_if_fail (action_name != NULL, NULL);
button = gtk_button_new_with_label (label);
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
gtk_style_context_add_class (gtk_widget_get_style_context (button), "text-button");
gtk_style_context_remove_class (gtk_widget_get_style_context (button), "image-button");
gtk_actionable_set_action_name (GTK_ACTIONABLE (button), action_name);
if (tooltip != NULL)
gtk_widget_set_tooltip_text (button, tooltip);
gtk_widget_show (button);
return button;
}
static void
gw_kanjipadwindow_constructed (GObject *object)
{
GwKanjipadWindow *window;
GwKanjipadWindowPrivate *priv;
GtkAccelGroup *accelgroup;
//Chain the parent class
{
G_OBJECT_CLASS (gw_kanjipadwindow_parent_class)->constructed (object);
}
window = GW_KANJIPADWINDOW (object);
priv = window->priv;
accelgroup = gw_window_get_accel_group (GW_WINDOW (window));
gw_kanjipadwindow_map_actions (G_ACTION_MAP (window), window);
gtk_window_set_title (GTK_WINDOW (window), gettext("gWaei Kanjipad"));
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_UTILITY);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (window), TRUE);
gtk_window_set_icon_name (GTK_WINDOW (window), "gwaei");
priv->drawingarea = GTK_DRAWING_AREA (gw_window_get_object (GW_WINDOW (window), "kdrawing_area"));
priv->candidates = GTK_DRAWING_AREA (gw_window_get_object (GW_WINDOW (window), "kguesses"));
priv->close_button = GTK_BUTTON (gw_window_get_object (GW_WINDOW (window), "close_button"));
gw_kanjipadwindow_initialize_drawingarea (window);
gw_kanjipadwindow_initialize_candidates (window);
_kanjipadwindow_initialize_engine (window);
gtk_widget_add_accelerator (GTK_WIDGET (priv->close_button), "activate",
accelgroup, (GDK_KEY_Escape), 0, GTK_ACCEL_VISIBLE);
gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (priv->close_button), "win.close");
gw_window_unload_xml (GW_WINDOW (window));
}
static gboolean
append_menu (RBButtonBar *bar, GMenuModel *menu, gboolean need_separator)
{
int i;
gulong id;
id = g_signal_connect (menu, "items-changed", G_CALLBACK (items_changed_cb), bar);
g_hash_table_insert (bar->priv->handlers, (gpointer)id, g_object_ref (menu));
for (i = 0; i < g_menu_model_get_n_items (menu); i++) {
char *label_text;
char *accel;
GtkWidget *button;
GtkWidget *label;
GMenuModel *submenu;
/* recurse into sections */
submenu = g_menu_model_get_item_link (menu, i, G_MENU_LINK_SECTION);
if (submenu != NULL) {
need_separator = append_menu (bar, submenu, TRUE);
continue;
}
/* if this item and the previous item are in different sections, add
* a separator between them. this may not be a good idea.
*/
if (need_separator) {
GtkWidget *sep;
if (bar->priv->position > 0) {
sep = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_widget_show (sep);
g_object_set (sep, "margin-start", 6, "margin-end", 6, NULL);
gtk_grid_attach (GTK_GRID (bar), sep, bar->priv->position++, 0, 1, 1);
}
need_separator = FALSE;
}
button = NULL;
/* submenus become menu buttons, normal items become buttons */
submenu = g_menu_model_get_item_link (menu, i, G_MENU_LINK_SUBMENU);
if (submenu != NULL) {
button = gtk_menu_button_new ();
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), submenu);
g_object_set_data_full (G_OBJECT (button), "rb-menu-model", g_object_ref (submenu), (GDestroyNotify)g_object_unref);
} else {
GMenuAttributeIter *iter;
const char *name;
GVariant *value;
char *str;
guint signal_id;
/* we can't do more than one of action and rb-property-bind
* and rb-signal-bind, so just do whichever turns up first
* in the iterator
*/
iter = g_menu_model_iterate_item_attributes (menu, i);
while (g_menu_attribute_iter_get_next (iter, &name, &value)) {
if (g_str_equal (name, "action")) {
button = gtk_button_new ();
g_variant_get (value, "s", &str, NULL);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button), str);
/* action target too somehow? */
g_free (str);
break;
} else if (g_str_equal (name, "rb-property-bind")) {
/* property has to be a boolean, can't do inverts, etc. etc. */
button = gtk_toggle_button_new ();
g_variant_get (value, "s", &str, NULL);
g_object_bind_property (bar->priv->target, str,
button, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
g_free (str);
break;
} else if (g_str_equal (name, "rb-signal-bind")) {
button = gtk_button_new ();
g_variant_get (value, "s", &str, NULL);
signal_id = g_signal_lookup (str, G_OBJECT_TYPE (bar->priv->target));
if (signal_id != 0) {
g_object_set_data (G_OBJECT (button), "rb-signal-bind-id", GUINT_TO_POINTER (signal_id));
g_signal_connect (button, "clicked", G_CALLBACK (signal_button_clicked_cb), bar);
}
g_free (str);
break;
}
}
g_object_unref (iter);
}
if (button == NULL) {
g_warning ("no idea what's going on here");
continue;
}
gtk_widget_set_hexpand (button, FALSE);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
label_text = NULL;
g_menu_model_get_item_attribute (menu, i, "label", "s", &label_text);
label = gtk_label_new (g_dgettext (NULL, label_text));
g_object_set (label, "margin-left", 6, "margin-right", 6, NULL);
gtk_container_add (GTK_CONTAINER (button), label);
if (g_menu_model_get_item_attribute (menu, i, "accel", "s", &accel)) {
g_object_set_data_full (G_OBJECT (button), "rb-accel", accel, (GDestroyNotify) g_free);
}
gtk_widget_show_all (button);
gtk_size_group_add_widget (bar->priv->size_group, button);
gtk_grid_attach (GTK_GRID (bar), button, bar->priv->position++, 0, 1, 1);
g_free (label_text);
}
return need_separator;
}
GtkWidget *
reader_window_new(GtkApplication *application,
CainteoirSettings *settings,
CainteoirSpeechSynthesizers *synthesizers,
const gchar *filename)
{
ReaderWindow *reader = READER_WINDOW(g_object_new(READER_TYPE_WINDOW,
"application", application,
nullptr));
ReaderWindowPrivate *priv = READER_WINDOW_PRIVATE(reader);
priv->self = GTK_WIDGET(reader);
priv->settings = CAINTEOIR_SETTINGS(g_object_ref(G_OBJECT(settings)));
priv->tts = CAINTEOIR_SPEECH_SYNTHESIZERS(g_object_ref(G_OBJECT(synthesizers)));
priv->application = READER_APPLICATION(application);
gtk_window_set_default_size(GTK_WINDOW(reader), INDEX_PANE_WIDTH + DOCUMENT_PANE_WIDTH + 5, 300);
gtk_window_set_title(GTK_WINDOW(reader), i18n("Cainteoir Text-to-Speech"));
GtkWidget *layout = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(reader), layout);
priv->header = gtk_header_bar_new();
gtk_header_bar_set_title(GTK_HEADER_BAR(priv->header), i18n("Cainteoir Text-to-Speech"));
if (cainteoir_settings_get_boolean(priv->settings, "window", "have-csd", TRUE))
{
// Use client-side decorations (e.g. on Gnome Shell and Unity) ...
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(priv->header), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(reader), priv->header);
}
else
{
// Don't use client-side decorations (e.g. on KDE) ...
gtk_box_pack_start(GTK_BOX(layout), priv->header, FALSE, FALSE, 0);
}
priv->actions = create_action_group(priv);
gtk_widget_insert_action_group(GTK_WIDGET(reader), "cainteoir", G_ACTION_GROUP(priv->actions));
priv->view = reader_document_view_new(priv->settings);
gtk_box_pack_start(GTK_BOX(layout), priv->view, TRUE, TRUE, 0);
reader_document_view_set_index_pane_close_action_name(READER_DOCUMENT_VIEW(priv->view), "cainteoir.side-pane");
GtkWidget *bottombar = gtk_toolbar_new();
gtk_widget_set_size_request(bottombar, -1, 45);
gtk_style_context_add_class(gtk_widget_get_style_context(bottombar), "bottombar");
gtk_box_pack_start(GTK_BOX(layout), bottombar, FALSE, FALSE, 0);
GtkToolItem *record = gtk_tool_button_new(gtk_image_new_from_icon_name("media-record-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR), nullptr);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), record, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(record), "cainteoir.record");
priv->play_stop = gtk_tool_button_new(nullptr, nullptr);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(priv->play_stop), "media-playback-start-symbolic");
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), priv->play_stop, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(priv->play_stop), "cainteoir.play-stop");
GtkToolItem *open = gtk_tool_button_new(gtk_image_new_from_icon_name("document-open-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR), nullptr);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), open, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(open), "cainteoir.open");
GtkToolItem *timebar = gtk_tool_item_new();
gtk_tool_item_set_expand(GTK_TOOL_ITEM(timebar), TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), timebar, -1);
priv->timebar = cainteoir_timebar_new();
gtk_style_context_add_class(gtk_widget_get_style_context(priv->timebar), "timebar");
gtk_container_add(GTK_CONTAINER(timebar), priv->timebar);
priv->previous = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(priv->previous), gtk_image_new_from_icon_name("go-previous-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_header_bar_pack_start(GTK_HEADER_BAR(priv->header), priv->previous);
gtk_actionable_set_action_name(GTK_ACTIONABLE(priv->previous), "cainteoir.view-previous");
GtkWidget *menu_button = gtk_menu_button_new();
gtk_button_set_image(GTK_BUTTON(menu_button), gtk_image_new_from_icon_name(HAMBURGER_MENU_ICON, GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(menu_button), create_main_menu());
gtk_header_bar_pack_end(GTK_HEADER_BAR(priv->header), menu_button);
g_signal_connect(reader, "window-state-event", G_CALLBACK(on_window_state_changed), priv->settings);
g_signal_connect(reader, "delete_event", G_CALLBACK(on_window_delete), priv);
g_signal_connect(reader, "show", G_CALLBACK(on_window_show), priv);
g_signal_connect(priv->tts, "speaking", G_CALLBACK(on_speaking), priv);
g_signal_connect(priv->tts, "text-range-changed", G_CALLBACK(on_text_range_changed), priv);
gtk_window_resize(GTK_WINDOW(reader),
cainteoir_settings_get_integer(priv->settings, "window", "width", 700),
cainteoir_settings_get_integer(priv->settings, "window", "height", 445));
gtk_window_move(GTK_WINDOW(reader),
cainteoir_settings_get_integer(priv->settings, "window", "left", 0),
cainteoir_settings_get_integer(priv->settings, "window", "top", 0));
if (cainteoir_settings_get_boolean(priv->settings, "window", "maximized", FALSE))
gtk_window_maximize(GTK_WINDOW(reader));
if (filename)
reader_window_load_document(reader, filename);
else
{
gchar *prev_filename = cainteoir_settings_get_string(priv->settings, "document", "filename", nullptr);
if (prev_filename)
{
reader_window_load_document(reader, prev_filename);
g_free(prev_filename);
}
}
gchar *anchor = cainteoir_settings_get_string(priv->settings, "highlight", "anchor", "none");
if (anchor)
{
if (!strcmp(anchor, "top"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_START);
else if (!strcmp(anchor, "middle"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_CENTER);
else if (!strcmp(anchor, "bottom"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_END);
g_free(anchor);
}
return GTK_WIDGET(reader);
}