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); }