static void
handle_button_press_event (GtkWidget *popup,
XKeyEvent *event)
{
Window window;
remove_popup (popup);
if (event->subwindow == None)
return;
if (wm_state_atom == None)
wm_state_atom = XInternAtom (event->display, "WM_STATE", FALSE);
window = find_managed_window (event->display, event->subwindow);
if (window != None) {
#if GTK_CHECK_VERSION (3, 0, 0)
if (!gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (event->display), window))
#else
if (!gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (event->display), window))
#endif
kill_window_question ((gpointer) window);
}
}
MetaUI*
meta_ui_new (Display *xdisplay,
Screen *screen)
{
GdkDisplay *gdisplay;
MetaUI *ui;
ui = g_new0 (MetaUI, 1);
ui->xdisplay = xdisplay;
ui->xscreen = screen;
gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
g_assert (gdisplay == gdk_display_get_default ());
g_assert (xdisplay == GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));
#if GTK_CHECK_VERSION (3, 0, 0)
/* This does not actually show any widget. MetaFrames has been hacked so
* that showing it doesn't actually do anything. But we need the flags
* set for GTK to deliver events properly. */
gtk_widget_show (GTK_WIDGET (ui->frames));
#else
gtk_widget_realize (GTK_WIDGET (ui->frames));
#endif
g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);
return ui;
}
static void
ensure_size_window (MetaResizePopup *popup)
{
GtkWidget *frame;
if (popup->size_window)
return;
popup->size_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (popup->size_window),
gdk_display_get_default_screen (gdk_x11_lookup_xdisplay (popup->display)));
/* never shrink the size window */
gtk_window_set_resizable (GTK_WINDOW (popup->size_window),
TRUE);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (popup->size_window), frame);
popup->size_label = gtk_label_new ("");
gtk_widget_set_margin_start (popup->size_label, 3);
gtk_widget_set_margin_end (popup->size_label, 3);
gtk_widget_set_margin_top (popup->size_label, 3);
gtk_widget_set_margin_bottom (popup->size_label, 3);
gtk_container_add (GTK_CONTAINER (frame), popup->size_label);
gtk_widget_show_all (frame);
}
char*
meta_text_property_to_utf8 (Display *xdisplay,
const XTextProperty *prop)
{
GdkDisplay *display;
char **list;
int count;
char *retval;
list = NULL;
display = gdk_x11_lookup_xdisplay (xdisplay);
count = gdk_text_property_to_utf8_list_for_display (display,
gdk_x11_xatom_to_atom_for_display (display, prop->encoding),
prop->format,
prop->value,
prop->nitems,
&list);
if (count == 0)
retval = NULL;
else
{
retval = list[0];
list[0] = g_strdup (""); /* something to free */
}
g_strfreev (list);
return retval;
}
MetaUI*
meta_ui_new (Display *xdisplay,
Screen *screen)
{
GdkDisplay *gdisplay;
MetaUI *ui;
ui = g_new0 (MetaUI, 1);
ui->xdisplay = xdisplay;
ui->xscreen = screen;
gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
g_assert (gdisplay == gdk_display_get_default ());
ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));
/* GTK+ needs the frame-sync protocol to work in order to properly
* handle style changes. This means that the dummy widget we create
* to get the style for title bars actually needs to be mapped
* and fully tracked as a MetaWindow. Horrible, but mostly harmless -
* the window is a 1x1 overide redirect window positioned offscreen.
*/
gtk_widget_show (GTK_WIDGET (ui->frames));
g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);
return ui;
}
static void
refcounted_ungrab_server (Display *xdisplay)
{
GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
gdk_x11_display_ungrab (display);
}
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);
}
MetaImageWindow*
meta_image_window_new (Display *xdisplay,
int screen_number,
int max_width,
int max_height)
{
MetaImageWindow *iw;
GdkDisplay *gdisplay;
GdkScreen *gscreen;
iw = g_new (MetaImageWindow, 1);
iw->window = gtk_window_new (GTK_WINDOW_POPUP);
gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
gscreen = gdk_display_get_screen (gdisplay, screen_number);
gtk_window_set_screen (GTK_WINDOW (iw->window), gscreen);
gtk_widget_realize (iw->window);
iw->pixmap = gdk_pixmap_new (gtk_widget_get_window (iw->window),
max_width, max_height,
-1);
gtk_widget_set_size_request (iw->window, 1, 1);
gtk_widget_set_double_buffered (iw->window, FALSE);
gtk_widget_set_app_paintable (iw->window, TRUE);
return iw;
}
EggTrayIcon *egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
{
GdkDisplay *display;
GdkScreen *screen;
display = gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen));
screen = gdk_display_get_screen (display, XScreenNumberOfScreen (xscreen));
return egg_tray_icon_new_for_screen (screen, name);
}
void
meta_ui_free (MetaUI *ui)
{
GdkDisplay *gdisplay;
gtk_widget_destroy (GTK_WIDGET (ui->frames));
gdisplay = gdk_x11_lookup_xdisplay (ui->xdisplay);
g_object_set_data (G_OBJECT (gdisplay), "meta-ui", NULL);
g_free (ui);
}
void
meta_ui_unmap_frame (MetaUI *ui,
Window xwindow)
{
GdkWindow *window;
GdkDisplay *display;
display = gdk_x11_lookup_xdisplay (ui->xdisplay);
window = gdk_x11_window_lookup_for_display (display, xwindow);
if (window)
gdk_window_hide (window);
}
void
meta_ui_theme_get_frame_borders (MetaUI *ui,
MetaFrameType type,
MetaFrameFlags flags,
MetaFrameBorders *borders)
{
int text_height;
GtkStyleContext *style = NULL;
PangoContext *context;
const PangoFontDescription *font_desc;
PangoFontDescription *free_font_desc = NULL;
if (meta_ui_have_a_theme ())
{
context = gtk_widget_get_pango_context (GTK_WIDGET (ui->frames));
font_desc = meta_prefs_get_titlebar_font ();
if (!font_desc)
{
GdkDisplay *display = gdk_x11_lookup_xdisplay (ui->xdisplay);
GdkScreen *screen = gdk_display_get_screen (display, XScreenNumberOfScreen (ui->xscreen));
GtkWidgetPath *widget_path;
style = gtk_style_context_new ();
gtk_style_context_set_screen (style, screen);
widget_path = gtk_widget_path_new ();
gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW);
gtk_style_context_set_path (style, widget_path);
gtk_widget_path_free (widget_path);
gtk_style_context_get (style, GTK_STATE_FLAG_NORMAL, "font", &free_font_desc, NULL);
font_desc = (const PangoFontDescription *) free_font_desc;
}
text_height = meta_pango_font_desc_get_text_height (font_desc, context);
meta_theme_get_frame_borders (meta_theme_get_current (),
type, text_height, flags,
borders);
if (free_font_desc)
pango_font_description_free (free_font_desc);
}
else
{
meta_frame_borders_clear (borders);
}
if (style != NULL)
g_object_unref (style);
}
// Look for an existing Colormap that known to be associated with visual.
static Colormap
LookupColormapForVisual(const Screen* screen, const Visual* visual)
{
// common case
if (visual == DefaultVisualOfScreen(screen))
return DefaultColormapOfScreen(screen);
#ifdef MOZ_WIDGET_GTK2
// I wish there were a gdk_x11_display_lookup_screen.
Display* dpy = DisplayOfScreen(screen);
GdkDisplay* gdkDpy = gdk_x11_lookup_xdisplay(dpy);
if (gdkDpy) {
gint screen_num = 0;
for (int s = 0; s < ScreenCount(dpy); ++s) {
if (ScreenOfDisplay(dpy, s) == screen) {
screen_num = s;
break;
}
}
GdkScreen* gdkScreen = gdk_display_get_screen(gdkDpy, screen_num);
GdkColormap* gdkColormap = NULL;
if (visual ==
GDK_VISUAL_XVISUAL(gdk_screen_get_rgb_visual(gdkScreen))) {
// widget/src/gtk2/mozcontainer.c uses gdk_rgb_get_colormap()
// which is inherited by child widgets, so this is the visual
// expected when drawing directly to widget surfaces or surfaces
// created using cairo_surface_create_similar with
// CAIRO_CONTENT_COLOR.
// gdk_screen_get_rgb_colormap is the generalization of
// gdk_rgb_get_colormap for any screen.
gdkColormap = gdk_screen_get_rgb_colormap(gdkScreen);
}
else if (visual ==
GDK_VISUAL_XVISUAL(gdk_screen_get_rgba_visual(gdkScreen))) {
// This is the visual expected on displays with the Composite
// extension enabled when the surface has been created using
// cairo_surface_create_similar with CAIRO_CONTENT_COLOR_ALPHA,
// as happens with non-unit opacity.
gdkColormap = gdk_screen_get_rgba_colormap(gdkScreen);
}
if (gdkColormap != NULL)
return GDK_COLORMAP_XCOLORMAP(gdkColormap);
}
#endif
return None;
}
EggTrayIcon *
egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
{
EggTrayIcon *icon;
char buffer[256];
GdkWindow *root_window;
GdkDisplay *display;
GdkScreen *screen;
g_return_val_if_fail (xscreen != NULL, NULL);
icon = g_object_new (EGG_TYPE_TRAY_ICON, NULL);
gtk_window_set_title (GTK_WINDOW (icon), name);
display = gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen));
screen = gdk_display_get_screen (display, XScreenNumberOfScreen (xscreen));
gtk_plug_construct_for_display (GTK_PLUG (icon),
display, 0);
gtk_window_set_screen (GTK_WINDOW (icon), screen);
gtk_widget_realize (GTK_WIDGET (icon));
/* Now see if there's a manager window around */
g_snprintf (buffer, sizeof (buffer),
"_NET_SYSTEM_TRAY_S%d",
XScreenNumberOfScreen (xscreen));
icon->selection_atom = XInternAtom (DisplayOfScreen (xscreen),
buffer, False);
icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen),
"MANAGER", False);
icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_OPCODE", False);
egg_tray_icon_update_manager_window (icon);
root_window = gdk_screen_get_root_window (gtk_widget_get_screen (GTK_WIDGET (icon)));
/* Add a root window filter so that we get changes on MANAGER */
gdk_window_add_filter (root_window,
egg_tray_icon_manager_filter, icon);
return icon;
}
gboolean
meta_ui_window_should_not_cause_focus (Display *xdisplay,
Window xwindow)
{
GdkWindow *window;
GdkDisplay *display;
display = gdk_x11_lookup_xdisplay (xdisplay);
window = gdk_x11_window_lookup_for_display (display, xwindow);
/* we shouldn't cause focus if we're an override redirect
* toplevel which is not foreign
*/
if (window && gdk_window_get_window_type (window) == GDK_WINDOW_TEMP)
return TRUE;
else
return FALSE;
}
gboolean
meta_ui_window_is_widget (MetaUI *ui,
Window xwindow)
{
GdkWindow *window;
GdkDisplay *display;
display = gdk_x11_lookup_xdisplay (ui->xdisplay);
window = gdk_x11_window_lookup_for_display (display, xwindow);
if (window)
{
void *user_data = NULL;
gdk_window_get_user_data (window, &user_data);
return user_data != NULL && user_data != ui->frames;
}
else
return FALSE;
}
static void
handle_button_press_event (GtkWidget *popup,
Display *display,
Window subwindow)
{
Window window;
remove_popup (popup);
if (subwindow == None)
return;
if (wm_state_atom == None)
wm_state_atom = XInternAtom (display, "WM_STATE", FALSE);
window = find_managed_window (display, subwindow);
if (window != None) {
if (!gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (display), window))
kill_window_question ((gpointer) window);
}
}
void
meta_ui_theme_get_frame_borders (MetaUI *ui,
MetaFrameType type,
MetaFrameFlags flags,
MetaFrameBorders *borders)
{
int text_height;
MetaStyleInfo *style_info = NULL;
PangoContext *context;
const PangoFontDescription *font_desc;
PangoFontDescription *free_font_desc = NULL;
GdkDisplay *display = gdk_x11_lookup_xdisplay (ui->xdisplay);
GdkScreen *screen = gdk_display_get_screen (display, XScreenNumberOfScreen (ui->xscreen));
style_info = meta_theme_create_style_info (screen, NULL);
context = gtk_widget_get_pango_context (GTK_WIDGET (ui->frames));
font_desc = meta_prefs_get_titlebar_font ();
if (!font_desc)
{
free_font_desc = meta_style_info_create_font_desc (style_info);
font_desc = (const PangoFontDescription *) free_font_desc;
}
text_height = meta_pango_font_desc_get_text_height (font_desc, context);
meta_theme_get_frame_borders (meta_theme_get_default (),
style_info, type, text_height, flags,
borders);
if (free_font_desc)
pango_font_description_free (free_font_desc);
if (style_info != NULL)
meta_style_info_unref (style_info);
}
int
moGLManager::CreateContext( int p_width, int p_height ) {
MODebug2->Message( "moGLManager::CreateContext > p_width: " + IntToStr(p_width) + " p_height: " + IntToStr(p_height) );
#ifdef MO_WIN
GLuint PixelFormat;
PIXELFORMATDESCRIPTOR pfd;
hDC = GetDC(NULL);
memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 16;
pfd.cStencilBits = 8;
pfd.iLayerType = PFD_MAIN_PLANE;
PixelFormat = ChoosePixelFormat(hDC, &pfd);
SetPixelFormat(hDC, PixelFormat, &pfd);
// HGLRC
this->m_Context = (moGLContext) wglCreateContext(hDC);
wglMakeCurrent(hDC, (HGLRC) this->m_Context );
#endif
#ifdef MO_LINUXX
/*
If direct is True,
then a direct-rendering context is created if the
implementation supports direct rendering, if the connection is to an X
server that is local, and if a direct-rendering context is available. (An implementation may return an indirect context when share_list is True.)
If share_list is False,
then a rendering context that renders through the X server is always created.
Direct rendering provides a performance advantage in some implementations.
However, direct-rendering contexts cannot be shared outside a single process,
and they may be unable to render to GLX pixmaps.
*/
int m_glxVersion = 0;
int glxMajorVer, glxMinorVer;
Display *XServerDisplay=NULL;
GdkDisplay *XGdkDisplay=NULL;
GLXFBConfig *fbc = NULL;
GLXPbuffer OffScreenBuffer = 0;
int nscreens = 0;
//XServerDisplay = GDK_DISPLAY();
//XServerDisplay = gdk_display_get_default();
MODebug2->Message( "moGLManager::CreateContext > getting X server display" );
//XServerDisplay = gdk_x11_get_default_xdisplay();
if (m_DisplayServer==NULL) {
XServerDisplay = XOpenDisplay(NULL);
m_DisplayServer = (void*)XServerDisplay;
} else {
XServerDisplay = (Display *)m_DisplayServer;
MODebug2->Message("moGLManager::CreateContext > display server connection already opened.");
}
//XServerDisplay = GDK_DISPLAY();
// gdk_display_get_screen ()
// gdk_display_get_n_screens ()
if (XServerDisplay) {
MODebug2->Message( "moGLManager::CreateContext > X server display OK." );
XGdkDisplay = gdk_x11_lookup_xdisplay( XServerDisplay );
if (!XGdkDisplay) XGdkDisplay = gdk_display_get_default ();
if (XGdkDisplay) {
MODebug2->Error("moGLManager::CreateContext > X Gdk Display OK! : " + IntToStr((MOulong)XGdkDisplay));
nscreens = gdk_display_get_n_screens(XGdkDisplay);
} else MODebug2->Error("moGLManager::CreateContext > X Gdk Display not found : " + IntToStr((MOulong)XGdkDisplay));
MODebug2->Message("moGLManager::CreateContext > X Server Display found: " + IntToStr((MOulong)XServerDisplay) + " screens:" + IntToStr(nscreens) );
} else {
MODebug2->Error("moGLManager::CreateContext > X Server Display not found : " + IntToStr((MOulong)XServerDisplay));
return false;
}
bool ok = glXQueryVersion( XServerDisplay, &glxMajorVer, &glxMinorVer);
if (!ok)
m_glxVersion = 10; // 1.0 by default
else
m_glxVersion = glxMajorVer*10 + glxMinorVer;
MODebug2->Message("moGLManager::CreateContext > GLX Version (10=1.0,13=1.3,...): " + IntToStr(m_glxVersion) + "=" + FloatToStr( (double)(m_glxVersion)/(double) 10.0) );
if ( m_glxVersion >= 13)
{
// GLX >= 1.3
//GLXFBConfig *fbc = gc->m_fbc;
int nelements = 0;
int attrib_list[] =
{
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DOUBLEBUFFER, 1,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
GLX_DEPTH_SIZE, 16,
GLX_STENCIL_SIZE, 8,
0
};
fbc = glXChooseFBConfig( XServerDisplay,
DefaultScreen(XServerDisplay)/*screen number*/,
attrib_list,
&nelements );
if (fbc) {
MODebug2->Message( "moGLManager::CreateContext > FBConfig OK!");
} else {
MODebug2->Error( "moGLManager::CreateContext > No FBConfig");
return false;
}
this->m_Context = (moGLContext) glXCreateNewContext( XServerDisplay /*XServer Display*/,
fbc[0] /*attribute list FB Config match*/,
GLX_RGBA_TYPE /*type of rendering*/,
NULL /*shared context for display lists*/,
GL_TRUE /*direct rendering to graphics system*/);
}
else
{
// GLX <= 1.2
int attrib_list_vi[] =
{
GLX_RGBA,
GLX_DOUBLEBUFFER,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
GLX_DEPTH_SIZE, 16,
GLX_STENCIL_SIZE, 8,
0
};
XVisualInfo *vi = glXChooseVisual( XServerDisplay,
DefaultScreen(XServerDisplay), /*screen number*/
attrib_list_vi );
this->m_Context = (moGLContext) glXCreateContext( XServerDisplay,
vi,
NULL,
GL_TRUE );
}
if (this->m_Context) {
MODebug2->Message("moGLManager::CreateContext > creating offscreen buffer.");
if ( m_glxVersion >= 13 ) {
// GLX >= 1.3
int pbuffer_attrib[] = {
GLX_PBUFFER_WIDTH, p_width,
GLX_PBUFFER_HEIGHT, p_height,
GLX_LARGEST_PBUFFER, 0,
GLX_PRESERVED_CONTENTS, 0,
0 };
OffScreenBuffer = glXCreatePbuffer( XServerDisplay, fbc[0], pbuffer_attrib );
this->m_DisplayScreen = (void*) OffScreenBuffer;
if (OffScreenBuffer) {
MODebug2->Message("moGLManager::CreateContext > Offscreen buffer OK! GLPXBuffer: " + IntToStr( (MOulong) OffScreenBuffer ) );
} else {
MODebug2->Error("moGLManager::CreateContext > Offscreen buffer BAD... : " + IntToStr( (MOulong) OffScreenBuffer ) );
return false;
}
if ( glXMakeContextCurrent( XServerDisplay, OffScreenBuffer, OffScreenBuffer, (GLXContext) this->m_Context ) ) {
MODebug2->Message("moGLManager::CreateContext > Making Context current OK!");
}
} else {
// GLX <= 1.2
//glXMakeCurrent( XServerDisplay, GDK_WINDOW_XWINDOW(window), m_glContext );
}
}
#endif
#ifdef MO_MAC
//CGL
CGLCreateContext
//COCOA
//NSOpenGLView
//CARBON
//aglCreateContext
#endif
return (this->m_Context == NULL);
}
static gboolean
maybe_redirect_mouse_event (XEvent *xevent)
{
GdkDisplay *gdisplay;
GdkDeviceManager *gmanager;
GdkDevice *gdevice;
MetaUI *ui;
GdkEvent *gevent;
GdkWindow *gdk_window;
Window window;
XIEvent *xev;
XIDeviceEvent *xev_d = NULL;
XIEnterEvent *xev_e = NULL;
if (!is_input_event (xevent))
return FALSE;
xev = (XIEvent *) xevent->xcookie.data;
switch (xev->evtype)
{
case XI_TouchBegin:
case XI_ButtonPress:
case XI_ButtonRelease:
case XI_Motion:
xev_d = (XIDeviceEvent *) xev;
window = xev_d->event;
break;
case XI_Enter:
case XI_Leave:
xev_e = (XIEnterEvent *) xev;
window = xev_e->event;
break;
default:
return FALSE;
}
gdisplay = gdk_x11_lookup_xdisplay (xev->display);
ui = g_object_get_data (G_OBJECT (gdisplay), "meta-ui");
if (!ui)
return FALSE;
gdk_window = gdk_x11_window_lookup_for_display (gdisplay, window);
if (gdk_window == NULL)
return FALSE;
gmanager = gdk_display_get_device_manager (gdisplay);
gdevice = gdk_x11_device_manager_lookup (gmanager, META_VIRTUAL_CORE_POINTER_ID);
/* If GDK already thinks it has a grab, we better let it see events; this
* is the menu-navigation case and events need to get sent to the appropriate
* (client-side) subwindow for individual menu items.
*/
if (gdk_display_device_is_grabbed (gdisplay, gdevice))
return FALSE;
switch (xev->evtype)
{
case XI_TouchBegin:
case XI_ButtonPress:
case XI_ButtonRelease:
if (xev_d->evtype == XI_ButtonPress || xev_d->evtype == XI_TouchBegin)
{
GtkSettings *settings = gtk_settings_get_default ();
int double_click_time;
int double_click_distance;
int button;
g_object_get (settings,
"gtk-double-click-time", &double_click_time,
"gtk-double-click-distance", &double_click_distance,
NULL);
if (xev->evtype == XI_TouchBegin)
button = 1;
else
button = xev_d->detail;
if (button == ui->button_click_number &&
xev_d->event == ui->button_click_window &&
xev_d->time < ui->button_click_time + double_click_time &&
ABS (xev_d->event_x - ui->button_click_x) <= double_click_distance &&
ABS (xev_d->event_y - ui->button_click_y) <= double_click_distance)
{
gevent = gdk_event_new (GDK_2BUTTON_PRESS);
ui->button_click_number = 0;
}
else
{
gevent = gdk_event_new (GDK_BUTTON_PRESS);
ui->button_click_number = button;
ui->button_click_window = xev_d->event;
ui->button_click_time = xev_d->time;
ui->button_click_x = xev_d->event_x;
ui->button_click_y = xev_d->event_y;
}
gevent->button.button = button;
}
else
{
gevent = gdk_event_new (GDK_BUTTON_RELEASE);
gevent->button.button = xev_d->detail;
}
gevent->button.window = g_object_ref (gdk_window);
gevent->button.time = xev_d->time;
gevent->button.x = xev_d->event_x;
gevent->button.y = xev_d->event_y;
gevent->button.x_root = xev_d->root_x;
gevent->button.y_root = xev_d->root_y;
break;
case XI_Motion:
gevent = gdk_event_new (GDK_MOTION_NOTIFY);
gevent->motion.type = GDK_MOTION_NOTIFY;
gevent->motion.window = g_object_ref (gdk_window);
break;
case XI_Enter:
case XI_Leave:
gevent = gdk_event_new (xev_e->evtype == XI_Enter ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);
gevent->crossing.window = g_object_ref (gdk_window);
gevent->crossing.x = xev_e->event_x;
gevent->crossing.y = xev_e->event_y;
break;
default:
g_assert_not_reached ();
break;
}
/* If we've gotten here, we've created the gdk_event and should send it on */
gdk_event_set_device (gevent, gdevice);
gtk_main_do_event (gevent);
gdk_event_free (gevent);
return TRUE;
}
static gboolean
egg_tray_manager_manage_xscreen (EggTrayManager *manager, Screen *xscreen)
{
GtkWidget *invisible;
char *selection_atom_name;
guint32 timestamp;
GdkScreen *screen;
g_return_val_if_fail (EGG_IS_TRAY_MANAGER (manager), FALSE);
g_return_val_if_fail (manager->screen == NULL, FALSE);
/* If there's already a manager running on the screen
* we can't create another one.
*/
#if 0
if (egg_tray_manager_check_running_xscreen (xscreen))
return FALSE;
#endif
screen = gdk_display_get_screen (gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen)),
XScreenNumberOfScreen (xscreen));
manager->screen = screen;
invisible = gtk_invisible_new_for_screen (screen);
gtk_widget_realize (invisible);
gtk_widget_add_events (invisible, GDK_PROPERTY_CHANGE_MASK | GDK_STRUCTURE_MASK);
selection_atom_name = g_strdup_printf ("_NET_SYSTEM_TRAY_S%d",
XScreenNumberOfScreen (xscreen));
manager->selection_atom = XInternAtom (DisplayOfScreen (xscreen), selection_atom_name, False);
g_free (selection_atom_name);
manager->invisible = invisible;
g_object_ref (G_OBJECT (manager->invisible));
manager->orientation_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_ORIENTATION",
FALSE);
egg_tray_manager_set_orientation_property (manager);
egg_tray_manager_set_visual_property (manager);
timestamp = gdk_x11_get_server_time (invisible->window);
XSetSelectionOwner (DisplayOfScreen (xscreen), manager->selection_atom,
GDK_WINDOW_XWINDOW (invisible->window), timestamp);
/* Check if we were could set the selection owner successfully */
if (XGetSelectionOwner (DisplayOfScreen (xscreen), manager->selection_atom) ==
GDK_WINDOW_XWINDOW (invisible->window))
{
XClientMessageEvent xev;
xev.type = ClientMessage;
xev.window = RootWindowOfScreen (xscreen);
xev.message_type = XInternAtom (DisplayOfScreen (xscreen), "MANAGER", False);
xev.format = 32;
xev.data.l[0] = timestamp;
xev.data.l[1] = manager->selection_atom;
xev.data.l[2] = GDK_WINDOW_XWINDOW (invisible->window);
xev.data.l[3] = 0; /* manager specific data */
xev.data.l[4] = 0; /* manager specific data */
XSendEvent (DisplayOfScreen (xscreen),
RootWindowOfScreen (xscreen),
False, StructureNotifyMask, (XEvent *)&xev);
manager->opcode_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_OPCODE",
False);
manager->message_data_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_MESSAGE_DATA",
False);
/* Add a window filter */
gdk_window_add_filter (invisible->window, egg_tray_manager_window_filter, manager);
return TRUE;
}
else
{
gtk_widget_destroy (invisible);
g_object_unref (invisible);
manager->invisible = NULL;
manager->screen = NULL;
return FALSE;
}
}
void
meta_ui_theme_get_frame_borders (MetaUI *ui,
MetaFrameType type,
MetaFrameFlags flags,
int *top_height,
int *bottom_height,
int *left_width,
int *right_width)
{
int text_height;
#if GTK_CHECK_VERSION (3, 0, 0)
GtkStyleContext *style = NULL;
PangoFontDescription *free_font_desc = NULL;
#endif
PangoContext *context;
const PangoFontDescription *font_desc;
if (meta_ui_have_a_theme ())
{
context = gtk_widget_get_pango_context (GTK_WIDGET (ui->frames));
font_desc = meta_prefs_get_titlebar_font ();
if (!font_desc)
{
#if GTK_CHECK_VERSION (3, 0, 0)
GdkDisplay *display = gdk_x11_lookup_xdisplay (ui->xdisplay);
GdkScreen *screen = gdk_display_get_screen (display, XScreenNumberOfScreen (ui->xscreen));
GtkWidgetPath *widget_path;
style = gtk_style_context_new ();
gtk_style_context_set_screen (style, screen);
widget_path = gtk_widget_path_new ();
gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW);
gtk_style_context_set_path (style, widget_path);
gtk_widget_path_free (widget_path);
gtk_style_context_get (style, GTK_STATE_FLAG_NORMAL, "font", &free_font_desc, NULL);
font_desc = (const PangoFontDescription *) free_font_desc;
#else
GtkStyle *default_style;
default_style = gtk_widget_get_default_style ();
font_desc = default_style->font_desc;
#endif
}
text_height = meta_pango_font_desc_get_text_height (font_desc, context);
meta_theme_get_frame_borders (meta_theme_get_current (),
type, text_height, flags,
top_height, bottom_height,
left_width, right_width);
#if GTK_CHECK_VERSION (3, 0, 0)
if (free_font_desc)
pango_font_description_free (free_font_desc);
#endif
}
else
{
*top_height = *bottom_height = *left_width = *right_width = 0;
}
#if GTK_CHECK_VERSION (3, 0, 0)
if (style != NULL)
g_object_unref (style);
#endif
}
Window
meta_ui_create_frame_window (MetaUI *ui,
Display *xdisplay,
Visual *xvisual,
gint x,
gint y,
gint width,
gint height,
gint screen_no,
gulong *create_serial)
{
GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
GdkScreen *screen = gdk_display_get_screen (display, screen_no);
GdkWindowAttr attrs;
gint attributes_mask;
GdkWindow *window;
GdkVisual *visual;
/* Default depth/visual handles clients with weird visuals; they can
* always be children of the root depth/visual obviously, but
* e.g. DRI games can't be children of a parent that has the same
* visual as the client.
*/
if (!xvisual)
visual = gdk_screen_get_system_visual (screen);
else
{
visual = gdk_x11_screen_lookup_visual (screen,
XVisualIDFromVisual (xvisual));
}
attrs.title = NULL;
/* frame.c is going to replace the event mask immediately, but
* we still have to set it here to let GDK know what it is.
*/
attrs.event_mask =
GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK;
attrs.x = x;
attrs.y = y;
attrs.wclass = GDK_INPUT_OUTPUT;
attrs.visual = visual;
attrs.window_type = GDK_WINDOW_CHILD;
attrs.cursor = NULL;
attrs.wmclass_name = NULL;
attrs.wmclass_class = NULL;
attrs.override_redirect = FALSE;
attrs.width = width;
attrs.height = height;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
/* We make an assumption that gdk_window_new() is going to call
* XCreateWindow as it's first operation; this seems to be true currently
* as long as you pass in a colormap.
*/
if (create_serial)
*create_serial = XNextRequest (xdisplay);
window =
gdk_window_new (gdk_screen_get_root_window(screen),
&attrs, attributes_mask);
gdk_window_resize (window, width, height);
meta_frames_manage_window (ui->frames, GDK_WINDOW_XID (window), window);
return GDK_WINDOW_XID (window);
}
static gboolean
maybe_redirect_mouse_event (XEvent *xevent)
{
GdkDisplay *gdisplay;
MetaUI *ui;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkDeviceManager *gmanager;
GdkDevice *gdevice;
GdkEvent *gevent;
#else
GdkEvent gevent;
#endif
GdkWindow *gdk_window;
Window window;
switch (xevent->type)
{
case ButtonPress:
case ButtonRelease:
window = xevent->xbutton.window;
break;
case MotionNotify:
window = xevent->xmotion.window;
break;
case EnterNotify:
case LeaveNotify:
window = xevent->xcrossing.window;
break;
default:
return FALSE;
}
gdisplay = gdk_x11_lookup_xdisplay (xevent->xany.display);
ui = g_object_get_data (G_OBJECT (gdisplay), "meta-ui");
if (!ui)
return FALSE;
#if GTK_CHECK_VERSION (3, 0, 0)
gdk_window = gdk_x11_window_lookup_for_display (gdisplay, window);
#else
gdk_window = gdk_window_lookup_for_display (gdisplay, window);
#endif
if (gdk_window == NULL)
return FALSE;
#if GTK_CHECK_VERSION (3, 0, 0)
gmanager = gdk_display_get_device_manager (gdisplay);
gdevice = gdk_device_manager_get_client_pointer (gmanager);
#endif
/* If GDK already thinks it has a grab, we better let it see events; this
* is the menu-navigation case and events need to get sent to the appropriate
* (client-side) subwindow for individual menu items.
*/
#if GTK_CHECK_VERSION (3, 0, 0)
if (gdk_display_device_is_grabbed (gdisplay, gdevice))
#else
if (gdk_display_pointer_is_grabbed (gdisplay))
#endif
return FALSE;
#if !GTK_CHECK_VERSION (3, 0, 0)
memset (&gevent, 0, sizeof (gevent));
#endif
switch (xevent->type)
{
case ButtonPress:
case ButtonRelease:
if (xevent->type == ButtonPress)
{
GtkSettings *settings = gtk_settings_get_default ();
int double_click_time;
int double_click_distance;
g_object_get (settings,
"gtk-double-click-time", &double_click_time,
"gtk-double-click-distance", &double_click_distance,
NULL);
if (xevent->xbutton.button == ui->button_click_number &&
xevent->xbutton.window == ui->button_click_window &&
xevent->xbutton.time < ui->button_click_time + double_click_time &&
ABS (xevent->xbutton.x - ui->button_click_x) <= double_click_distance &&
ABS (xevent->xbutton.y - ui->button_click_y) <= double_click_distance)
{
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (GDK_2BUTTON_PRESS);
#else
gevent.button.type = GDK_2BUTTON_PRESS;
#endif
ui->button_click_number = 0;
}
else
{
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (GDK_BUTTON_PRESS);
#else
gevent.button.type = GDK_BUTTON_PRESS;
#endif
ui->button_click_number = xevent->xbutton.button;
ui->button_click_window = xevent->xbutton.window;
ui->button_click_time = xevent->xbutton.time;
ui->button_click_x = xevent->xbutton.x;
ui->button_click_y = xevent->xbutton.y;
}
}
else
{
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (GDK_BUTTON_RELEASE);
#else
gevent.button.type = GDK_BUTTON_RELEASE;
#endif
}
#if GTK_CHECK_VERSION (3, 0, 0)
gevent->button.window = g_object_ref (gdk_window);
gevent->button.button = xevent->xbutton.button;
gevent->button.time = xevent->xbutton.time;
gevent->button.x = xevent->xbutton.x;
gevent->button.y = xevent->xbutton.y;
gevent->button.x_root = xevent->xbutton.x_root;
gevent->button.y_root = xevent->xbutton.y_root;
#else
gevent.button.window = gdk_window;
gevent.button.button = xevent->xbutton.button;
gevent.button.time = xevent->xbutton.time;
gevent.button.x = xevent->xbutton.x;
gevent.button.y = xevent->xbutton.y;
gevent.button.x_root = xevent->xbutton.x_root;
gevent.button.y_root = xevent->xbutton.y_root;
#endif
break;
case MotionNotify:
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (GDK_MOTION_NOTIFY);
gevent->motion.type = GDK_MOTION_NOTIFY;
gevent->motion.window = g_object_ref (gdk_window);
#else
gevent.motion.type = GDK_MOTION_NOTIFY;
gevent.motion.window = gdk_window;
#endif
break;
case EnterNotify:
case LeaveNotify:
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);
gevent->crossing.window = g_object_ref (gdk_window);
gevent->crossing.x = xevent->xcrossing.x;
gevent->crossing.y = xevent->xcrossing.y;
#else
gevent.crossing.type = xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;
gevent.crossing.window = gdk_window;
gevent.crossing.x = xevent->xcrossing.x;
gevent.crossing.y = xevent->xcrossing.y;
#endif
break;
default:
g_assert_not_reached ();
break;
}
/* If we've gotten here, we've filled in the gdk_event and should send it on */
#if GTK_CHECK_VERSION (3, 0, 0)
gdk_event_set_device (gevent, gdevice);
gtk_main_do_event (gevent);
gdk_event_free (gevent);
#else
gtk_main_do_event (&gevent);
#endif
return TRUE;
}
Window
meta_ui_create_frame_window (MetaUI *ui,
Display *xdisplay,
Visual *xvisual,
gint x,
gint y,
gint width,
gint height,
gint screen_no)
{
GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
GdkScreen *screen = gdk_display_get_screen (display, screen_no);
GdkWindowAttr attrs;
gint attributes_mask;
GdkWindow *window;
GdkVisual *visual;
#if !GTK_CHECK_VERSION (3, 0, 0)
GdkColormap *cmap = gdk_screen_get_default_colormap (screen);
#endif
/* Default depth/visual handles clients with weird visuals; they can
* always be children of the root depth/visual obviously, but
* e.g. DRI games can't be children of a parent that has the same
* visual as the client.
*/
if (!xvisual)
visual = gdk_screen_get_system_visual (screen);
else
{
visual = gdk_x11_screen_lookup_visual (screen,
XVisualIDFromVisual (xvisual));
#if !GTK_CHECK_VERSION (3, 0, 0)
cmap = gdk_colormap_new (visual, FALSE);
#endif
}
attrs.title = NULL;
/* frame.c is going to replace the event mask immediately, but
* we still have to set it here to let GDK know what it is.
*/
attrs.event_mask =
GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK;
attrs.x = x;
attrs.y = y;
attrs.wclass = GDK_INPUT_OUTPUT;
attrs.visual = visual;
#if !GTK_CHECK_VERSION (3, 0, 0)
attrs.colormap = cmap;
#endif
attrs.window_type = GDK_WINDOW_CHILD;
attrs.cursor = NULL;
attrs.wmclass_name = NULL;
attrs.wmclass_class = NULL;
attrs.override_redirect = FALSE;
attrs.width = width;
attrs.height = height;
#if GTK_CHECK_VERSION (3, 0, 0)
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
#else
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
#endif
window =
gdk_window_new (gdk_screen_get_root_window(screen),
&attrs, attributes_mask);
gdk_window_resize (window, width, height);
meta_frames_manage_window (ui->frames, GDK_WINDOW_XID (window), window);
return GDK_WINDOW_XID (window);
}
