decor_frame_t *
decor_frame_new (const gchar *type)
{
GdkScreen *gdkscreen = gdk_screen_get_default ();
GdkVisual *visual;
decor_frame_t *frame = malloc (sizeof (decor_frame_t));
if (!frame)
{
g_critical ("Couldn't allocate frame!");
return NULL;
}
frame->type = strdup (type);
frame->refcount = 0;
frame->titlebar_height = 17;
frame->max_titlebar_height = 17;
frame->border_shadow_active = NULL;
frame->border_shadow_inactive = NULL;
frame->border_no_shadow = NULL;
frame->max_border_no_shadow = NULL;
frame->max_border_shadow_active = NULL;
frame->max_border_shadow_inactive = NULL;
frame->titlebar_font = NULL;
frame->style_window_rgba = gtk_window_new (GTK_WINDOW_POPUP);
visual = gdk_screen_get_rgba_visual (gdkscreen);
if (visual)
gtk_widget_set_visual (frame->style_window_rgba, visual);
gtk_widget_realize (frame->style_window_rgba);
gtk_widget_set_size_request (frame->style_window_rgba, 0, 0);
gtk_window_move (GTK_WINDOW (frame->style_window_rgba), -100, -100);
frame->pango_context = gtk_widget_create_pango_context (frame->style_window_rgba);
g_signal_connect_data (frame->style_window_rgba, "style-updated",
G_CALLBACK (style_updated),
(gpointer) frame->pango_context, 0, 0);
frame->style_window_rgb = gtk_window_new (GTK_WINDOW_POPUP);
visual = gdk_screen_get_system_visual (gdkscreen);
if (visual)
gtk_widget_set_visual (frame->style_window_rgb, visual);
gtk_widget_realize (frame->style_window_rgb);
gtk_widget_set_size_request (frame->style_window_rgb, 0, 0);
gtk_window_move (GTK_WINDOW (frame->style_window_rgb), -100, -100);
g_signal_connect_data (frame->style_window_rgb, "style-updated",
G_CALLBACK (style_updated),
(gpointer) frame->pango_context, 0, 0);
return frame;
}
static gboolean
parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void* data)
{
wxGLCanvas* win = (wxGLCanvas*)data;
if (g_value_peek_pointer(¶m_values[0]) == win->m_wxwindow)
{
const XVisualInfo* xvi = win->GetXVisualInfo();
GdkVisual* visual = gtk_widget_get_visual(win->m_wxwindow);
if (GDK_VISUAL_XVISUAL(visual)->visualid != xvi->visualid)
{
GdkScreen* screen = gtk_widget_get_screen(win->m_wxwindow);
visual = gdk_x11_screen_lookup_visual(screen, xvi->visualid);
#ifdef __WXGTK3__
gtk_widget_set_visual(win->m_wxwindow, visual);
#else
GdkColormap* colormap = gdk_colormap_new(visual, false);
gtk_widget_set_colormap(win->m_wxwindow, colormap);
g_object_unref(colormap);
#endif
}
// remove hook
return false;
}
return true;
}
static void
create_window (int width,
int height,
gboolean alpha,
gboolean maximized)
{
WindowInfo *info;
info = g_new0 (WindowInfo, 1);
info->width = width;
info->height = height;
info->alpha = alpha;
info->maximized = maximized;
info->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (alpha)
gtk_widget_set_visual (info->window, gdk_screen_get_rgba_visual (gdk_screen_get_default ()));
if (maximized)
gtk_window_maximize (GTK_WINDOW (info->window));
info->pending = TRUE;
gtk_widget_set_size_request (info->window, width, height);
gtk_widget_set_app_paintable (info->window, TRUE);
g_signal_connect (info->window, "map-event", G_CALLBACK (on_window_map_event), info);
g_signal_connect (info->window, "draw", G_CALLBACK (on_window_draw), info);
gtk_widget_show (info->window);
our_windows = g_list_prepend (our_windows, info);
}
static void
realize (GtkWidget *widget)
{
NemoDesktopWindow *window;
NemoDesktopWindowDetails *details;
GdkVisual *visual;
window = NEMO_DESKTOP_WINDOW (widget);
details = window->details;
/* Make sure we get keyboard events */
gtk_widget_set_events (widget, gtk_widget_get_events (widget)
| GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
visual = gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget));
if (visual) {
gtk_widget_set_visual (widget, visual);
}
/* Do the work of realizing. */
GTK_WIDGET_CLASS (nemo_desktop_window_parent_class)->realize (widget);
/* This is the new way to set up the desktop window */
set_wmspec_desktop_hint (gtk_widget_get_window (widget));
set_desktop_window_id (window, gtk_widget_get_window (widget));
details->size_changed_id =
g_signal_connect (gtk_window_get_screen (GTK_WINDOW (window)), "size_changed",
G_CALLBACK (nemo_desktop_window_screen_size_changed), window);
}
static void
ensure_size_window (MetaResizePopup *popup)
{
GdkVisual *visual;
GdkScreen *screen;
if (popup->size_window)
return;
popup->size_window = gtk_window_new (GTK_WINDOW_POPUP);
screen = gdk_display_get_screen (gdk_x11_lookup_xdisplay (popup->display),
popup->screen_number);
visual = gdk_screen_get_rgba_visual (screen);
gtk_window_set_screen (GTK_WINDOW (popup->size_window), screen);
if (visual != NULL)
gtk_widget_set_visual (popup->size_window, visual);
gtk_window_set_type_hint (GTK_WINDOW (popup->size_window),
GDK_WINDOW_TYPE_HINT_TOOLTIP);
gtk_window_set_resizable (GTK_WINDOW (popup->size_window), FALSE);
gtk_widget_set_app_paintable (popup->size_window, TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (popup->size_window),
GTK_STYLE_CLASS_TOOLTIP);
g_signal_connect (popup->size_window, "draw",
G_CALLBACK (size_window_draw), popup);
popup->size_label = gtk_label_new ("");
g_object_set (popup->size_label, "margin", 6, NULL);
gtk_container_add (GTK_CONTAINER (popup->size_window), popup->size_label);
gtk_widget_show (popup->size_label);
}
static GtkWidget *
create_select_window (void)
{
GtkWidget *window;
GdkScreen *screen;
GdkVisual *visual;
screen = gdk_screen_get_default ();
visual = gdk_screen_get_rgba_visual (screen);
window = gtk_window_new (GTK_WINDOW_POPUP);
if (gdk_screen_is_composited (screen) && visual)
{
gtk_widget_set_visual (window, visual);
gtk_widget_set_app_paintable (window, TRUE);
}
g_signal_connect (window, "draw", G_CALLBACK (select_window_draw), NULL);
gtk_window_move (GTK_WINDOW (window), -100, -100);
gtk_window_resize (GTK_WINDOW (window), 10, 10);
gtk_widget_show (window);
return window;
}
static void
msd_osd_window_real_realize (GtkWidget *widget)
{
GdkScreen *screen;
GdkVisual *visual;
cairo_region_t *region;
screen = gtk_widget_get_screen (widget);
visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL) {
visual = gdk_screen_get_system_visual (screen);
}
gtk_widget_set_visual (widget, visual);
if (GTK_WIDGET_CLASS (msd_osd_window_parent_class)->realize) {
GTK_WIDGET_CLASS (msd_osd_window_parent_class)->realize (widget);
}
/* make the whole window ignore events */
region = cairo_region_create ();
gtk_widget_input_shape_combine_region (widget, region);
cairo_region_destroy (region);
}
void
gtk_gl_enable (GtkWidget *widget)
{
GdkScreen *screen;
GdkVisual *visual;
Display *xdisplay;
XVisualInfo *xvi;
gint xscreen;
GtkGLContext *gtkgc;
gint attributes[] ={GLX_RGBA,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_DEPTH_SIZE,24,
GLX_DOUBLEBUFFER,
None};
gtk_widget_set_app_paintable (widget, TRUE);
gtk_widget_set_double_buffered (widget, FALSE);
gtkgc = g_slice_new0 (GtkGLContext);
xdisplay = gdk_x11_get_default_xdisplay ();
xscreen = gdk_x11_get_default_screen ();
g_return_if_fail (NULL != (xvi = glXChooseVisual (xdisplay, xscreen, attributes)));
screen = gtk_widget_get_screen (widget);
g_return_if_fail (NULL != (visual = gdk_x11_screen_lookup_visual (screen, xvi->visualid)));
gtk_widget_set_visual (widget, visual);
gtkgc->widget = widget;
g_return_if_fail (NULL != (gtkgc->context = glXCreateContext (xdisplay, xvi, NULL, GL_TRUE)));
gtk_glx_context_list = g_slist_prepend (gtk_glx_context_list, gtkgc);
}
bool C4Window::ReInit(C4AbstractApp* pApp)
{
// Check whether multisampling settings was changed. If not then we
// don't need to ReInit anything.
#ifdef GDK_WINDOWING_X11
int value;
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
glXGetFBConfigAttrib(dpy, Info, GLX_SAMPLES, &value);
if(value == Config.Graphics.MultiSampling) return true;
// Check whether we have a visual with the requested number of samples
GLXFBConfig new_info;
if(!FindFBConfig(Config.Graphics.MultiSampling, &new_info)) return false;
GdkScreen * scr = gtk_widget_get_screen(GTK_WIDGET(render_widget));
XVisualInfo *vis_info = glXGetVisualFromFBConfig(dpy, new_info);
assert(vis_info);
GdkVisual * vis = gdk_x11_screen_lookup_visual(scr, vis_info->visualid);
XFree(vis_info);
// Un- and re-realizing the render_widget does not work, the window
// remains hidden afterwards. So we re-create it from scratch.
gtk_widget_destroy(GTK_WIDGET(render_widget));
render_widget = gtk_drawing_area_new();
#if !GTK_CHECK_VERSION(3,10,0)
gtk_widget_set_double_buffered (GTK_WIDGET(render_widget), false);
#endif
g_object_set(G_OBJECT(render_widget), "can-focus", TRUE, NULL);
gtk_widget_set_visual(GTK_WIDGET(render_widget),vis);
Info = new_info;
// Wait until window is mapped to get the window's XID
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(render_widget));
gtk_widget_show_now(GTK_WIDGET(render_widget));
if (GTK_IS_LAYOUT(render_widget))
{
GdkWindow* bin_wnd = gtk_layout_get_bin_window(GTK_LAYOUT(render_widget));
renderwnd = GDK_WINDOW_XID(bin_wnd);
}
else
{
GdkWindow* render_wnd = gtk_widget_get_window(GTK_WIDGET(render_widget));
renderwnd = GDK_WINDOW_XID(render_wnd);
}
gdk_flush();
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(render_widget)),
gdk_cursor_new_for_display(gdk_display_get_default(), GDK_BLANK_CURSOR));
return true;
#endif
}
GtkWidget *
na_tray_child_new (GdkScreen *screen,
Window icon_window)
{
XWindowAttributes window_attributes;
Display *xdisplay;
NaTrayChild *child;
GdkVisual *visual;
gboolean visual_has_alpha;
int red_prec, green_prec, blue_prec, depth;
int result;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (icon_window != None, NULL);
xdisplay = GDK_SCREEN_XDISPLAY (screen);
/* We need to determine the visual of the window we are embedding and create
* the socket in the same visual.
*/
gdk_error_trap_push ();
result = XGetWindowAttributes (xdisplay, icon_window,
&window_attributes);
gdk_error_trap_pop_ignored ();
if (!result) /* Window already gone */
return NULL;
visual = gdk_x11_screen_lookup_visual (screen,
window_attributes.visual->visualid);
if (!visual) /* Icon window is on another screen? */
return NULL;
child = g_object_new (NA_TYPE_TRAY_CHILD, NULL);
child->icon_window = icon_window;
gtk_widget_set_visual (GTK_WIDGET (child), visual);
/* We have alpha if the visual has something other than red, green,
* and blue */
gdk_visual_get_red_pixel_details (visual, NULL, NULL, &red_prec);
gdk_visual_get_green_pixel_details (visual, NULL, NULL, &green_prec);
gdk_visual_get_blue_pixel_details (visual, NULL, NULL, &blue_prec);
depth = gdk_visual_get_depth (visual);
visual_has_alpha = red_prec + blue_prec + green_prec < depth;
child->has_alpha = (visual_has_alpha &&
gdk_display_supports_composite (gdk_screen_get_display (screen)));
child->composited = child->has_alpha;
return GTK_WIDGET (child);
}
static void set_colormap(GtkWidget *window)
{
/*Set RGBA visual*/
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (window));
GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (window, visual);
}
void eric_window_screen_changed( GtkWidget *widget, GdkScreen *old_screen, gpointer userdata )
{
GdkVisual *visual;
GdkScreen* screen=gtk_widget_get_screen(widget);
if(!screen) return;
visual = gdk_screen_get_rgba_visual(screen);
if(visual==NULL) visual=gdk_screen_get_system_visual(screen);
gtk_widget_set_visual(widget,visual);
}
static void
gtk_bubble_window_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen)
{
GdkScreen *screen;
GdkVisual *visual;
screen = gtk_widget_get_screen (widget);
visual = gdk_screen_get_rgba_visual (screen);
if (visual)
gtk_widget_set_visual (widget, visual);
}
void
screen_changed_handler (GtkWidget* window,
GdkScreen* old_screen,
gpointer data)
{
GdkScreen* screen = gtk_widget_get_screen (GTK_WIDGET (window));
GdkVisual* visual = gdk_screen_get_rgba_visual (screen);
if (!visual)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (GTK_WIDGET (window), visual);
}
int main(int argc, char* argv[]) {
gtk_init(&argc, &argv);
if (argc == 1) {
printf("Usage: URI\n");
return 1;
}
const char *uri = argv[1];
if(!g_thread_supported())
g_thread_init(NULL);
// Create a Window, set colormap to RGBA
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GdkScreen *screen = gtk_widget_get_screen(window);
#if GTK_CHECK_VERSION(3, 0, 0)
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (visual && gdk_screen_is_composited (screen)) {
gtk_widget_set_visual(GTK_WIDGET(window), visual);
}
#else
GdkColormap *rgba = gdk_screen_get_rgba_colormap (screen);s
if (rgba && gdk_screen_is_composited (screen)) {
gtk_widget_set_default_colormap(rgba);
gtk_widget_set_default_colormap(rgba);
}
#endif
gtk_window_set_default_size(GTK_WINDOW(window), 600, 400);
g_signal_connect(window, "destroy", G_CALLBACK(destroy_cb), NULL);
// Optional: for dashboard style borderless windows
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
// Create a WebView, set it transparent, add it to the window
WebKitWebView* web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
webkit_web_view_set_transparent(web_view, TRUE);
gtk_container_add (GTK_CONTAINER(window), GTK_WIDGET(web_view));
// Load a default page
webkit_web_view_load_uri(web_view, uri);
// Show it and continue running until the window closes
gtk_widget_grab_focus(GTK_WIDGET(web_view));
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void setup(GtkWidget *win)
{
GdkScreen *screen;
GdkVisual *visual;
gtk_widget_set_app_paintable(win, TRUE);
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_DOCK);
// gtk_window_set_keep_below(GTK_WINDOW(win), TRUE);
screen = gdk_screen_get_default();
visual = gdk_screen_get_rgba_visual(screen);
if(visual != NULL && gdk_screen_is_composited(screen))
gtk_widget_set_visual(win, visual);
}
static void
realize (GtkWidget *widget)
{
GdkVisual *visual;
visual = gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget));
if (visual) {
gtk_widget_set_visual (widget, visual);
}
GTK_WIDGET_CLASS (nemo_blank_desktop_window_parent_class)->realize (widget);
/* This is the new way to set up the desktop window */
set_wmspec_desktop_hint (gtk_widget_get_window (widget));
}
void on_screen_changed(GtkWidget *widget,
GdkScreen *previous_screen,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
if(data->debug)
g_printerr("DEBUG: got screen-changed event\n");
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET (widget));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (widget, visual);
}
int main( int argc, char* argv[] )
{
Glib::RefPtr<Gtk::Application> app =
Gtk::Application::create( argc, argv, "org.gtkmm.examples.base" );
TransparentWindow window;
win = &window;
window.set_type_hint( Gdk::WINDOW_TYPE_HINT_DOCK );
window.set_keep_below( true );
window.set_decorated( false );
window.set_default_size( 200, 200 );
window.maximize();
screen = window.get_screen();
gtk_widget_set_visual( GTK_WIDGET( window.gobj() ),
screen->get_rgba_visual()->gobj() );
css = Gtk::CssProvider::create();
css->load_from_path( "style.css" );
Gtk::StyleContext::add_provider_for_screen( screen, css,
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION );
NoteCollection notes;
notes.addNote( *new Note( "Silverstone", "6 Hours of Silverstone",
Glib::DateTime::create_local( 2014, 4, 20, 0, 0, 0.0 ) ) );
notes.addNote( *new Note( "Spa", "6 Hours of Spa-Francorchamps",
Glib::DateTime::create_local( 2014, 5, 3, 0, 0, 0.0 ) ) );
notes.addNote( *new Note( "Today", "is now!",
Glib::DateTime::create_now_local() ) );
notes.addNote( *new Note( "Pre-Alpha",
"is a state myorg isn't in have yet." ) );
YearView view;
view.setNotes( ¬es );
view.updateNotes();
window.add( view );
window.show_all();
window.get_window()->set_events( Gdk::BUTTON_RELEASE_MASK );
window.signal_button_release_event().connect(
sigc::ptr_fun( buttonReleased ) );
return app->run(window);
}
void on_screen_change_event(GtkWidget *widget, gboolean *supportsAlpha)
{
GdkScreen *screen = gtk_widget_get_screen(widget);
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (!visual)
g_print("Your screen doesn't support alpha\n");
else
*supportsAlpha = TRUE;
gtk_widget_set_visual(widget, visual);
g_object_unref(visual);
return;
}
/*
* http://web.mit.edu/ghudson/dev/nokrb/third/libwnck/libwnck/test-wnck.c
* constructor
* set the window transparence
*/
AppWindow::AppWindow()
{
add_events(Gdk::BUTTON_PRESS_MASK);
set_app_paintable(true);
GdkScreen *screen;
GdkVisual *visual;
gtk_widget_set_app_paintable(GTK_WIDGET(gobj()), TRUE);
screen = gdk_screen_get_default();
visual = gdk_screen_get_rgba_visual(screen);
if (visual != NULL && gdk_screen_is_composited(screen)) {
gtk_widget_set_visual(GTK_WIDGET(gobj()), visual);
}
}
void ly_3lrc_desktop_create ()
{
int lrc_desktop_visible=1;
int lrc_desktop_fixed=0;
if(!ly_reg_get("3lrc_desktop_state", "%d:%d", &lrc_desktop_visible, &lrc_desktop_fixed))
{
ly_reg_set("3lrc_desktop_state", "%d:%d", lrc_desktop_visible, lrc_desktop_fixed);
}
int w=1000;
int h=50;
int x=0;
int y=0;
ly_reg_get("3lrc_desktop_pos_and_size", "%d:%d:%d:%d", &x, &y, &w, &h);
ly_3lrc_desktop=gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_default_size(GTK_WINDOW(ly_3lrc_desktop),w,h);
gtk_window_move(GTK_WINDOW(ly_3lrc_desktop),x,y);
gtk_widget_set_app_paintable(ly_3lrc_desktop, TRUE);
gtk_window_set_decorated(GTK_WINDOW(ly_3lrc_desktop), FALSE);
GdkVisual *visual;
GdkScreen *screen;
screen = gtk_widget_get_screen(ly_3lrc_desktop);
visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (GTK_WIDGET (ly_3lrc_desktop), visual);
gtk_widget_set_events(ly_3lrc_desktop,GDK_ALL_EVENTS_MASK);
if(lrc_desktop_visible<=0)
gtk_widget_hide(ly_3lrc_desktop);
if(lrc_desktop_fixed>0)
gtk_widget_set_sensitive(ly_3lrc_desktop,FALSE);
gtk_widget_show_all(ly_3lrc_desktop);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "draw", G_CALLBACK(ly_3lrc_desktop_on_expose_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "button_press_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "button_release_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "motion_notify_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "enter_notify_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
g_signal_connect(G_OBJECT(ly_3lrc_desktop), "leave_notify_event", G_CALLBACK(ly_3lrc_desktop_on_drag_cb), NULL);
ly_3lrc_desktop_timeout=g_timeout_add(100, ly_3lrc_desktop_on_update_cb, NULL);
}
static GtkWidget *
create_fake_menu (MateMenuTreeDirectory *directory)
{
GtkWidget *menu;
guint idle_id;
menu = create_empty_menu ();
g_object_set_data_full (G_OBJECT (menu),
"panel-menu-tree-directory",
matemenu_tree_item_ref (directory),
(GDestroyNotify) matemenu_tree_item_unref);
g_object_set_data (G_OBJECT (menu),
"panel-menu-needs-loading",
GUINT_TO_POINTER (TRUE));
g_signal_connect (menu, "show",
G_CALLBACK (submenu_to_display), NULL);
idle_id = g_idle_add_full (G_PRIORITY_LOW,
submenu_to_display_in_idle,
menu,
NULL);
g_object_set_data_full (G_OBJECT (menu),
"panel-menu-idle-id",
GUINT_TO_POINTER (idle_id),
remove_submenu_to_display_idle);
g_signal_connect (menu, "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
#if GTK_CHECK_VERSION (3, 0, 0)
GtkWidget *toplevel = gtk_widget_get_toplevel (menu);
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);
#endif
return menu;
}
static void
realize (GtkWidget *widget)
{
GdkVisual *visual;
/* Make sure we get keyboard events */
gtk_widget_set_events (widget, gtk_widget_get_events (widget)
| GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
visual = gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget));
if (visual) {
gtk_widget_set_visual (widget, visual);
}
/* Do the work of realizing. */
GTK_WIDGET_CLASS (nemo_desktop_window_parent_class)->realize (widget);
/* This is the new way to set up the desktop window */
set_wmspec_desktop_hint (gtk_widget_get_window (widget));
}
void screen_changed(GtkWidget *widget, GdkScreen *old_screen, gpointer userdata)
{
/* To check if the display supports alpha channels, get the visual */
GdkScreen *screen = gtk_widget_get_screen(widget);
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (!visual)
{
printf("Your screen does not support alpha channels!\n");
visual = gdk_screen_get_system_visual(screen);
supports_alpha = FALSE;
}
else
{
printf("Your screen supports alpha channels!\n");
supports_alpha = TRUE;
}
gtk_widget_set_visual(widget, visual);
}
void
populate_menu (charpick_data *curr_data)
{
GList *list = curr_data->chartable;
GSList *group = NULL;
GtkMenu *menu;
GtkWidget *menuitem;
if (curr_data->menu)
gtk_widget_destroy (curr_data->menu);
curr_data->menu = gtk_menu_new ();
menu = GTK_MENU (curr_data->menu);
while (list) {
gchar *string = list->data;
menuitem = gtk_radio_menu_item_new_with_label (group, string);
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
gtk_widget_show (menuitem);
g_object_set_data (G_OBJECT (menuitem), "string", string);
g_signal_connect (G_OBJECT (menuitem), "activate",
G_CALLBACK (menuitem_activated), curr_data);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
if (g_ascii_strcasecmp (curr_data->charlist, string) == 0)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
list = g_list_next (list);
}
build_table(curr_data);
/*Set up custom theme and transparency support*/
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu));
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);
/* Set menu and it's toplevel window to follow panel theme */
GtkStyleContext *context;
context = gtk_widget_get_style_context (GTK_WIDGET(toplevel));
gtk_style_context_add_class(context,"gnome-panel-menu-bar");
gtk_style_context_add_class(context,"mate-panel-menu-bar");
}
static void ghtml_window_initialize(int width, int height, bool as_dialog, void *file) {
ghtml_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (ghtml_window));
GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
visual = gdk_screen_get_system_visual (screen);
gtk_widget_set_visual (ghtml_window, visual);
g_signal_connect(ghtml_window, "destroy", G_CALLBACK(ghtml_window_destroy), NULL);
void *ghtml_window_scrollable_content_area = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(
ghtml_window_scrollable_content_area, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC
);
if (ghtml_app_title) gtk_window_set_title(ghtml_window, ghtml_app_title);
gtk_window_set_default_size(ghtml_window, width, height);
ghtml_webview = WEBKIT_WEB_VIEW(webkit_web_view_new());
gtk_container_add(ghtml_window, ghtml_window_scrollable_content_area);
if (as_dialog) {
gtk_window_set_type_hint((void*) ghtml_window, GDK_WINDOW_TYPE_HINT_DIALOG);
GtkAccelGroup *gtk_accel = gtk_accel_group_new ();
GClosure *closure;
closure = g_cclosure_new (G_CALLBACK (ghtml_window_escaped), NULL, NULL);
gtk_accel_group_connect (gtk_accel, gdk_keyval_from_name ("Escape"), 0, GTK_ACCEL_LOCKED, closure);
gtk_window_add_accel_group (ghtml_window, gtk_accel);
}
ghtml_webview_initialize(ghtml_window_scrollable_content_area, file, true);
}
DragIcon::DragIcon()
: m_window(gtk_window_new(GTK_WINDOW_POPUP))
{
#ifdef GTK_API_VERSION_2
g_signal_connect(m_window, "expose-event", G_CALLBACK(dragIconWindowDrawEventCallback), this);
#else
g_signal_connect(m_window, "draw", G_CALLBACK(dragIconWindowDrawEventCallback), this);
#endif
// This strategy originally comes from Chromium: src/chrome/browser/gtk/tab_contents_drag_source.cc
GdkScreen* screen = gtk_widget_get_screen(m_window);
#ifdef GTK_API_VERSION_2
GdkColormap* rgba = gdk_screen_get_rgba_colormap(screen);
if (rgba)
gtk_widget_set_colormap(m_window, rgba);
#else
GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
if (!visual)
visual = gdk_screen_get_system_visual(screen);
gtk_widget_set_visual(m_window, visual);
#endif // GTK_API_VERSION_2
}
static void
_gtk_bubble_window_init (GtkBubbleWindow *window)
{
GtkWidget *widget;
GdkScreen *screen;
GdkVisual *visual;
widget = GTK_WIDGET (window);
window->priv = _gtk_bubble_window_get_instance_private (window);
gtk_window_set_default_size (GTK_WINDOW (window),
TAIL_GAP_WIDTH, TAIL_GAP_WIDTH);
gtk_widget_set_app_paintable (widget, TRUE);
screen = gtk_widget_get_screen (widget);
visual = gdk_screen_get_rgba_visual (screen);
if (visual)
gtk_widget_set_visual (widget, visual);
gtk_style_context_add_class (gtk_widget_get_style_context (widget),
GTK_STYLE_CLASS_OSD);
}
/* On screen changed. */
G_MODULE_EXPORT void
on_screen_changed (GtkWidget *widget,
GdkScreen *previous_screen,
gpointer user_data)
{
AnnotateData *data = (AnnotateData *) user_data;
if (data->debug)
{
g_printerr ("DEBUG: Annotation window get screen-changed event\n");
}
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (widget));
GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
if (visual == NULL)
{
visual = gdk_screen_get_system_visual (screen);
}
gtk_widget_set_visual (widget, visual);
}
