char *
na_tray_manager_get_child_title (NaTrayManager *manager,
NaTrayManagerChild *child)
{
char *retval = NULL;
#ifdef GDK_WINDOWING_X11
GdkDisplay *display;
Window *child_window;
Atom utf8_string, atom, type;
int result;
int format;
gulong nitems;
gulong bytes_after;
gchar *val;
g_return_val_if_fail (NA_IS_TRAY_MANAGER (manager), NULL);
g_return_val_if_fail (GTK_IS_SOCKET (child), NULL);
display = gdk_screen_get_display (manager->screen);
child_window = g_object_get_data (G_OBJECT (child),
"na-tray-child-window");
utf8_string = gdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING");
atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_NAME");
gdk_error_trap_push ();
result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
*child_window,
atom,
0, G_MAXLONG,
False, utf8_string,
&type, &format, &nitems,
&bytes_after, (guchar **)&val);
if (gdk_error_trap_pop () || result != Success)
return NULL;
if (type != utf8_string ||
format != 8 ||
nitems == 0)
{
if (val)
XFree (val);
return NULL;
}
if (!g_utf8_validate (val, nitems, NULL))
{
XFree (val);
return NULL;
}
retval = g_strndup (val, nitems);
XFree (val);
#endif
return retval;
}
char *
egg_tray_manager_get_child_title (EggTrayManager *manager,
EggTrayManagerChild *child)
{
Window *child_window;
Atom utf8_string, atom, type;
int result;
gchar *val, *retval;
int format;
gulong nitems;
gulong bytes_after;
guchar *tmp;
g_return_val_if_fail (EGG_IS_TRAY_MANAGER (manager), NULL);
g_return_val_if_fail (GTK_IS_SOCKET (child), NULL);
child_window = g_object_get_data (G_OBJECT (child),
"egg-tray-child-window");
utf8_string = XInternAtom (GDK_DISPLAY (), "UTF8_STRING", False);
atom = XInternAtom (GDK_DISPLAY (), "_NET_WM_NAME", False);
gdk_error_trap_push ();
result = XGetWindowProperty (GDK_DISPLAY (),
*child_window,
atom,
0, G_MAXLONG,
False, utf8_string,
&type, &format, &nitems,
&bytes_after, &tmp);
val = (gchar *) tmp;
if (gdk_error_trap_pop () || result != Success)
return NULL;
if (type != utf8_string ||
format != 8 ||
nitems == 0)
{
if (val)
XFree (val);
return NULL;
}
if (!g_utf8_validate (val, nitems, NULL))
{
XFree (val);
return NULL;
}
retval = g_strndup (val, nitems);
XFree (val);
return retval;
}
static gboolean
panel_key_press_event (GtkWidget *widget,
GdkEventKey *event)
{
/*
* If the focus widget is a GtkSocket, i.e. the
* focus is in an applet in another process, then key
* bindings do not work. We get around this by
* activating the key bindings here.
*/
if (GTK_IS_SOCKET (gtk_window_get_focus (GTK_WINDOW (widget))) &&
event->keyval == GDK_F10 &&
(event->state & gtk_accelerator_get_default_mod_mask ()) == GDK_CONTROL_MASK)
return gtk_bindings_activate (GTK_OBJECT (widget),
event->keyval,
event->state);
return FALSE;
}
void ScrollView::platformAddChild(Widget* child)
{
if (!GTK_IS_SOCKET(child->platformWidget()))
gtk_container_add(GTK_CONTAINER(hostWindow()->platformWindow()), child->platformWidget());
}
static gboolean
gail_focus_watcher (GSignalInvocationHint *ihint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
GObject *object;
GtkWidget *widget;
GdkEvent *event;
object = g_value_get_object (param_values + 0);
g_return_val_if_fail (GTK_IS_WIDGET(object), FALSE);
event = g_value_get_boxed (param_values + 1);
widget = GTK_WIDGET (object);
if (event->type == GDK_FOCUS_CHANGE)
{
if (event->focus_change.in)
{
if (GTK_IS_WINDOW (widget))
{
GtkWidget *focus_widget;
GtkWindow *window;
GtkWindowType type;
window = GTK_WINDOW (widget);
focus_widget = gtk_window_get_focus (window);
g_object_get (window, "type", &type, NULL);
if (focus_widget)
{
/*
* If we already have a potential focus widget set this
* windows's focus widget to focus_before_menu so that
* it will be reported when menu item is unset.
*/
if (next_focus_widget)
{
if (GTK_IS_MENU_ITEM (next_focus_widget) &&
!focus_before_menu)
{
void *vp_focus_before_menu = &focus_before_menu;
focus_before_menu = focus_widget;
g_object_add_weak_pointer (G_OBJECT (focus_before_menu), vp_focus_before_menu);
}
return TRUE;
}
widget = focus_widget;
}
else if (type == GTK_WINDOW_POPUP)
{
if (GTK_IS_BIN (widget))
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget));
if (GTK_IS_WIDGET (child) && gtk_widget_has_grab (child))
{
if (GTK_IS_MENU_SHELL (child))
{
if (gtk_menu_shell_get_selected_item (GTK_MENU_SHELL (child)))
{
/*
* We have a menu which has a menu item selected
* so we do not report focus on the menu.
*/
return TRUE;
}
}
widget = child;
}
}
else /* popup window has no children; this edge case occurs in some custom code (OOo for instance) */
{
return TRUE;
}
}
else /* Widget is a non-popup toplevel with no focus children;
don't emit for this case either, as it's useless */
{
return TRUE;
}
}
}
else
{
if (next_focus_widget)
{
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (next_focus_widget);
if (toplevel == widget)
next_focus_widget = NULL;
}
/* focus out */
widget = NULL;
}
}
else
{
if (event->type == GDK_MOTION_NOTIFY && gtk_widget_has_focus (widget))
{
if (widget == _focus_widget)
{
return TRUE;
}
}
else
{
return TRUE;
}
}
#ifdef GDK_WINDOWING_X11
/*
* If the focus widget is a GtkSocket without a plug
* then ignore the focus notification as the embedded
* plug will report a focus notification.
*/
if (GTK_IS_SOCKET (widget) &&
gtk_socket_get_plug_window (GTK_SOCKET (widget)) != NULL)
return TRUE;
#endif
/*
* The widget may not yet be visible on the screen so we wait until it is.
*/
gail_focus_notify_when_idle (widget);
return TRUE;
}
/* Establish the widget placement of an icon grid. */
static gboolean icon_grid_placement(IconGrid * ig)
{
/* Make sure the container is visible. */
gtk_widget_show(ig->container);
/* Erase the window. */
GdkWindow * window = ig->widget->window;
if (window != NULL)
panel_determine_background_pixmap(ig->panel, ig->widget, window);
/* Get and save the desired container geometry. */
ig->container_width = ig->container->allocation.width;
ig->container_height = ig->container->allocation.height;
int child_width = ig->child_width;
int child_height = ig->child_height;
/* Get the required container geometry if all elements get the client's desired allocation. */
int container_width_needed = (ig->columns * (child_width + ig->spacing)) - ig->spacing;
int container_height_needed = (ig->rows * (child_height + ig->spacing)) - ig->spacing;
/* Get the constrained child geometry if the allocated geometry is insufficient.
* All children are still the same size and share equally in the deficit. */
ig->constrained_child_width = ig->child_width;
if ((ig->columns != 0) && (ig->rows != 0) && (ig->container_width > 1))
{
if (container_width_needed > ig->container_width)
ig->constrained_child_width = child_width = (ig->container_width - ((ig->columns - 1) * ig->spacing)) / ig->columns;
if (container_height_needed > ig->container_height)
child_height = (ig->container_height - ((ig->rows - 1) * ig->spacing)) / ig->rows;
}
/* Initialize parameters to control repositioning each visible child. */
GtkTextDirection direction = gtk_widget_get_direction(ig->container);
int limit = ig->border + ((ig->orientation == GTK_ORIENTATION_HORIZONTAL)
? (ig->rows * (child_height + ig->spacing))
: (ig->columns * (child_width + ig->spacing)));
int x_initial = ((direction == GTK_TEXT_DIR_RTL)
? ig->widget->allocation.width - child_width - ig->border
: ig->border);
int x_delta = child_width + ig->spacing;
if (direction == GTK_TEXT_DIR_RTL) x_delta = - x_delta;
/* Reposition each visible child. */
int x = x_initial;
int y = ig->border;
gboolean contains_sockets = FALSE;
IconGridElement * ige;
for (ige = ig->child_list; ige != NULL; ige = ige->flink)
{
if (ige->visible)
{
/* Do necessary operations on the child. */
gtk_widget_show(ige->widget);
if (((child_width != ige->widget->allocation.width) || (child_height != ige->widget->allocation.height))
&& (child_width > 0) && (child_height > 0))
{
GtkAllocation alloc;
alloc.x = x;
alloc.y = y;
alloc.width = child_width;
alloc.height = child_height;
gtk_widget_size_allocate(ige->widget, &alloc);
gtk_widget_queue_resize(ige->widget); /* Get labels to redraw ellipsized */
}
gtk_fixed_move(GTK_FIXED(ig->widget), ige->widget, x, y);
gtk_widget_queue_draw(ige->widget);
/* Note if a socket is placed. */
if (GTK_IS_SOCKET(ige->widget))
contains_sockets = TRUE;
/* Advance to the next grid position. */
if (ig->orientation == GTK_ORIENTATION_HORIZONTAL)
{
y += child_height + ig->spacing;
if (y >= limit)
{
y = ig->border;
x += x_delta;
}
}
else
{
x += x_delta;
if ((direction == GTK_TEXT_DIR_RTL) ? (x <= 0) : (x >= limit))
{
x = x_initial;
y += child_height + ig->spacing;
}
}
}
}
/* Redraw the container. */
if (window != NULL)
gdk_window_invalidate_rect(window, NULL, TRUE);
gtk_widget_queue_draw(ig->container);
/* If the icon grid contains sockets, do special handling to get the background erased. */
if (contains_sockets)
plugin_widget_set_background(ig->widget, ig->panel);
return FALSE;
}