From 090c1a5e59ef4f98ee63609956106cbc6dc8d95c Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Sep 30 2006 04:56:01 +0000 Subject: fix transparent panels --- diff --git a/ekiga-2.0.2-transparent.patch b/ekiga-2.0.2-transparent.patch new file mode 100644 index 0000000..0c2b413 --- /dev/null +++ b/ekiga-2.0.2-transparent.patch @@ -0,0 +1,582 @@ +--- ekiga-2.0.3/lib/gui/gmtray/eggtrayicon.h.transparent 2006-09-30 00:33:32.000000000 -0400 ++++ ekiga-2.0.3/lib/gui/gmtray/eggtrayicon.h 2006-09-30 00:33:49.000000000 -0400 +@@ -22,7 +22,9 @@ + #define __EGG_TRAY_ICON_H__ + + #include ++#ifdef GDK_WINDOWING_X11 + #include ++#endif + + G_BEGIN_DECLS + +@@ -42,10 +44,14 @@ + + guint stamp; + ++#ifdef GDK_WINDOWING_X11 + Atom selection_atom; + Atom manager_atom; + Atom system_tray_opcode_atom; ++ Atom orientation_atom; + Window manager_window; ++#endif ++ GtkOrientation orientation; + }; + + struct _EggTrayIconClass +@@ -55,10 +61,8 @@ + + GType egg_tray_icon_get_type (void); + +-#if EGG_TRAY_ENABLE_MULTIHEAD + EggTrayIcon *egg_tray_icon_new_for_screen (GdkScreen *screen, + const gchar *name); +-#endif + + EggTrayIcon *egg_tray_icon_new (const gchar *name); + +@@ -69,7 +73,7 @@ + void egg_tray_icon_cancel_message (EggTrayIcon *icon, + guint id); + +- ++GtkOrientation egg_tray_icon_get_orientation (EggTrayIcon *icon); + + G_END_DECLS + +--- ekiga-2.0.3/lib/gui/gmtray/eggtrayicon.c.transparent 2006-09-30 00:33:26.000000000 -0400 ++++ ekiga-2.0.3/lib/gui/gmtray/eggtrayicon.c 2006-09-30 00:34:05.000000000 -0400 +@@ -18,22 +18,56 @@ + * Boston, MA 02111-1307, USA. + */ + ++#include + #include +-#ifndef WIN32 ++#include ++ ++#include "eggtrayicon.h" ++ ++#include ++#if defined (GDK_WINDOWING_X11) + #include ++#include ++#elif defined (GDK_WINDOWING_WIN32) ++#include + #endif +-#include "eggtrayicon.h" ++ ++#define _(x) x ++#define N_(x) x + + #define SYSTEM_TRAY_REQUEST_DOCK 0 + #define SYSTEM_TRAY_BEGIN_MESSAGE 1 + #define SYSTEM_TRAY_CANCEL_MESSAGE 2 ++ ++#define SYSTEM_TRAY_ORIENTATION_HORZ 0 ++#define SYSTEM_TRAY_ORIENTATION_VERT 1 ++ ++enum { ++ PROP_0, ++ PROP_ORIENTATION ++}; + + static GtkPlugClass *parent_class = NULL; + + static void egg_tray_icon_init (EggTrayIcon *icon); + static void egg_tray_icon_class_init (EggTrayIconClass *klass); + +-static void egg_tray_icon_update_manager_window (EggTrayIcon *icon); ++static void egg_tray_icon_get_property (GObject *object, ++ guint prop_id, ++ GValue *value, ++ GParamSpec *pspec); ++ ++static void egg_tray_icon_realize (GtkWidget *widget); ++static void egg_tray_icon_unrealize (GtkWidget *widget); ++ ++static void egg_tray_icon_add (GtkContainer *container, ++ GtkWidget *widget); ++ ++#ifdef GDK_WINDOWING_X11 ++static void egg_tray_icon_update_manager_window (EggTrayIcon *icon, ++ gboolean dock_if_realized); ++static void egg_tray_icon_manager_window_destroyed (EggTrayIcon *icon); ++#endif + + GType + egg_tray_icon_get_type (void) +@@ -65,6 +99,7 @@ + egg_tray_icon_init (EggTrayIcon *icon) + { + icon->stamp = 1; ++ icon->orientation = GTK_ORIENTATION_HORIZONTAL; + + gtk_widget_add_events (GTK_WIDGET (icon), GDK_PROPERTY_CHANGE_MASK); + } +@@ -72,7 +107,108 @@ + static void + egg_tray_icon_class_init (EggTrayIconClass *klass) + { ++ GObjectClass *gobject_class = (GObjectClass *)klass; ++ GtkWidgetClass *widget_class = (GtkWidgetClass *)klass; ++ GtkContainerClass *container_class = (GtkContainerClass *)klass; ++ + parent_class = g_type_class_peek_parent (klass); ++ ++ gobject_class->get_property = egg_tray_icon_get_property; ++ ++ widget_class->realize = egg_tray_icon_realize; ++ widget_class->unrealize = egg_tray_icon_unrealize; ++ ++ container_class->add = egg_tray_icon_add; ++ ++ g_object_class_install_property (gobject_class, ++ PROP_ORIENTATION, ++ g_param_spec_enum ("orientation", ++ _("Orientation"), ++ _("The orientation of the tray."), ++ GTK_TYPE_ORIENTATION, ++ GTK_ORIENTATION_HORIZONTAL, ++ G_PARAM_READABLE)); ++ ++#if defined (GDK_WINDOWING_X11) ++ /* Nothing */ ++#elif defined (GDK_WINDOWING_WIN32) ++ g_warning ("Port eggtrayicon to Win32"); ++#else ++ g_warning ("Port eggtrayicon to this GTK+ backend"); ++#endif ++} ++ ++static void ++egg_tray_icon_get_property (GObject *object, ++ guint prop_id, ++ GValue *value, ++ GParamSpec *pspec) ++{ ++ EggTrayIcon *icon = EGG_TRAY_ICON (object); ++ ++ switch (prop_id) ++ { ++ case PROP_ORIENTATION: ++ g_value_set_enum (value, icon->orientation); ++ break; ++ default: ++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); ++ break; ++ } ++} ++ ++#ifdef GDK_WINDOWING_X11 ++ ++static void ++egg_tray_icon_get_orientation_property (EggTrayIcon *icon) ++{ ++ Display *xdisplay; ++ Atom type; ++ int format; ++ union { ++ gulong *prop; ++ guchar *prop_ch; ++ } prop = { NULL }; ++ gulong nitems; ++ gulong bytes_after; ++ int error, result; ++ ++ g_assert (icon->manager_window != None); ++ ++ xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon))); ++ ++ gdk_error_trap_push (); ++ type = None; ++ result = XGetWindowProperty (xdisplay, ++ icon->manager_window, ++ icon->orientation_atom, ++ 0, G_MAXLONG, FALSE, ++ XA_CARDINAL, ++ &type, &format, &nitems, ++ &bytes_after, &(prop.prop_ch)); ++ error = gdk_error_trap_pop (); ++ ++ if (error || result != Success) ++ return; ++ ++ if (type == XA_CARDINAL) ++ { ++ GtkOrientation orientation; ++ ++ orientation = (prop.prop [0] == SYSTEM_TRAY_ORIENTATION_HORZ) ? ++ GTK_ORIENTATION_HORIZONTAL : ++ GTK_ORIENTATION_VERTICAL; ++ ++ if (icon->orientation != orientation) ++ { ++ icon->orientation = orientation; ++ ++ g_object_notify (G_OBJECT (icon), "orientation"); ++ } ++ } ++ ++ if (prop.prop) ++ XFree (prop.prop); + } + + static GdkFilterReturn +@@ -85,19 +221,53 @@ + xev->xclient.message_type == icon->manager_atom && + xev->xclient.data.l[1] == icon->selection_atom) + { +- egg_tray_icon_update_manager_window (icon); ++ egg_tray_icon_update_manager_window (icon, TRUE); + } + else if (xev->xany.window == icon->manager_window) + { ++ if (xev->xany.type == PropertyNotify && ++ xev->xproperty.atom == icon->orientation_atom) ++ { ++ egg_tray_icon_get_orientation_property (icon); ++ } + if (xev->xany.type == DestroyNotify) + { +- egg_tray_icon_update_manager_window (icon); ++ egg_tray_icon_manager_window_destroyed (icon); + } + } +- + return GDK_FILTER_CONTINUE; + } + ++#endif ++ ++static void ++egg_tray_icon_unrealize (GtkWidget *widget) ++{ ++#ifdef GDK_WINDOWING_X11 ++ EggTrayIcon *icon = EGG_TRAY_ICON (widget); ++ GdkWindow *root_window; ++ ++ if (icon->manager_window != None) ++ { ++ GdkWindow *gdkwin; ++ ++ gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (widget), ++ icon->manager_window); ++ ++ gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon); ++ } ++ ++ root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget)); ++ ++ gdk_window_remove_filter (root_window, egg_tray_icon_manager_filter, icon); ++ ++ if (GTK_WIDGET_CLASS (parent_class)->unrealize) ++ (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); ++#endif ++} ++ ++#ifdef GDK_WINDOWING_X11 ++ + static void + egg_tray_icon_send_manager_message (EggTrayIcon *icon, + long message, +@@ -119,11 +289,7 @@ + ev.data.l[3] = data2; + ev.data.l[4] = data3; + +-#if HAVE_GTK_MULTIHEAD + display = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon))); +-#else +- display = gdk_display; +-#endif + + gdk_error_trap_push (); + XSendEvent (display, +@@ -143,29 +309,15 @@ + } + + static void +-egg_tray_icon_update_manager_window (EggTrayIcon *icon) ++egg_tray_icon_update_manager_window (EggTrayIcon *icon, ++ gboolean dock_if_realized) + { + Display *xdisplay; + +-#if HAVE_GTK_MULTIHEAD +- xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon))); +-#else +- xdisplay = gdk_display; +-#endif +- + if (icon->manager_window != None) +- { +- GdkWindow *gdkwin; ++ return; + +-#if HAVE_GTK_MULTIHEAD +- gdkwin = gdk_window_lookup_for_display (display, +- icon->manager_window); +-#else +- gdkwin = gdk_window_lookup (icon->manager_window); +-#endif +- +- gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon); +- } ++ xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon))); + + XGrabServer (xdisplay); + +@@ -174,7 +326,7 @@ + + if (icon->manager_window != None) + XSelectInput (xdisplay, +- icon->manager_window, StructureNotifyMask); ++ icon->manager_window, StructureNotifyMask|PropertyChangeMask); + + XUngrabServer (xdisplay); + XFlush (xdisplay); +@@ -183,87 +335,135 @@ + { + GdkWindow *gdkwin; + +-#if HAVE_GTK_MULTIHEAD + gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (GTK_WIDGET (icon)), + icon->manager_window); +-#else +- gdkwin = gdk_window_lookup (icon->manager_window); +-#endif + + gdk_window_add_filter (gdkwin, egg_tray_icon_manager_filter, icon); + +- /* Send a request that we'd like to dock */ +- egg_tray_icon_send_dock_request (icon); ++ if (dock_if_realized && GTK_WIDGET_REALIZED (icon)) ++ egg_tray_icon_send_dock_request (icon); ++ ++ egg_tray_icon_get_orientation_property (icon); + } + } + +-EggTrayIcon * +-egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name) ++static void ++egg_tray_icon_manager_window_destroyed (EggTrayIcon *icon) + { +- EggTrayIcon *icon; ++ GdkWindow *gdkwin; ++ ++ g_return_if_fail (icon->manager_window != None); ++ ++ gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (GTK_WIDGET (icon)), ++ icon->manager_window); ++ ++ gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon); ++ ++ icon->manager_window = None; ++ ++ egg_tray_icon_update_manager_window (icon, TRUE); ++} ++ ++#endif ++ ++static gboolean ++transparent_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data) ++{ ++ gdk_window_clear_area (widget->window, event->area.x, event->area.y, ++ event->area.width, event->area.height); ++ return FALSE; ++} ++ ++static void ++make_transparent_again (GtkWidget *widget, GtkStyle *previous_style, ++ gpointer user_data) ++{ ++ gdk_window_set_back_pixmap (widget->window, NULL, TRUE); ++} ++ ++static void ++make_transparent (GtkWidget *widget, gpointer user_data) ++{ ++ if (GTK_WIDGET_NO_WINDOW (widget) || GTK_WIDGET_APP_PAINTABLE (widget)) ++ return; ++ ++ gtk_widget_set_app_paintable (widget, TRUE); ++ gtk_widget_set_double_buffered (widget, FALSE); ++ gdk_window_set_back_pixmap (widget->window, NULL, TRUE); ++ g_signal_connect (widget, "expose_event", ++ G_CALLBACK (transparent_expose_event), NULL); ++ g_signal_connect_after (widget, "style_set", ++ G_CALLBACK (make_transparent_again), NULL); ++} ++ ++static void ++egg_tray_icon_realize (GtkWidget *widget) ++{ ++#ifdef GDK_WINDOWING_X11 ++ EggTrayIcon *icon = EGG_TRAY_ICON (widget); ++ GdkScreen *screen; ++ GdkDisplay *display; ++ Display *xdisplay; + char buffer[256]; + GdkWindow *root_window; + +- 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); ++ if (GTK_WIDGET_CLASS (parent_class)->realize) ++ GTK_WIDGET_CLASS (parent_class)->realize (widget); + +-#if HAVE_GTK_MULTIHEAD +- gtk_plug_construct_for_display (GTK_PLUG (icon), +- gdk_screen_get_display (screen), 0); +-#else +- gtk_plug_construct (GTK_PLUG (icon), 0); +-#endif +- +- gtk_widget_realize (GTK_WIDGET (icon)); ++ make_transparent (widget, NULL); ++ ++ screen = gtk_widget_get_screen (widget); ++ display = gdk_screen_get_display (screen); ++ xdisplay = gdk_x11_display_get_xdisplay (display); + + /* 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); ++ gdk_screen_get_number (screen)); ++ ++ icon->selection_atom = XInternAtom (xdisplay, buffer, False); + +- icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen), +- "MANAGER", False); ++ icon->manager_atom = XInternAtom (xdisplay, "MANAGER", False); + +- icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen), +- "_NET_SYSTEM_TRAY_OPCODE", False); ++ icon->system_tray_opcode_atom = XInternAtom (xdisplay, ++ "_NET_SYSTEM_TRAY_OPCODE", ++ False); + +- egg_tray_icon_update_manager_window (icon); ++ icon->orientation_atom = XInternAtom (xdisplay, ++ "_NET_SYSTEM_TRAY_ORIENTATION", ++ False); ++ ++ egg_tray_icon_update_manager_window (icon, FALSE); ++ egg_tray_icon_send_dock_request (icon); + +-#if HAVE_GTK_MULTIHEAD + root_window = gdk_screen_get_root_window (screen); +-#else +- root_window = gdk_window_lookup (gdk_x11_get_default_root_xwindow ()); +-#endif + + /* 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; ++#endif ++} ++ ++static void ++egg_tray_icon_add (GtkContainer *container, GtkWidget *widget) ++{ ++ g_signal_connect (widget, "realize", ++ G_CALLBACK (make_transparent), NULL); ++ GTK_CONTAINER_CLASS (parent_class)->add (container, widget); + } + +-#if HAVE_GTK_MULTIHEAD + EggTrayIcon * + egg_tray_icon_new_for_screen (GdkScreen *screen, const char *name) + { +- EggTrayIcon *icon; +- char buffer[256]; +- + g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); + +- return egg_tray_icon_new_for_xscreen (GDK_SCREEN_XSCREEN (screen), name); ++ return g_object_new (EGG_TYPE_TRAY_ICON, "screen", screen, "title", name, NULL); + } +-#endif + + EggTrayIcon* + egg_tray_icon_new (const gchar *name) + { +- return egg_tray_icon_new_for_xscreen (DefaultScreenOfDisplay (gdk_display), name); ++ return g_object_new (EGG_TYPE_TRAY_ICON, "title", name, NULL); + } + + guint +@@ -278,17 +478,20 @@ + g_return_val_if_fail (timeout >= 0, 0); + g_return_val_if_fail (message != NULL, 0); + ++#ifdef GDK_WINDOWING_X11 + if (icon->manager_window == None) + return 0; ++#endif + + if (len < 0) + len = strlen (message); + + stamp = icon->stamp++; + ++#ifdef GDK_WINDOWING_X11 + /* Get ready to send the message */ + egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_BEGIN_MESSAGE, +- (Window)gtk_plug_get_id (GTK_PLUG (icon)), ++ icon->manager_window, + timeout, len, stamp); + + /* Now to send the actual message */ +@@ -298,14 +501,10 @@ + XClientMessageEvent ev; + Display *xdisplay; + +-#if HAVE_GTK_MULTIHEAD + xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon))); +-#else +- xdisplay = gdk_display; +-#endif + + ev.type = ClientMessage; +- ev.window = (Window)gtk_plug_get_id (GTK_PLUG (icon)); ++ ev.window = icon->manager_window; + ev.format = 8; + ev.message_type = XInternAtom (xdisplay, + "_NET_SYSTEM_TRAY_MESSAGE_DATA", False); +@@ -326,6 +525,7 @@ + XSync (xdisplay, False); + } + gdk_error_trap_pop (); ++#endif + + return stamp; + } +@@ -336,8 +536,17 @@ + { + g_return_if_fail (EGG_IS_TRAY_ICON (icon)); + g_return_if_fail (id > 0); +- ++#ifdef GDK_WINDOWING_X11 + egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_CANCEL_MESSAGE, + (Window)gtk_plug_get_id (GTK_PLUG (icon)), + id, 0, 0); ++#endif ++} ++ ++GtkOrientation ++egg_tray_icon_get_orientation (EggTrayIcon *icon) ++{ ++ g_return_val_if_fail (EGG_IS_TRAY_ICON (icon), GTK_ORIENTATION_HORIZONTAL); ++ ++ return icon->orientation; + } diff --git a/ekiga.spec b/ekiga.spec index 2e0252f..26079c1 100644 --- a/ekiga.spec +++ b/ekiga.spec @@ -1,9 +1,12 @@ Summary: A Gnome based SIP/H323 teleconferencing application Name: ekiga -Version: 2.0.3 -Release: 1 +Version: 2.0.2 +Release: 7 URL: http://www.ekiga.org/ -Source0: http://www.ekiga.org/ekiga-%{version}.tar.bz2 +Source0: http://www.ekiga.org/ekiga-%{version}.tar.gz +# fixed in upstream cvs +Patch0: ekiga-2.0.2-translator-credits.patch +Patch1: ekiga-2.0.2-transparent.patch License: GPL Group: Applications/Communications BuildRoot: %{_tmppath}/%{name}-%{version}-root @@ -45,6 +48,8 @@ It uses the standard SIP and H323 protocols. %prep %setup -q +%patch0 -p1 -b .translator-credits +%patch1 -p1 -b .transparent %build CXXFLAGS="$RPM_OPT_FLAGS -DLDAP_DEPRECATED=1 -fPIC" @@ -93,8 +98,8 @@ scrollkeeper-update %{_sysconfdir}/gconf/schemas/ekiga.schemas %changelog -* Tue Sep 5 2006 Matthias Clasen - 2.0.3-1 -- Update to 2.0.3 +* Sat Sep 30 2006 Matthias Clasen - 2.0.2-7 +- Make the status icon work in transparent panels * Thu Aug 31 2006 Matthias Clasen - 2.0.2-6 - Fix translator credits (197871) diff --git a/sources b/sources index 260aacd..7597778 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -37c57468c7c15ff9bcea91e7fc32aea9 ekiga-2.0.3.tar.bz2 +569e0f79ec018ca3e8f2979449dd6f0f ekiga-2.0.2.tar.gz