void
mc_create_command_entry (MCData *mc)
{
mc->applet_box = icon_entry_new ();
mc->entry= ICON_ENTRY(mc->applet_box)->entry;
g_object_set_data (G_OBJECT (mc->applet_box), "mcdata", mc);
gtk_entry_set_max_length (GTK_ENTRY (mc->entry), MC_MAX_COMMAND_LENGTH);
mc->history_button = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (mc->history_button), FALSE);
mc->history_image = gtk_image_new_from_stock ("gtk-go-down",
GTK_ICON_SIZE_MENU);
gtk_widget_show (mc->history_image);
gtk_container_add (GTK_CONTAINER (mc->history_button), mc->history_image);
icon_entry_pack_widget (ICON_ENTRY(mc->applet_box), mc->history_button, FALSE);
mc->file_select_button = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (mc->file_select_button), FALSE);
mc->file_select_image = gtk_image_new_from_stock ("gtk-open",
GTK_ICON_SIZE_MENU);
gtk_widget_show (mc->file_select_image);
gtk_container_add (GTK_CONTAINER (mc->file_select_button), mc->file_select_image);
icon_entry_pack_widget (ICON_ENTRY(mc->applet_box),
mc->file_select_button, FALSE);
g_signal_connect (mc->entry, "key_press_event",
G_CALLBACK (command_key_event), mc);
g_signal_connect (mc->entry, "button_press_event",
G_CALLBACK (button_press_cb), mc);
g_signal_connect (mc->file_select_button, "button_press_event",
G_CALLBACK (button_press_hack), mc);
g_signal_connect (mc->history_button, "button_press_event",
G_CALLBACK (button_press_hack), mc);
if (!mc->preferences.show_default_theme)
{
gtk_widget_set_name (mc->entry, "minicommander-applet-entry");
mc_command_update_entry_color (mc);
}
else
gtk_widget_set_name (mc->entry,
"minicommander-applet-entry-default");
mc_command_update_entry_size (mc);
set_atk_name_description (mc->entry,
_("Command line"),
_("Type a command here and Gnome will execute it for you"));
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *eventbox;
GtkWidget *icon;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
icon = gtk_image_new_from_file ("bt-blocked.svg");
eventbox = gtk_event_box_new ();
gtk_widget_set_app_paintable(eventbox, TRUE);
g_signal_connect (G_OBJECT (eventbox), "draw", G_CALLBACK (draw_box_back), NULL);
gtk_event_box_set_visible_window (GTK_EVENT_BOX (eventbox), TRUE);
gtk_container_add (GTK_CONTAINER (eventbox), icon);
gtk_container_add (GTK_CONTAINER (window), eventbox);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
SlingshotFrontendAppItem* slingshot_frontend_app_item_construct (GType object_type, gint size) {
SlingshotFrontendAppItem * self = NULL;
gint _tmp0_ = 0;
gint _tmp1_ = 0;
gint _tmp2_ = 0;
GtkVBox* _tmp3_ = NULL;
GtkVBox* _tmp4_ = NULL;
GtkVBox* _tmp5_ = NULL;
self = (SlingshotFrontendAppItem*) g_object_new (object_type, NULL);
_tmp0_ = size;
self->priv->icon_size = _tmp0_;
gtk_event_box_set_visible_window ((GtkEventBox*) self, FALSE);
g_object_set ((GtkWidget*) self, "can-focus", TRUE, NULL);
_tmp1_ = self->priv->icon_size;
_tmp2_ = self->priv->icon_size;
gtk_widget_set_size_request ((GtkWidget*) self, _tmp1_ * 3, _tmp2_ + 30);
_tmp3_ = (GtkVBox*) gtk_vbox_new (FALSE, 0);
g_object_ref_sink (_tmp3_);
_g_object_unref0 (self->priv->wrapper);
self->priv->wrapper = _tmp3_;
_tmp4_ = self->priv->wrapper;
g_signal_connect_object ((GtkWidget*) _tmp4_, "expose-event", (GCallback) _slingshot_frontend_app_item_draw_icon_gtk_widget_expose_event, self, 0);
_tmp5_ = self->priv->wrapper;
gtk_container_add ((GtkContainer*) self, (GtkWidget*) _tmp5_);
g_signal_connect_object ((GtkWidget*) self, "expose-event", (GCallback) _slingshot_frontend_app_item_draw_background_gtk_widget_expose_event, self, 0);
g_signal_connect_object ((GtkWidget*) self, "focus-in-event", (GCallback) ___lambda5__gtk_widget_focus_in_event, self, 0);
g_signal_connect_object ((GtkWidget*) self, "focus-out-event", (GCallback) ___lambda7__gtk_widget_focus_out_event, self, 0);
return self;
}
static TimeOutPlugin*
time_out_new (XfcePanelPlugin *plugin)
{
TimeOutPlugin *time_out;
GtkOrientation orientation;
/* Allocate memory for the plugin structure */
time_out = panel_slice_new0 (TimeOutPlugin);
/* Store pointer to the plugin */
time_out->plugin = plugin;
/* Create lock screen */
time_out->lock_screen = time_out_lock_screen_new ();
/* Connect to 'postpone' signal of the lock screen */
g_signal_connect (G_OBJECT (time_out->lock_screen), "postpone", G_CALLBACK (time_out_postpone), time_out);
/* Connect to 'resume' signal of the lock screen */
g_signal_connect (G_OBJECT (time_out->lock_screen), "resume", G_CALLBACK (time_out_resume), time_out);
/* Create countdowns */
time_out->break_countdown = time_out_countdown_new ();
time_out->lock_countdown = time_out_countdown_new ();
/* Connect to break countdown signals */
g_signal_connect (G_OBJECT (time_out->break_countdown), "update", G_CALLBACK (time_out_break_countdown_update), time_out);
g_signal_connect (G_OBJECT (time_out->break_countdown), "finish", G_CALLBACK (time_out_break_countdown_finish), time_out);
/* Connect to lock countdown signals */
g_signal_connect (G_OBJECT (time_out->lock_countdown), "update", G_CALLBACK (time_out_lock_countdown_update), time_out);
g_signal_connect (G_OBJECT (time_out->lock_countdown), "finish", G_CALLBACK (time_out_lock_countdown_finish), time_out);
/* Get the current orientation */
orientation = xfce_panel_plugin_get_orientation (plugin);
/* Create event box to catch user events */
time_out->ebox = gtk_event_box_new ();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(time_out->ebox), FALSE);
gtk_widget_show (time_out->ebox);
/* Create flexible box which can do both, horizontal and vertical layout */
time_out->hvbox = xfce_hvbox_new (orientation, FALSE, 2);
gtk_container_add (GTK_CONTAINER (time_out->ebox), time_out->hvbox);
gtk_widget_show (time_out->hvbox);
/* Create time out icon */
time_out->panel_icon = gtk_image_new_from_icon_name ("xfce4-time-out-plugin", GTK_ICON_SIZE_DIALOG);
gtk_image_set_pixel_size (GTK_IMAGE (time_out->panel_icon), xfce_panel_plugin_get_size (time_out->plugin) - 8);
gtk_box_pack_start (GTK_BOX (time_out->hvbox), time_out->panel_icon, TRUE, TRUE, 0);
gtk_widget_show (time_out->panel_icon);
/* Create label for displaying the remaining time until the next break */
time_out->time_label = gtk_label_new (_("Inactive"));
gtk_misc_set_alignment (GTK_MISC (time_out->time_label), 0.5, 0.5);
gtk_box_pack_start (GTK_BOX (time_out->hvbox), time_out->time_label, TRUE, TRUE, 0);
gtk_widget_show (time_out->time_label);
return time_out;
}
static GtkWidget *ui_make_img_btn(char *img_btn)
{
GtkWidget *image;
GtkWidget *eventbox;
eventbox = gtk_event_box_new();
gtk_widget_set_events(eventbox, GDK_MOTION_NOTIFY | GDK_BUTTON_RELEASE
| GDK_BUTTON_PRESS
| GDK_ENTER_NOTIFY
| GDK_LEAVE_NOTIFY);
image = gtk_image_new_from_file(img_btn);
gtk_container_add(GTK_CONTAINER(eventbox), image);
/* set eventbox not visible, only accept event */
gtk_event_box_set_visible_window(GTK_EVENT_BOX(eventbox), FALSE);
/* just change the mouse style */
g_signal_connect(eventbox, "button_press_event", G_CALLBACK(e_img_btn_handle), NULL);
g_signal_connect(eventbox, "button_release_event", G_CALLBACK(e_img_btn_handle), NULL);
g_signal_connect(eventbox, "enter_notify_event", G_CALLBACK(e_img_btn_handle), NULL);
g_signal_connect(eventbox, "leave_notify_event", G_CALLBACK(e_img_btn_handle), NULL);
return eventbox;
}
static void
colorful_tabs_deactivate_cb (MidoriExtension* extension,
MidoriBrowser* browser)
{
guint i;
GtkWidget* view;
MidoriApp* app = midori_extension_get_app (extension);
g_signal_handlers_disconnect_by_func (
app, colorful_tabs_app_add_browser_cb, extension);
g_signal_handlers_disconnect_by_func (
browser, colorful_tabs_browser_add_tab_cb, extension);
g_signal_handlers_disconnect_by_func (
extension, colorful_tabs_deactivate_cb, browser);
i = 0;
while ((view = midori_browser_get_nth_tab (browser, i++)))
{
GtkWidget* label = midori_view_get_proxy_tab_label (MIDORI_VIEW (view));
gtk_event_box_set_visible_window (GTK_EVENT_BOX (label), FALSE);
gtk_widget_modify_bg (label, GTK_STATE_NORMAL, NULL);
gtk_widget_modify_bg (label, GTK_STATE_ACTIVE, NULL);
gtk_container_foreach (GTK_CONTAINER (gtk_bin_get_child (GTK_BIN (label))),
(GtkCallback) colorful_tabs_modify_fg,
NULL);
g_signal_handlers_disconnect_by_func (
view, colorful_tabs_view_notify_uri_cb, extension);
}
}
void make_cancel_button(GtkWidget *fixed_base)
{
GtkWidget *fixed;
GtkWidget *event_box;
GtkWidget *label;
fixed = fixed_base;
label = gtk_label_new(cancel_text);
gtk_widget_set_size_request(label, cancel_label_width, cancel_label_height);
gtk_widget_show(label);
GdkColor white = {0, 65535, 65535, 65535};
GtkRcStyle *rc_style = gtk_rc_style_new ();
rc_style->fg[GTK_STATE_NORMAL] = white;
rc_style->color_flags[GTK_STATE_NORMAL] |= GTK_RC_FG;
gtk_widget_modify_style(label, rc_style);
gtk_rc_style_unref(rc_style);
event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), label);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
gtk_widget_show(event_box);
g_signal_connect(G_OBJECT(event_box), "enter_notify_event",
G_CALLBACK(cancel_enter), NULL);
g_signal_connect(G_OBJECT(event_box), "leave_notify_event",
G_CALLBACK(cancel_leave), NULL);
g_signal_connect(G_OBJECT(event_box), "button_press_event",
G_CALLBACK(cancel_press), NULL);
gtk_widget_show(event_box);
gtk_fixed_put(GTK_FIXED(fixed), event_box, cancel_label_pos_x, cancel_label_pos_y);
}
void tabmanagergui_create_label (GuTabPage* tp, gchar* labeltext) {
static unsigned count = 0;
GtkRcStyle* rcstyle = NULL;
GtkWidget* image = NULL;
GtkHBox* hbox;
tp->labelbox = gtk_event_box_new ();
hbox = GTK_HBOX (gtk_hbox_new (FALSE, 0));
tp->unsavednr = ++count;
gtk_event_box_set_visible_window (GTK_EVENT_BOX (tp->labelbox), FALSE);
gtk_container_add (GTK_CONTAINER(tp->labelbox), GTK_WIDGET (hbox));
tp->label = GTK_LABEL (gtk_label_new (labeltext));
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (tp->label), TRUE, TRUE, 5);
tp->button = GTK_BUTTON (gtk_button_new());
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_button_set_image (tp->button, image);
g_object_set (tp->button, "relief", GTK_RELIEF_NONE,
"focus-on-click", FALSE, NULL);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (tp->button), FALSE,FALSE,0);
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style (GTK_WIDGET (tp->button), rcstyle);
g_object_unref (rcstyle);
gtk_widget_show_all (GTK_WIDGET (hbox));
}
static void
gimp_color_bar_init (GimpColorBar *bar)
{
gtk_event_box_set_visible_window (GTK_EVENT_BOX (bar), FALSE);
bar->orientation = GTK_ORIENTATION_HORIZONTAL;
}
void ui_playlist_notebook_create_tab(gint playlist)
{
GtkWidget *scrollwin, *treeview;
GtkWidget *label, *entry, *ebox, *hbox;
GtkAdjustment *vscroll;
gint position = aud_playlist_get_position (playlist);
scrollwin = gtk_scrolled_window_new(NULL, NULL);
vscroll = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrollwin));
treeview = ui_playlist_widget_new(playlist);
g_object_set_data(G_OBJECT(scrollwin), "treeview", treeview);
gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_show_all(scrollwin);
ebox = gtk_event_box_new();
gtk_event_box_set_visible_window ((GtkEventBox *) ebox, FALSE);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
label = gtk_label_new ("");
set_tab_label (playlist, (GtkLabel *) label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(ebox), hbox);
gtk_widget_show_all(ebox);
gtk_widget_hide(entry);
gtk_box_pack_end ((GtkBox *) hbox, make_close_button (playlist), FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(ebox), "label", label);
g_object_set_data(G_OBJECT(ebox), "entry", entry);
g_object_set_data(G_OBJECT(ebox), "page", scrollwin);
gtk_notebook_insert_page (UI_PLAYLIST_NOTEBOOK, scrollwin, ebox, playlist);
gtk_notebook_set_tab_reorderable(UI_PLAYLIST_NOTEBOOK, scrollwin, TRUE);
g_object_set_data ((GObject *) treeview, "playlist-id",
GINT_TO_POINTER (aud_playlist_get_unique_id (playlist)));
if (position >= 0)
{
aud_playlist_select_all (playlist, FALSE);
aud_playlist_entry_set_selected (playlist, position, TRUE);
audgui_list_set_highlight (treeview, position);
audgui_list_set_focus (treeview, position);
}
g_signal_connect(ebox, "button-press-event", G_CALLBACK(tab_button_press_cb), NULL);
g_signal_connect(ebox, "key-press-event", G_CALLBACK(tab_key_press_cb), NULL);
g_signal_connect(entry, "activate", G_CALLBACK(tab_title_save), ebox);
g_signal_connect_swapped (vscroll, "value-changed",
G_CALLBACK(ui_playlist_widget_scroll), treeview);
}
// Public functions
GtkWidget *dtgtk_icon_new(DTGTKCairoPaintIconFunc paint, gint paintflags)
{
GtkDarktableIcon *icon;
icon = g_object_new(dtgtk_icon_get_type(), NULL);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(icon), FALSE);
icon->icon = paint;
icon->icon_flags = paintflags;
return (GtkWidget *)icon;
}
static WindowckPlugin * windowck_new(XfcePanelPlugin *plugin)
{
WindowckPlugin *wckp;
GtkOrientation orientation;
GtkWidget *label;
/* allocate memory for the plugin structure */
wckp = g_slice_new0 (WindowckPlugin);
/* pointer to plugin */
wckp->plugin = plugin;
/* read the user settings */
windowck_read(wckp);
/* get the current orientation */
orientation = xfce_panel_plugin_get_orientation(plugin);
/* not needed for shrink mode */
if (!wckp->prefs->size_mode == SHRINK)
xfce_panel_plugin_set_shrink (plugin, TRUE);
/* create some panel widgets */
wckp->ebox = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(wckp->ebox), FALSE);
gtk_widget_set_name(wckp->ebox, "XfceWindowckPlugin");
wckp->alignment = gtk_alignment_new (0.5, 0.5, 0, 0);
wckp->hvbox = xfce_hvbox_new(orientation, FALSE, 2);
/* some wckp widgets */
label = gtk_label_new("");
wckp->title = GTK_LABEL (label);
create_icon (wckp);
gtk_box_pack_start (GTK_BOX(wckp->hvbox), label, TRUE, TRUE, 0);
if (wckp->prefs->icon_on_right)
{
gtk_box_reorder_child (GTK_BOX (wckp->hvbox), GTK_WIDGET(wckp->icon->eventbox), 1);
}
gtk_container_add(GTK_CONTAINER(wckp->alignment), GTK_WIDGET(wckp->hvbox));
gtk_container_add(GTK_CONTAINER(wckp->ebox), wckp->alignment);
/* show widgets */
gtk_widget_show(wckp->ebox);
gtk_widget_show(wckp->alignment);
gtk_widget_show(wckp->hvbox);
gtk_widget_show(label);
return wckp;
}
// Public functions
GtkWidget *dtgtk_icon_new(DTGTKCairoPaintIconFunc paint, gint paintflags, void *paintdata)
{
GtkDarktableIcon *icon;
icon = g_object_new(dtgtk_icon_get_type(), NULL);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(icon), FALSE);
icon->icon = paint;
icon->icon_flags = paintflags;
icon->icon_data = paintdata;
gtk_widget_set_name(GTK_WIDGET(icon), "dt-icon");
return (GtkWidget *)icon;
}
void create_tray_icon(struct _tray_icon *tray, gboolean runned)
{
gchar *hint;
char *image_file;
if (runned == TRUE)
{
hint = _("X Neural Switcher RUNNED");
image_file = "gxneur-run.png";
}
else
{
hint = _("X Neural Switcher STOPPED");
image_file = "gxneur-stop.png";
}
if (tray != NULL)
{
gtk_object_destroy (GTK_OBJECT (tray->tooltip));
tray->tooltip = NULL;
gtk_widget_destroy (GTK_WIDGET (tray->popup_menu));
tray->popup_menu = NULL;
gtk_widget_destroy (GTK_WIDGET (tray->image));
tray->image = NULL;
gtk_widget_destroy (GTK_WIDGET (tray->evbox));
tray->evbox = NULL;
}
else
{
tray = g_new0(struct _tray_icon, 1);
tray->clock = egg_clock_new();
g_signal_connect (G_OBJECT(tray->clock), "time-changed", G_CALLBACK (clock_check_xneur), tray);
tray->eggtray = egg_tray_icon_new(_("X Neural Switcher"));
g_signal_connect(G_OBJECT(tray->eggtray), "button_press_event", G_CALLBACK(tray_icon_press), tray);
g_signal_connect(G_OBJECT(tray->eggtray), "button_release_event", G_CALLBACK(tray_icon_release), tray);
}
tray->tooltip = gtk_tooltips_new();
tray->popup_menu = create_menu_icon(tray);
tray->evbox = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(tray->evbox), 0);
gtk_widget_set_size_request(tray->evbox, 25, 20);
gtk_tooltips_set_tip(tray->tooltip, GTK_WIDGET(tray->eggtray), hint, NULL);
tray->image = create_pixmap(tray->evbox, image_file);
gtk_container_add(GTK_CONTAINER(tray->evbox), tray->image);
gtk_container_add(GTK_CONTAINER(tray->eggtray), tray->evbox);
gtk_widget_show_all (GTK_WIDGET (tray->eggtray));
return;
}
static void
nemo_location_bar_init (NemoLocationBar *bar)
{
GtkWidget *entry;
GtkWidget *event_box;
bar->details = G_TYPE_INSTANCE_GET_PRIVATE (bar, NEMO_TYPE_LOCATION_BAR,
NemoLocationBarDetails);
gtk_orientable_set_orientation (GTK_ORIENTABLE (bar),
GTK_ORIENTATION_HORIZONTAL);
event_box = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (event_box), 2);
entry = nemo_location_entry_new ();
g_signal_connect_object (entry, "activate",
G_CALLBACK (editable_activate_callback), bar, G_CONNECT_AFTER);
g_signal_connect_object (entry, "changed",
G_CALLBACK (editable_changed_callback), bar, 0);
gtk_container_add (GTK_CONTAINER (event_box), entry);
gtk_box_pack_start (GTK_BOX (bar), event_box, TRUE, TRUE, 4);
/* Label context menu */
g_signal_connect (event_box, "button-press-event",
G_CALLBACK (button_pressed_callback), NULL);
/* Drag source */
gtk_drag_source_set (GTK_WIDGET (event_box),
GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
drag_types, G_N_ELEMENTS (drag_types),
GDK_ACTION_COPY | GDK_ACTION_LINK);
g_signal_connect_object (event_box, "drag_data_get",
G_CALLBACK (drag_data_get_callback), bar, 0);
/* Drag dest. */
gtk_drag_dest_set (GTK_WIDGET (bar),
GTK_DEST_DEFAULT_ALL,
drop_types, G_N_ELEMENTS (drop_types),
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect (bar, "drag_data_received",
G_CALLBACK (drag_data_received_callback), NULL);
bar->details->entry = NEMO_ENTRY (entry);
gtk_widget_show_all (GTK_WIDGET (bar));
}
static GtkWidget *
_gtk_text_handle_ensure_widget (GtkTextHandle *handle,
GtkTextHandlePosition pos)
{
GtkTextHandlePrivate *priv;
priv = handle->priv;
if (!priv->windows[pos].widget)
{
GtkWidget *widget, *window;
GtkStyleContext *context;
widget = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (widget), TRUE);
gtk_widget_set_events (widget,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_POINTER_MOTION_MASK);
gtk_widget_set_direction (widget, priv->windows[pos].dir);
g_signal_connect (widget, "draw",
G_CALLBACK (gtk_text_handle_widget_draw), handle);
g_signal_connect (widget, "event",
G_CALLBACK (gtk_text_handle_widget_event), handle);
g_signal_connect (widget, "style-updated",
G_CALLBACK (gtk_text_handle_widget_style_updated),
handle);
priv->windows[pos].widget = g_object_ref_sink (widget);
window = gtk_widget_get_ancestor (priv->parent, GTK_TYPE_WINDOW);
_gtk_window_add_popover (GTK_WINDOW (window), widget, priv->parent, FALSE);
context = gtk_widget_get_style_context (widget);
gtk_style_context_set_parent (context, gtk_widget_get_style_context (priv->parent));
gtk_css_node_set_name (gtk_widget_get_css_node (widget), I_("cursor-handle"));
if (pos == GTK_TEXT_HANDLE_POSITION_SELECTION_END)
{
gtk_style_context_add_class (context, GTK_STYLE_CLASS_BOTTOM);
if (priv->mode == GTK_TEXT_HANDLE_MODE_CURSOR)
gtk_style_context_add_class (context, GTK_STYLE_CLASS_INSERTION_CURSOR);
}
else
gtk_style_context_add_class (context, GTK_STYLE_CLASS_TOP);
}
return priv->windows[pos].widget;
}
static void create_icon (WindowckPlugin *wckp)
{
wckp->icon = g_slice_new0 (WindowIcon);
wckp->icon->eventbox = GTK_EVENT_BOX (gtk_event_box_new());
wckp->icon->symbol = NULL;
gtk_widget_set_can_focus (GTK_WIDGET(wckp->icon->eventbox), TRUE);
gtk_event_box_set_visible_window (wckp->icon->eventbox, FALSE);
gtk_box_pack_start (GTK_BOX (wckp->hvbox), GTK_WIDGET(wckp->icon->eventbox), FALSE, FALSE, 0);
create_symbol (wckp);
}
static void create_char(int index)
{
int i;
// dbg("create_char %d\n", index);
if (!hbox_edit) {
dbg("create_char: !hbox_edit\n");
return;
}
GdkColor fg;
gdk_color_parse(gcin_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_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, gcin_font_size);
chars[i].label = label;
if (gcin_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);
}
}
void phoneBookEntry_init(PhoneBookEntry *pbe) {
phoneBookEntryPrivate *priv = PHONE_BOOK_ENTRY_GET_PRIVATE(pbe);
GtkWidget *event_box = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), TRUE);
gtk_widget_add_events(event_box, GDK_FOCUS_CHANGE_MASK);
g_signal_connect(G_OBJECT(event_box), "focus", G_CALLBACK(focus_me), NULL);
GtkWidget *vbox = gtk_vbox_new(FALSE, 2);
priv->name = gtk_label_new("");
priv->number = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(vbox), priv->name, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), priv->number, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(event_box), vbox);
gtk_container_add(GTK_CONTAINER(pbe), event_box);
}
static void
gimp_handle_bar_init (GimpHandleBar *bar)
{
gtk_widget_add_events (GTK_WIDGET (bar),
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK);
gtk_event_box_set_visible_window (GTK_EVENT_BOX (bar), FALSE);
bar->orientation = GTK_ORIENTATION_HORIZONTAL;
bar->lower = 0.0;
bar->upper = 1.0;
}
static void
colorful_tabs_view_notify_uri_cb (MidoriView* view,
GParamSpec* pspec,
MidoriExtension* extension)
{
GtkWidget* label;
SoupURI* uri;
gchar* hash;
gchar* colorstr;
GdkColor color;
label = midori_view_get_proxy_tab_label (view);
if (!midori_extension_get_boolean (extension, "tint"))
{
gtk_widget_modify_bg (label, GTK_STATE_NORMAL, NULL);
gtk_widget_modify_bg (label, GTK_STATE_ACTIVE, NULL);
return;
}
/* Find a color that is unique to an address. We merely compute
a hash value, pick the first 6 + 1 characters and turn the
first into a hash sign, ie. #8b424b. In case a color is too
dark, we lighten it up a litte. Finally we make the event box
visible and modify its background. */
if ((uri = soup_uri_new (midori_view_get_display_uri (view))) && uri->host)
{
hash = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri->host, -1);
soup_uri_free (uri);
colorstr = g_strndup (hash, 6 + 1);
g_free (hash);
colorstr[0] = '#';
gdk_color_parse (colorstr, &color);
if (color.red < 35000)
color.red += 25000 + (color.blue + 1) / 2;
if (color.green < 35000)
color.green += 25000 + (color.red + 1) / 2;
if (color.blue < 35000)
color.blue += 25000 + (color.green + 1) / 2;
gtk_event_box_set_visible_window (GTK_EVENT_BOX (label), TRUE);
gtk_widget_modify_bg (label, GTK_STATE_NORMAL, &color);
gtk_widget_modify_bg (label, GTK_STATE_ACTIVE, &color);
}
else
{
gtk_widget_modify_bg (label, GTK_STATE_NORMAL, NULL);
gtk_widget_modify_bg (label, GTK_STATE_ACTIVE, NULL);
}
}
GtkWidget *make_item(gint index)
{
GtkWidget *fixed_item;
GtkWidget *event_box;
GtkWidget *image;
GtkWidget *label;
const gchar *img_file;
GdkColor color1;
gdk_color_parse ("white", &color1);
fixed_item = gtk_fixed_new();
img_file = item_normal_imgs[index];
image = gtk_image_new_from_file(img_file);
gtk_widget_show(image);
const gchar *text = item_labels[index];
label = gtk_label_new(text);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_widget_set_size_request(label, label_width, label_height);
ITEM_IMG *item_img = (ITEM_IMG *)malloc(sizeof(ITEM_IMG));
item_img->image = image;
item_img->index = index;
item_list = g_list_append(item_list, (gpointer)item_img);
event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), image);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
gtk_widget_show(event_box);
g_signal_connect(G_OBJECT(event_box), "enter_notify_event",
G_CALLBACK(item_enter), (gpointer)item_img);
g_signal_connect(G_OBJECT(event_box), "leave_notify_event",
G_CALLBACK(item_leave), (gpointer)item_img);
g_signal_connect(G_OBJECT(event_box), "button_press_event",
G_CALLBACK(item_press), (gpointer)item_img);
gtk_fixed_put(GTK_FIXED(fixed_item), event_box, 0, 0);
gtk_widget_set_size_request(label, 110, 40);
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &color1);
gtk_fixed_put(GTK_FIXED(fixed_item), label, 0, label_pos_y);
gtk_widget_show_all(fixed_item);
return fixed_item;
}
CCMCellExtension *
ccm_cell_extension_new (const gchar * path, int width)
{
g_return_val_if_fail (path != NULL, NULL);
CCMCellExtension *self = g_object_new (CCM_TYPE_CELL_EXTENSION, NULL);
GtkWidget *vbox, *hbox, *button;
self->priv->path = g_strdup (path);
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (self), vbox);
// Name/description label
self->priv->name = gtk_label_new ("\n");
gtk_widget_set_size_request (self->priv->name, width - 4, -1);
gtk_label_set_use_markup (GTK_LABEL (self->priv->name), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (self->priv->name), TRUE);
gtk_widget_show (self->priv->name);
gtk_box_pack_start (GTK_BOX (vbox), self->priv->name, TRUE, TRUE, 0);
// Add activation line
hbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
self->priv->author = gtk_label_new ("");
gtk_label_set_use_markup (GTK_LABEL (self->priv->author), TRUE);
gtk_widget_show (self->priv->author);
gtk_box_pack_start (GTK_BOX (hbox), self->priv->author, TRUE, TRUE, 0);
self->priv->enable = gtk_label_new ("");
gtk_label_set_use_markup (GTK_LABEL (self->priv->enable), TRUE);
gtk_label_set_markup (GTK_LABEL (self->priv->enable), "<span size='small'>Enable</span>");
gtk_widget_show (self->priv->enable);
button = gtk_button_new ();
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (button), self->priv->enable);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_event_box_set_above_child (GTK_EVENT_BOX (self), FALSE);
gtk_event_box_set_visible_window (GTK_EVENT_BOX (self), FALSE);
return self;
}
static GtkWidget *
editor_create_item (EggToolbarEditor *editor,
GtkImage *icon,
const char *label_text,
GdkDragAction action)
{
GtkWidget *event_box;
GtkWidget *vbox;
GtkWidget *label;
gchar *label_no_mnemonic = NULL;
event_box = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
gtk_widget_show (event_box);
gtk_drag_source_set (event_box,
GDK_BUTTON1_MASK,
source_drag_types, n_source_drag_types, action);
g_signal_connect (event_box, "drag_data_get",
G_CALLBACK (drag_data_get_cb), editor);
g_signal_connect (event_box, "drag_data_delete",
G_CALLBACK (editor_drag_data_delete_cb), editor);
g_signal_connect_after (event_box, "realize",
G_CALLBACK (event_box_realize_cb), icon);
if (action == GDK_ACTION_MOVE)
{
g_signal_connect (event_box, "drag_begin",
G_CALLBACK (drag_begin_cb), NULL);
g_signal_connect (event_box, "drag_end",
G_CALLBACK (drag_end_cb), NULL);
}
vbox = gtk_vbox_new (0, FALSE);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (event_box), vbox);
gtk_widget_show (GTK_WIDGET (icon));
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (icon), FALSE, TRUE, 0);
label_no_mnemonic = elide_underscores (label_text);
label = gtk_label_new (label_no_mnemonic);
g_free (label_no_mnemonic);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
return event_box;
}
/* {EV_NOTEBOOK_IMP}.ensure_tab_label */
void F1106_14788 (EIF_REFERENCE Current, EIF_POINTER arg1)
{
GTCX
EIF_POINTER loc1 = (EIF_POINTER) 0;
EIF_POINTER loc2 = (EIF_POINTER) 0;
EIF_POINTER loc3 = (EIF_POINTER) 0;
EIF_POINTER loc4 = (EIF_POINTER) 0;
EIF_POINTER tp1;
EIF_POINTER tp2;
RTLD;
RTLI(1);
RTLR(0,Current);
RTGC;
tp1 = F1079_14146(Current);
{
/* INLINED CODE (default_pointer) */
tp2 = (EIF_POINTER) 0;
/* END INLINED CODE */
}
if ((EIF_BOOLEAN)((EIF_POINTER) gtk_notebook_get_tab_label((GtkNotebook*) tp1, (GtkWidget*) arg1) == tp2)) {
loc1 = (EIF_POINTER) gtk_event_box_new();
gtk_event_box_set_visible_window((GtkEventBox*) loc1, (gboolean) (EIF_BOOLEAN) 0);
gtk_widget_show((GtkWidget*) loc1);
loc2 = (EIF_POINTER) gtk_hbox_new((gboolean) (EIF_BOOLEAN) 0, (gint) ((EIF_INTEGER_32) 2L));
gtk_container_add((GtkContainer*) loc1, (GtkWidget*) loc2);
gtk_widget_show((GtkWidget*) loc2);
loc3 = (EIF_POINTER) gtk_image_new();
gtk_widget_show((GtkWidget*) loc3);
gtk_container_add((GtkContainer*) loc2, (GtkWidget*) loc3);
{
/* INLINED CODE (default_pointer) */
tp1 = (EIF_POINTER) 0;
/* END INLINED CODE */
}
tp2 = tp1;
loc4 = (EIF_POINTER) gtk_label_new((gchar*) tp2);
gtk_widget_show((GtkWidget*) loc4);
gtk_container_add((GtkContainer*) loc2, (GtkWidget*) loc4);
tp1 = F1079_14146(Current);
gtk_notebook_set_tab_label((GtkNotebook*) tp1, (GtkWidget*) arg1, (GtkWidget*) loc1);
}
RTLE;
}
G_MODULE_EXPORT GtkWidget *
mb_panel_applet_create (const char *id, GtkOrientation orientation)
{
GtkWidget *box, *image;
box = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (box), FALSE);
gtk_event_box_set_above_child (GTK_EVENT_BOX (box), TRUE);
gtk_widget_set_name (box, "MatchboxPanelKeyboard");
image = mb_panel_scaling_image2_new (orientation, "matchbox-keyboard");
gtk_container_add (GTK_CONTAINER (box), image);
g_signal_connect (box, "button-release-event", G_CALLBACK (on_toggled), NULL);
gtk_widget_show_all (box);
return box;
}
static void
setup_dnd (TTXWindow *self, GtkWidget *ebox)
{
GtkTargetEntry entries[] = {
{ "text/uri-list", 0, 1 },
{ "application/x-rootwindow-drop", 0, 2 }
};
/* note: without this, D&D does not work; see the Gtk docs */
gtk_event_box_set_visible_window (GTK_EVENT_BOX(ebox),
FALSE);
/* setup drag & drop */
gtk_drag_source_set (ebox, GDK_BUTTON1_MASK,
entries, G_N_ELEMENTS(entries),
GDK_ACTION_COPY);
g_signal_connect (G_OBJECT(ebox), "drag-data-get",
G_CALLBACK(on_drag_data_get), self);
}
static GObject * fadable_box_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
GObject * obj;
GObjectClass * parent_class;
FadableBox * self;
FadeTracker* _tmp0_;
FadeTracker* _tmp1_;
FadeTracker* _tmp2_;
FadeTracker* _tmp3_;
parent_class = G_OBJECT_CLASS (fadable_box_parent_class);
obj = parent_class->constructor (type, n_construct_properties, construct_properties);
self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FADABLE_BOX, FadableBox);
gtk_event_box_set_visible_window ((GtkEventBox*) self, FALSE);
_tmp0_ = fade_tracker_new ((GtkWidget*) self);
_tmp1_ = _tmp0_;
fadable_set_fade_tracker ((Fadable*) self, _tmp1_);
_g_object_unref0 (_tmp1_);
_tmp2_ = fadable_get_fade_tracker ((Fadable*) self);
_tmp3_ = _tmp2_;
g_signal_connect_object (_tmp3_, "done", (GCallback) __fadable_box___lambda5__fade_tracker_done, self, 0);
return obj;
}
static void
gstyle_slidein_init (GstyleSlidein *self)
{
GtkStyleContext *context;
g_signal_connect_swapped (self,
"key-press-event",
G_CALLBACK (gstyle_slidein_event_box_key_pressed_cb),
self);
gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
gtk_event_box_set_visible_window (GTK_EVENT_BOX (self), FALSE);
gtk_event_box_set_above_child (GTK_EVENT_BOX (self), FALSE);
context = gtk_widget_get_style_context (GTK_WIDGET (self));
self->default_provider = gstyle_css_provider_init_default (gtk_style_context_get_screen (context));
self->direction_type = GSTYLE_SLIDEIN_DIRECTION_TYPE_RIGHT;
self->direction_type_reverse = GSTYLE_SLIDEIN_DIRECTION_TYPE_LEFT;
self->duration = 0.0;
self->duration_set = TRUE;
}
static PowerManagerPlugin *
power_manager_plugin_new (XfcePanelPlugin *plugin)
{
PowerManagerPlugin *power_manager_plugin;
/* allocate memory for the plugin structure */
power_manager_plugin = panel_slice_new0 (PowerManagerPlugin);
/* pointer to plugin */
power_manager_plugin->plugin = plugin;
/* create some panel ebox */
power_manager_plugin->ebox = gtk_event_box_new ();
gtk_widget_show (power_manager_plugin->ebox);
gtk_event_box_set_visible_window (GTK_EVENT_BOX(power_manager_plugin->ebox), FALSE);
power_manager_plugin->power_manager_button = power_manager_button_new (plugin);
power_manager_button_show(POWER_MANAGER_BUTTON(power_manager_plugin->power_manager_button));
gtk_container_add (GTK_CONTAINER (power_manager_plugin->ebox), power_manager_plugin->power_manager_button);
return power_manager_plugin;
}
