static void
gimp_color_selector_init (GimpColorSelector *selector)
{
selector->toggles_visible = TRUE;
selector->toggles_sensitive = TRUE;
selector->show_alpha = TRUE;
gtk_orientable_set_orientation (GTK_ORIENTABLE (selector),
GTK_ORIENTATION_VERTICAL);
gimp_rgba_set (&selector->rgb, 0.0, 0.0, 0.0, 1.0);
gimp_rgb_to_hsv (&selector->rgb, &selector->hsv);
selector->channel = GIMP_COLOR_SELECTOR_HUE;
}
static void
gnc_date_edit_init (GNCDateEdit *gde)
{
gtk_orientable_set_orientation (GTK_ORIENTABLE(gde), GTK_ORIENTATION_HORIZONTAL);
// Set the style context for this widget so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(gde), "GncDateEdit");
gde->disposed = FALSE;
gde->popup_in_progress = FALSE;
gde->lower_hour = 7;
gde->upper_hour = 19;
gde->flags = GNC_DATE_EDIT_SHOW_TIME;
gde->in_selected_handler = FALSE;
}
static void
gtk_inspector_strv_editor_init (GtkInspectorStrvEditor *editor)
{
gtk_orientable_set_orientation (GTK_ORIENTABLE (editor), GTK_ORIENTATION_VERTICAL);
editor->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (editor->box);
editor->button = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_focus_on_click (editor->button, FALSE);
gtk_widget_set_halign (editor->button, GTK_ALIGN_END);
gtk_widget_show (editor->button);
g_signal_connect (editor->button, "clicked", G_CALLBACK (add_cb), editor);
gtk_box_pack_start (GTK_BOX (editor), editor->box, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (editor), editor->button, FALSE, FALSE, 0);
}
GtkWidget *create_en_pho_key_sel(char *s, gint index)
{
GtkWidget *frame_tsin_sw = gtk_frame_new(s);
GtkWidget *vbox_tsin_sw = gtk_vbox_new(FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_tsin_sw), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (frame_tsin_sw), vbox_tsin_sw);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_sw), 1);
gtk_container_add (GTK_CONTAINER (vbox_tsin_sw), create_eng_ch_opts(index));
GtkWidget *hbox_hime_capslock_lower = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_tsin_sw), hbox_hime_capslock_lower, FALSE, FALSE, 0);
check_button_hime_capslock_lower = gtk_check_button_new_with_label(_("按下 Capslock 時輸出小寫英數字"));
gtk_box_pack_start (GTK_BOX (hbox_hime_capslock_lower), check_button_hime_capslock_lower, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_capslock_lower), hime_capslock_lower);
return frame_tsin_sw;
}
static void
gdaui_cloud_init (GdauiCloud *cloud)
{
cloud->priv = g_new0 (GdauiCloudPriv, 1);
cloud->priv->min_scale = .8;
cloud->priv->max_scale = 2.;
cloud->priv->selected_tags = NULL;
cloud->priv->selection_mode = GTK_SELECTION_SINGLE;
gtk_orientable_set_orientation (GTK_ORIENTABLE (cloud), GTK_ORIENTATION_VERTICAL);
/* text buffer */
cloud->priv->tbuffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (cloud->priv->tbuffer, "section",
"weight", PANGO_WEIGHT_BOLD,
"foreground", "blue", NULL);
/* text view */
GtkWidget *sw, *vbox, *vp;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (cloud), sw, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
vp = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (vp), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (sw), vp);
gtk_container_add (GTK_CONTAINER (vp), vbox);
cloud->priv->tview = gtk_text_view_new_with_buffer (cloud->priv->tbuffer);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (cloud->priv->tview), GTK_WRAP_WORD);
gtk_text_view_set_editable (GTK_TEXT_VIEW (cloud->priv->tview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (cloud->priv->tview), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), cloud->priv->tview, TRUE, TRUE, 0);
gtk_widget_show_all (sw);
g_signal_connect (cloud->priv->tview, "key-press-event",
G_CALLBACK (key_press_event), cloud);
g_signal_connect (cloud->priv->tview, "event-after",
G_CALLBACK (event_after), cloud);
g_signal_connect (cloud->priv->tview, "motion-notify-event",
G_CALLBACK (motion_notify_event), cloud);
g_signal_connect (cloud->priv->tview, "visibility-notify-event",
G_CALLBACK (visibility_notify_event), cloud);
}
static void create_char(int index)
{
int i;
if (!hbox_edit)
return;
GdkColor fg;
gdk_color_parse(hime_win_color_fg, &fg);
GdkColor color_bg;
gdk_color_parse(tsin_phrase_line_color, &color_bg);
i = index;
{
if (chars[i].vbox)
return;
GtkWidget *event_box = gtk_event_box_new();
gtk_event_box_set_visible_window (GTK_EVENT_BOX(event_box), FALSE);
chars[i].vbox = event_box;
g_signal_connect (G_OBJECT (event_box), "button-press-event", G_CALLBACK (mouse_char_callback), GINT_TO_POINTER(index));
gtk_box_pack_start (GTK_BOX (hbox_edit), event_box, FALSE, FALSE, 0);
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
gtk_container_add(GTK_CONTAINER(event_box), vbox);
GtkWidget *label = gtk_label_new(NULL);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
set_label_font_size(label, hime_font_size);
chars[i].label = label;
if (hime_win_color_use) {
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &fg);
#else
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&fg));
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
}
gtk_widget_show_all(event_box);
}
}
static void
nautilus_trash_bar_init (NautilusTrashBar *bar)
{
GtkWidget *content_area, *action_area, *w;
GtkWidget *label;
PangoAttrList *attrs;
bar->priv = NAUTILUS_TRASH_BAR_GET_PRIVATE (bar);
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action_area),
GTK_ORIENTATION_HORIZONTAL);
attrs = pango_attr_list_new ();
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
label = gtk_label_new (_("Trash"));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("_Restore"),
TRASH_BAR_RESPONSE_RESTORE);
gtk_widget_set_tooltip_text (w,
_("Restore selected items to their original position"));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
/* Translators: "Empty" is an action (for the trash) , not a state */
_("_Empty"),
TRASH_BAR_RESPONSE_EMPTY);
gtk_widget_set_tooltip_text (w,
_("Delete all items in the Trash"));
g_signal_connect_object (nautilus_trash_monitor_get (),
"trash-state-changed",
G_CALLBACK (nautilus_trash_bar_trash_state_changed),
bar,
0);
nautilus_trash_bar_trash_state_changed (nautilus_trash_monitor_get (),
FALSE, bar);
g_signal_connect (bar, "response",
G_CALLBACK (trash_bar_response_cb), bar);
}
static void
nemo_interesting_folder_bar_constructed (GObject *obj)
{
G_OBJECT_CLASS (nemo_interesting_folder_bar_parent_class)->constructed (obj);
NemoInterestingFolderBar *bar = NEMO_INTERESTING_FOLDER_BAR (obj);
GtkWidget *content_area, *action_area, *w;
GtkWidget *label;
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action_area),
GTK_ORIENTATION_HORIZONTAL);
switch (bar->priv->type) {
case TYPE_ACTIONS_FOLDER:
label = gtk_label_new (_("Actions: Action files can be added to this folder and will appear in the menu."));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("More info"),
INTERESTING_FOLDER_BAR_ACTION_OPEN_DOC);
gtk_widget_set_tooltip_text (w, _("View a sample action file with documentation"));
break;
case TYPE_SCRIPTS_FOLDER:
label = gtk_label_new (_("Scripts: All executable files in this folder will appear in the "
"Scripts menu."));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("More info"),
INTERESTING_FOLDER_BAR_SCRIPT_OPEN_DOC);
gtk_widget_set_tooltip_text (w, _("View additional information about creating scripts"));
break;
case TYPE_NONE_FOLDER:
default:
label = gtk_label_new ("undefined");
break;
}
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (label),
"nemo-cluebar-label");
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
g_signal_connect (bar, "response",
G_CALLBACK (interesting_folder_bar_response_cb), bar);
}
static void
gtk_stack_switcher_init (GtkStackSwitcher *switcher)
{
GtkStyleContext *context;
GtkStackSwitcherPrivate *priv;
priv = G_TYPE_INSTANCE_GET_PRIVATE (switcher, GTK_TYPE_STACK_SWITCHER, GtkStackSwitcherPrivate);
switcher->priv = priv;
priv->stack = NULL;
priv->buttons = g_hash_table_new (g_direct_hash, g_direct_equal);
context = gtk_widget_get_style_context (GTK_WIDGET (switcher));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_LINKED);
gtk_orientable_set_orientation (GTK_ORIENTABLE (switcher), GTK_ORIENTATION_HORIZONTAL);
}
static void
my_icon_view_init (MyIconView *view)
{
GtkCellArea *area;
if (subclass_init == 0)
{
/* do nothing to area */
}
else if (subclass_init == 1)
{
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (view));
g_assert (GTK_IS_CELL_AREA_BOX (area));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_VERTICAL);
gtk_orientable_set_orientation (GTK_ORIENTABLE (area), GTK_ORIENTATION_HORIZONTAL);
}
}
static void
photos_dropdown_init (PhotosDropdown *self)
{
PhotosDropdownPrivate *priv;
GApplication *app;
GtkStyleContext *context;
GtkWidget *frame;
PhotosSearchContextState *state;
self->priv = photos_dropdown_get_instance_private (self);
priv = self->priv;
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
priv->srch_mtch_mngr = g_object_ref (state->srch_mtch_mngr);
priv->srch_typ_mngr = g_object_ref (state->srch_typ_mngr);
priv->src_mngr = g_object_ref (state->src_mngr);
priv->match_view = photos_base_view_new (priv->srch_mtch_mngr);
priv->source_view = photos_base_view_new (priv->src_mngr);
priv->type_view = photos_base_view_new (priv->srch_typ_mngr);
g_signal_connect_swapped (priv->match_view, "item-activated", G_CALLBACK (photos_dropdown_item_activated), self);
g_signal_connect_swapped (priv->source_view, "item-activated", G_CALLBACK (photos_dropdown_item_activated), self);
g_signal_connect_swapped (priv->type_view, "item-activated", G_CALLBACK (photos_dropdown_item_activated), self);
frame = gtk_frame_new (NULL);
gtk_widget_set_opacity (frame, 0.9);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
context = gtk_widget_get_style_context (frame);
gtk_style_context_add_class (context, "photos-dropdown");
gtk_container_add (GTK_CONTAINER (self), frame);
priv->grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->grid), GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (frame), priv->grid);
gtk_container_add (GTK_CONTAINER (priv->grid), priv->source_view);
gtk_container_add (GTK_CONTAINER (priv->grid), priv->type_view);
gtk_container_add (GTK_CONTAINER (priv->grid), priv->match_view);
photos_dropdown_hide (self);
gtk_widget_show_all (GTK_WIDGET (self));
}
static void
eina_seek_init (EinaSeek *self)
{
EinaSeekPrivate *priv = self->priv = (G_TYPE_INSTANCE_GET_PRIVATE ((self), EINA_TYPE_SEEK, EinaSeekPrivate));
gtk_orientable_set_orientation(GTK_ORIENTABLE(self), GTK_ORIENTATION_HORIZONTAL);
priv->total_is_desync = TRUE;
priv->lomo = NULL;
for (guint i = 0; i < EINA_SEEK_N_TIMES; i++)
{
priv->time_labels[i] = NULL;
priv->time_fmts[i] = NULL;
}
priv->fast_scan_position = -1;
priv->fast_scan_timeout_id = 0;
}
static void ygtk_steps_init (YGtkSteps *steps)
{
gtk_box_set_spacing (GTK_BOX (steps), 8);
gtk_orientable_set_orientation (GTK_ORIENTABLE (steps), GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (steps), 4);
const gchar *check = "\u2714", *current = "\u25b6", *todo = "\u26ab";
if (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL)
current = "\u25c0";
PangoContext *context = gtk_widget_get_pango_context (GTK_WIDGET (steps));
steps->check_mark_layout = pango_layout_new (context);
steps->current_mark_layout = pango_layout_new (context);
steps->todo_mark_layout = pango_layout_new (context);
pango_layout_set_text (steps->check_mark_layout, check, -1);
pango_layout_set_text (steps->current_mark_layout, current, -1);
pango_layout_set_text (steps->todo_mark_layout, todo, -1);
steps->current_mark_timeout_id = steps->current_mark_frame = 0;
}
static void
gtk_menu_section_box_init (GtkMenuSectionBox *box)
{
GtkWidget *item_box;
gtk_orientable_set_orientation (GTK_ORIENTABLE (box), GTK_ORIENTATION_VERTICAL);
box->toplevel = box;
item_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
box->item_box = GTK_BOX (item_box);
gtk_box_pack_end (GTK_BOX (box), item_box, FALSE, FALSE, 0);
gtk_widget_set_halign (GTK_WIDGET (item_box), GTK_ALIGN_FILL);
gtk_widget_show (item_box);
gtk_widget_set_halign (GTK_WIDGET (box), GTK_ALIGN_FILL);
g_object_set (box, "margin", 0, NULL);
}
static void gigolo_bookmark_panel_init(GigoloBookmarkPanel *self)
{
GtkWidget *swin, *toolbar;
GtkToolItem *toolitem;
GigoloBookmarkPanelPrivate *priv = gigolo_bookmark_panel_get_instance_private(self);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL);
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_BUTTON);
toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name ("gtk-connect",
gtk_toolbar_get_icon_size(GTK_TOOLBAR(toolbar))), NULL);
gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _("Connect to the selected bookmark"));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
g_signal_connect(toolitem, "clicked", G_CALLBACK(button_connect_click_cb), self);
priv->button_connect = GTK_WIDGET(toolitem);
toolitem = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name ("gtk-close",
gtk_toolbar_get_icon_size(GTK_TOOLBAR(toolbar))), NULL);
gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _("Close panel"));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
g_signal_connect(toolitem, "clicked", G_CALLBACK(button_close_click_cb), self);
tree_prepare(self);
swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(swin), priv->tree);
gtk_box_pack_start(GTK_BOX(self), toolbar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self), swin, TRUE, TRUE, 0);
gtk_widget_show_all(toolbar);
gtk_widget_show_all(swin);
}
static void
pnl_tab_strip_init (PnlTabStrip *self)
{
PnlTabStripPrivate *priv = pnl_tab_strip_get_instance_private (self);
GSimpleActionGroup *group;
static const GActionEntry entries[] = {
{ "tab", NULL, "i", "0", set_tab_state },
};
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_HORIZONTAL);
group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (group), entries, G_N_ELEMENTS (entries), self);
priv->action = g_object_ref (g_action_map_lookup_action (G_ACTION_MAP (group), "tab"));
gtk_widget_insert_action_group (GTK_WIDGET (self), "tab-strip", G_ACTION_GROUP (group));
g_object_unref (group);
pnl_tab_strip_set_edge (self, GTK_POS_TOP);
}
static void
gimp_message_box_init (GimpMessageBox *box)
{
gint i;
gtk_orientable_set_orientation (GTK_ORIENTABLE (box),
GTK_ORIENTATION_VERTICAL);
gtk_box_set_spacing (GTK_BOX (box), 12);
gtk_container_set_border_width (GTK_CONTAINER (box), 12);
/* Unset the focus chain to keep the labels from being in the focus
* chain. Users of GimpMessageBox that add focusable widgets should
* either unset the focus chain or (better) explicitly set one.
*/
gtk_container_set_focus_chain (GTK_CONTAINER (box), NULL);
for (i = 0; i < 2; i++)
{
GtkWidget *label = g_object_new (GTK_TYPE_LABEL,
"wrap", TRUE,
"wrap-mode", PANGO_WRAP_WORD_CHAR,
"max-width-chars", 80,
"selectable", TRUE,
"xalign", 0.0,
"yalign", 0.5,
NULL);
if (i == 0)
gimp_label_set_attributes (GTK_LABEL (label),
PANGO_ATTR_SCALE, PANGO_SCALE_LARGE,
PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD,
-1);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
box->label[i] = label;
}
box->repeat = 0;
box->label[2] = NULL;
box->idle_id = 0;
}
static void
nemo_trash_bar_init (NemoTrashBar *bar)
{
GtkWidget *content_area, *action_area, *w;
GtkWidget *label;
bar->priv = NEMO_TRASH_BAR_GET_PRIVATE (bar);
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action_area),
GTK_ORIENTATION_HORIZONTAL);
label = gtk_label_new (_("Trash"));
gtk_style_context_add_class (gtk_widget_get_style_context (label),
"nemo-cluebar-label");
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("Restore Selected Items"),
TRASH_BAR_RESPONSE_RESTORE);
gtk_widget_set_tooltip_text (w,
_("Restore selected items to their original position"));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("Empty _Trash"),
TRASH_BAR_RESPONSE_EMPTY);
gtk_widget_set_tooltip_text (w,
_("Delete all items in the Trash"));
g_signal_connect_object (nemo_trash_monitor_get (),
"trash_state_changed",
G_CALLBACK (nemo_trash_bar_trash_state_changed),
bar,
0);
nemo_trash_bar_trash_state_changed (nemo_trash_monitor_get (),
FALSE, bar);
g_signal_connect (bar, "response",
G_CALLBACK (trash_bar_response_cb), bar);
}
create_statusbar ()void *GtkMain(void * argument)
{
printf("%s:%d\n", __func__, __LINE__);
int argc = 0;
char**argv = NULL;
unsigned char haveUrl = 0;
int argCount = 0;
{
g_main_statusbar = GTK_STATUSBAR (gtk_statusbar_new ());
gtk_widget_set_can_focus(GTK_WIDGET (g_main_statusbar), false);
status_context_id = gtk_statusbar_get_context_id (g_main_statusbar, "Link Hover");
return (GtkWidget*)g_main_statusbar;
}
static GtkWidget*
create_toolbar ()
{
g_toolbar = gtk_toolbar_new ();
gtk_widget_set_can_focus(GTK_WIDGET (g_toolbar), false);
#if GTK_CHECK_VERSION(2,15,0)
gtk_orientable_set_orientation (GTK_ORIENTABLE (g_toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
gtk_toolbar_set_orientation (GTK_TOOLBAR (g_toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
gtk_toolbar_set_style (GTK_TOOLBAR (g_toolbar), GTK_TOOLBAR_BOTH_HORIZ);
/* The URL entry */
itemUrl = gtk_tool_item_new ();
gtk_widget_set_can_focus(GTK_WIDGET (itemUrl), false);
gtk_tool_item_set_expand (itemUrl, TRUE);
uri_entry = gtk_entry_new ();
gtk_container_add (GTK_CONTAINER (itemUrl), uri_entry);
g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL);
gtk_toolbar_insert (GTK_TOOLBAR (g_toolbar), itemUrl, -1);
return g_toolbar;
}
static void
photos_dlna_renderers_dialog_add_renderer (PhotosDlnaRenderersDialog *self, PhotosDlnaRenderer *renderer)
{
PhotosDlnaRenderersDialogPrivate *priv = self->priv;
GIcon *icon;
GtkWidget *row;
GtkWidget *row_grid;
GtkWidget *image;
GtkWidget *label;
const gchar *name;
row = gtk_list_box_row_new ();
gtk_container_add (GTK_CONTAINER (priv->listbox), row);
row_grid = gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (row_grid), 12);
gtk_orientable_set_orientation (GTK_ORIENTABLE (row_grid), GTK_ORIENTATION_HORIZONTAL);
gtk_grid_set_column_spacing (GTK_GRID (row_grid), 12);
gtk_container_add (GTK_CONTAINER (row), row_grid);
g_object_set_data_full (G_OBJECT (row), "renderer", renderer, g_object_unref);
name = photos_dlna_renderer_get_friendly_name (renderer);
icon = g_themed_icon_new_with_default_fallbacks (PHOTOS_ICON_VIDEO_DISPLAY_SYMBOLIC);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_ref (image); /* keep a ref for the following async call and release it in the callback */
photos_dlna_renderer_get_icon (renderer,
"",
"",
GTK_ICON_SIZE_DIALOG,
NULL,
photos_dlna_renderers_dialog_set_icon_cb,
image);
gtk_container_add (GTK_CONTAINER (row_grid), image);
label = gtk_label_new (NULL);
gtk_label_set_text (GTK_LABEL (label), name);
gtk_container_add (GTK_CONTAINER (row_grid), label);
}
void create_stat_win()
{
gwin_stat = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(gwin_stat), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (gwin_stat), 0);
gtk_widget_realize (gwin_stat);
set_no_focus(gwin_stat);
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (gwin_stat), vbox);
label_disp = gtk_label_new(NULL);
gtk_box_pack_start (GTK_BOX (vbox), label_disp, TRUE, TRUE, 0);
gtk_widget_show_all(gwin_stat);
timeout_handle = g_timeout_add(3000, timeout_update_stat, NULL);
}
GtkWidget *gui_toolbar_new(toolbar_item_t *tbitems)
{
GtkWidget *icon;
GtkWidget *toolbar;
GtkToolItem *item;
int i;
toolbar = gtk_toolbar_new();
gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_HORIZONTAL );
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH);
for (i=0; tbitems[i].icon!=NULL; i++)
{
if (strcmp(tbitems[i].icon,TOOLBAR_ITEM_SEPARATOR)==0)
{
item = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1);
}
else if (strcmp(tbitems[i].icon,TOOLBAR_ITEM_EXPANDER)==0)
{
item = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM(item),FALSE);
gtk_tool_item_set_expand(GTK_TOOL_ITEM(item),TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1);
}
else
{
icon = gtk_image_new_from_icon_name(tbitems[i].icon, GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new(icon, tbitems[i].text);
if (tbitems[i].callback)
g_signal_connect(G_OBJECT(item),"clicked",G_CALLBACK(tbitems[i].callback),(gpointer)tbitems[i].callback_data);
if (tbitems[i].tooltip)
gtk_widget_set_tooltip_text(GTK_WIDGET(item),tbitems[i].tooltip);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1);
}
}
return toolbar;
}
bool wxGauge::Create( wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxGauge creation failed") );
return false;
}
m_rangeMax = range;
m_widget = gtk_progress_bar_new();
g_object_ref(m_widget);
if ( style & wxGA_VERTICAL )
{
#ifdef __WXGTK3__
gtk_orientable_set_orientation(GTK_ORIENTABLE(m_widget), GTK_ORIENTATION_VERTICAL);
gtk_progress_bar_set_inverted(GTK_PROGRESS_BAR(m_widget), true);
#else
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR(m_widget),
GTK_PROGRESS_BOTTOM_TO_TOP );
#endif
}
// when using the gauge in indeterminate mode, we need this:
gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR (m_widget), 0.05);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size);
return true;
}
static void
text_grid (void)
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *paned1;
GtkWidget *box;
GtkWidget *label;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Height-for-Width");
paned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window), paned1);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_paned_pack1 (GTK_PANED (paned1), box, TRUE, FALSE);
gtk_paned_pack2 (GTK_PANED (paned1), gtk_label_new ("Space"), TRUE, FALSE);
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Above"));
gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
gtk_container_add (GTK_CONTAINER (box), grid);
gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Below"));
label = gtk_label_new ("Some text that may wrap if it has to");
gtk_label_set_width_chars (GTK_LABEL (label), 10);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), test_widget ("1", "red"), 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), test_widget ("2", "blue"), 0, 1, 1, 1);
label = gtk_label_new ("Some text that may wrap if it has to");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_label_set_width_chars (GTK_LABEL (label), 10);
gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 1, 1);
gtk_widget_show_all (window);
}
GtkWidget *create_info_bar_update_music(struct con_win *cwin)
{
GtkWidget *info_bar = gtk_info_bar_new();
GtkWidget *action_area = gtk_info_bar_get_action_area(GTK_INFO_BAR (info_bar));
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
gtk_orientable_set_orientation(GTK_ORIENTABLE(action_area), GTK_ORIENTATION_HORIZONTAL);
//GtkInfoBar has undocumented behavior for GTK_RESPONSE_CANCEL
gtk_info_bar_add_button(GTK_INFO_BAR(info_bar), GTK_STOCK_NO, GTK_RESPONSE_CANCEL);
gtk_info_bar_add_button(GTK_INFO_BAR(info_bar), GTK_STOCK_YES, GTK_RESPONSE_YES);
GtkWidget *label = gtk_label_new(_("Want to upgrade your music library?"));
gtk_box_pack_start(GTK_BOX(content_area), label, FALSE, FALSE, 0);
g_signal_connect(info_bar, "response", G_CALLBACK(info_bar_update_response_cb), cwin);
gtk_widget_show_all(info_bar);
return info_bar;
}
static GtkWidget *create_hime_icon_dir_display()
{
GtkWidget *hbox_hime_icon_dir = gtk_hbox_new(FALSE, 10);
gtk_orientable_set_orientation(GTK_ORIENTABLE(hbox_hime_icon_dir), GTK_ORIENTATION_HORIZONTAL);
GtkWidget *label = gtk_label_new(_("Icon style"));
gtk_box_pack_start(GTK_BOX(hbox_hime_icon_dir), label, FALSE, FALSE, 0);
opt_hime_icon_dir_display = gtk_combo_box_new_text();
gtk_box_pack_start(GTK_BOX(hbox_hime_icon_dir), opt_hime_icon_dir_display, FALSE, FALSE, 0);
int i, current_idx=0;
for(i = 0; i < sizeof(icon_dir_sel)/sizeof(icon_dir_sel[0]); i++) {
gtk_combo_box_append_text(GTK_COMBO_BOX_TEXT(opt_hime_icon_dir_display), icon_dir_sel[i].name);
if(!strcmp(hime_icon_dir, icon_dir_sel[i].path)){
current_idx = i;
}
}
gtk_combo_box_set_active(GTK_COMBO_BOX(opt_hime_icon_dir_display), current_idx);
return hbox_hime_icon_dir;
}
static void
wallpaper_data_set (WallpaperData *wdata)
{
GtkWidget *infobar;
wallpaper_style_set_as_current (&wdata->new_style);
infobar = gth_browser_get_infobar (wdata->browser);
gth_info_bar_set_icon (GTH_INFO_BAR (infobar), GTK_STOCK_DIALOG_INFO);
{
char *name;
char *msg;
name = _g_file_get_display_name (wdata->new_style.file);
msg = g_strdup_printf ("The image \"%s\" has been set as desktop background", name);
gth_info_bar_set_primary_text (GTH_INFO_BAR (infobar), msg);
g_free (msg);
g_free (name);
}
_gtk_info_bar_clear_action_area (GTK_INFO_BAR (infobar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (gtk_info_bar_get_action_area (GTK_INFO_BAR (infobar))), GTK_ORIENTATION_HORIZONTAL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (infobar), GTK_MESSAGE_INFO);
gtk_info_bar_add_buttons (GTK_INFO_BAR (infobar),
GTK_STOCK_PREFERENCES, _RESPONSE_PREFERENCES,
GTK_STOCK_UNDO, _RESPONSE_UNDO,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_info_bar_set_response_sensitive (GTK_INFO_BAR (infobar),
_RESPONSE_UNDO,
wdata->old_style.file != NULL);
wdata->response_id = g_signal_connect (infobar,
"response",
G_CALLBACK (infobar_response_cb),
wdata);
gtk_widget_show (infobar);
}
static void
gtk_app_chooser_widget_init (GtkAppChooserWidget *self)
{
GtkWidget *scrolled_window;
GtkTreeSelection *selection;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_APP_CHOOSER_WIDGET,
GtkAppChooserWidgetPrivate);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scrolled_window, 400, 300);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolled_window);
self->priv->program_list = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->priv->program_list),
FALSE);
gtk_container_add (GTK_CONTAINER (scrolled_window), self->priv->program_list);
gtk_box_pack_start (GTK_BOX (self), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (self->priv->program_list);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function (selection, gtk_app_chooser_selection_func,
self, NULL);
g_signal_connect_swapped (selection, "changed",
G_CALLBACK (refresh_and_emit_app_selected),
self);
g_signal_connect (self->priv->program_list, "row-activated",
G_CALLBACK (program_list_selection_activated),
self);
g_signal_connect (self->priv->program_list, "button-press-event",
G_CALLBACK (widget_button_press_event_cb),
self);
}
static void
nautilus_window_slot_constructed (GObject *object)
{
NautilusWindowSlot *slot = NAUTILUS_WINDOW_SLOT (object);
GtkWidget *extras_vbox;
G_OBJECT_CLASS (nautilus_window_slot_parent_class)->constructed (object);
gtk_orientable_set_orientation (GTK_ORIENTABLE (slot),
GTK_ORIENTATION_VERTICAL);
gtk_widget_show (GTK_WIDGET (slot));
extras_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
slot->extra_location_widgets = extras_vbox;
gtk_box_pack_start (GTK_BOX (slot), extras_vbox, FALSE, FALSE, 0);
gtk_widget_show (extras_vbox);
slot->query_editor = NAUTILUS_QUERY_EDITOR (nautilus_query_editor_new ());
nautilus_window_slot_add_extra_location_widget (slot, GTK_WIDGET (slot->query_editor));
g_object_add_weak_pointer (G_OBJECT (slot->query_editor),
(gpointer *) &slot->query_editor);
slot->view_overlay = gtk_overlay_new ();
gtk_widget_add_events (slot->view_overlay,
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK);
gtk_box_pack_start (GTK_BOX (slot), slot->view_overlay, TRUE, TRUE, 0);
gtk_widget_show (slot->view_overlay);
slot->floating_bar = nautilus_floating_bar_new (NULL, NULL, FALSE);
gtk_widget_set_halign (slot->floating_bar, GTK_ALIGN_END);
gtk_widget_set_valign (slot->floating_bar, GTK_ALIGN_END);
gtk_overlay_add_overlay (GTK_OVERLAY (slot->view_overlay),
slot->floating_bar);
g_signal_connect (slot->floating_bar, "action",
G_CALLBACK (floating_bar_action_cb), slot);
slot->title = g_strdup (_("Loading..."));
}
static void
gimp_action_editor_init (GimpActionEditor *editor)
{
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *entry;
gtk_orientable_set_orientation (GTK_ORIENTABLE (editor),
GTK_ORIENTATION_VERTICAL);
gtk_box_set_spacing (GTK_BOX (editor), 12);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("_Search:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_activatable (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY, TRUE);
gtk_entry_set_icon_sensitive (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY, FALSE);
g_signal_connect (entry, "icon-press",
G_CALLBACK (gimp_action_editor_filter_clear),
NULL);
g_signal_connect (entry, "changed",
G_CALLBACK (gimp_action_editor_filter_changed),
editor);
}
