/**
* gtk_ellipsis_set_expanded:
* @ellipsis: a #GtkEllipsis
* @expanded: whether the child widget is revealed
*
* Sets the state of the ellipsis. Set to %TRUE, if you want
* the child widget to be revealed, and %FALSE if you want the
* child widget to be hidden.
*
* Since: 2.4
**/
void
gtk_ellipsis_set_expanded (GtkEllipsis *ellipsis,
gboolean expanded)
{
GtkEllipsisPrivate *priv;
g_return_if_fail (GTK_IS_ELLIPSIS (ellipsis));
priv = ellipsis->priv;
expanded = expanded != FALSE;
if (priv->expanded != expanded)
{
GtkWidget *child = GTK_BIN (ellipsis)->child;
priv->expanded = expanded;
if (child)
{
if (!expanded && GTK_WIDGET_MAPPED (child))
gtk_widget_unmap (child);
if (expanded && GTK_WIDGET_MAPPED (priv->label))
{
if (GTK_WIDGET_REALIZED (ellipsis))
gdk_window_hide (priv->event_window);
gtk_widget_unmap (priv->ellipsis_label);
gtk_widget_unmap (priv->label);
}
if (GTK_WIDGET_MAPPED (ellipsis))
{
if (expanded && GTK_WIDGET_VISIBLE (child))
gtk_widget_map (child);
if (!expanded && GTK_WIDGET_VISIBLE (priv->label))
{
gtk_widget_map (priv->label);
gtk_widget_map (priv->ellipsis_label);
if (GTK_WIDGET_REALIZED (ellipsis))
gdk_window_show (priv->event_window);
}
}
gtk_widget_queue_resize (GTK_WIDGET (ellipsis));
}
g_object_notify (G_OBJECT (ellipsis), "expanded");
}
}
/**
* mate_druid_set_page:
* @druid: A #MateDruid widget.
* @page: The #MateDruidPage to be brought to the foreground.
*
* Description: This will make @page the currently showing page in the druid.
* @page must already be in the druid.
**/
void
mate_druid_set_page (MateDruid *druid,
MateDruidPage *page)
{
GList *list;
GtkWidget *old = NULL;
g_return_if_fail (druid != NULL);
g_return_if_fail (MATE_IS_DRUID (druid));
g_return_if_fail (page != NULL);
g_return_if_fail (MATE_IS_DRUID_PAGE (page));
if (druid->_priv->current == page)
return;
list = g_list_find (druid->_priv->children, page);
g_return_if_fail (list != NULL);
if ((druid->_priv->current) && (GTK_WIDGET_VISIBLE (druid->_priv->current)) && (GTK_WIDGET_MAPPED (druid))) {
old = GTK_WIDGET (druid->_priv->current);
}
druid->_priv->current = MATE_DRUID_PAGE (list->data);
mate_druid_page_prepare (druid->_priv->current);
if (GTK_WIDGET_VISIBLE (druid->_priv->current) && (GTK_WIDGET_MAPPED (druid))) {
gtk_widget_map (GTK_WIDGET (druid->_priv->current));
gtk_widget_set_sensitive (GTK_WIDGET (druid->_priv->current), TRUE);
}
if (old && GTK_WIDGET_MAPPED (old)) {
gtk_widget_unmap (old);
gtk_widget_set_sensitive (old, FALSE);
}
}
static void
gtk_pizza_position_child (GtkPizza *pizza,
GtkPizzaChild *child)
{
gint x;
gint y;
x = child->x - pizza->xoffset;
y = child->y - pizza->yoffset;
if (IS_ONSCREEN (x,y))
{
if (GTK_WIDGET_MAPPED (pizza) &&
GTK_WIDGET_VISIBLE (child->widget))
{
if (!GTK_WIDGET_MAPPED (child->widget))
gtk_widget_map (child->widget);
}
if (GTK_WIDGET_IS_OFFSCREEN (child->widget))
GTK_PRIVATE_UNSET_FLAG (child->widget, GTK_IS_OFFSCREEN);
}
else
{
if (!GTK_WIDGET_IS_OFFSCREEN (child->widget))
GTK_PRIVATE_SET_FLAG (child->widget, GTK_IS_OFFSCREEN);
if (GTK_WIDGET_MAPPED (child->widget))
gtk_widget_unmap (child->widget);
}
}
/**
* For details of what is expected from an icon window and what it
* should expect.
*
* See --
* http://tronche.com/gui/x/icccm/sec-4.html#s-4.1.9
*/
G_GNUC_COLD void
icon_init(void)
{
create_icon();
gtk_widget_realize(icon);
/*
* For some reason, when a window is the icon for another
* window, none of its subwindows get mapped. This is not
* because of GTK, but seems to be either the window manager
* or X itself that does this.
*
* Also note the canvas widget is never unmapped, regardless
* of whether the icon window is visible or not.
*/
gtk_widget_map(canvas);
/* FIXME: This causes a crash with twm when iconizing the main window. */
#if 0
gdk_window_set_icon(gui_main_window()->window, icon->window, NULL, NULL);
#endif
icon_just_mapped_fg = icon_visible_fg = icon_close_fg = FALSE;
/* load images */
con_pixbuf = create_pixbuf("smallserver.xpm");
up_pixbuf = create_pixbuf("upload.xpm");
down_pixbuf = create_pixbuf("download.xpm");
status_icon_init();
main_gui_add_timer(icon_timer);
}
static void
awt_gtk_panel_add (GtkContainer *container, GtkWidget *widget)
{
AWTGtkPanel *panel = AWT_GTK_PANEL(container);
g_return_if_fail (panel != NULL);
g_return_if_fail (widget != NULL);
gtk_widget_set_parent (widget, GTK_WIDGET (panel));
/* Add at start of list using g_list_prepend to ensure widgets are added behind
other widgets if they are added later. */
panel->children = g_list_prepend (panel->children, widget);
if (GTK_WIDGET_REALIZED (panel))
gtk_widget_realize (widget);
if (GTK_WIDGET_VISIBLE (panel) && GTK_WIDGET_VISIBLE (widget))
{
if (GTK_WIDGET_MAPPED (panel))
gtk_widget_map (widget);
gtk_widget_queue_resize (GTK_WIDGET (panel));
}
}
/**
* gdl_dock_add_floating_item:
* @dock: A #GdlDock widget
* @item: A #GdlDockItem widget
* @x: X coordinate of the floating item
* @y: Y coordinate of the floating item
* @width: width of the floating item
* @height: height of the floating item
*
* Dock an item as a floating item. It creates a new window containing a new
* dock widget sharing the same master where the item is docked.
*/
void
gdl_dock_add_floating_item (GdlDock *dock,
GdlDockItem *item,
gint x,
gint y,
gint width,
gint height)
{
GdlDock *new_dock;
g_return_if_fail (dock != NULL);
g_return_if_fail (item != NULL);
new_dock = GDL_DOCK (g_object_new (GDL_TYPE_DOCK,
"master", gdl_dock_object_get_master (GDL_DOCK_OBJECT (dock)),
"floating", TRUE,
"width", width,
"height", height,
"floatx", x,
"floaty", y,
"skip-taskbar", dock->priv->skip_taskbar,
NULL));
if (gtk_widget_get_visible (GTK_WIDGET (dock))) {
gtk_widget_show (GTK_WIDGET (new_dock));
if (gtk_widget_get_mapped (GTK_WIDGET (dock)))
gtk_widget_map (GTK_WIDGET (new_dock));
/* Make the widget resize. */
gtk_widget_queue_resize (GTK_WIDGET (new_dock));
}
gdl_dock_add_item (GDL_DOCK (new_dock), item, GDL_DOCK_TOP);
}
void columns_add(Columns *cols, GtkWidget *child, gint colstart, gint colspan)
{
ColumnsChild *childdata;
g_return_if_fail(cols != NULL);
g_return_if_fail(IS_COLUMNS(cols));
g_return_if_fail(child != NULL);
g_return_if_fail(gtk_widget_get_parent(child) == NULL);
childdata = g_new(ColumnsChild, 1);
childdata->widget = child;
childdata->colstart = colstart;
childdata->colspan = colspan;
childdata->force_left = FALSE;
childdata->same_height_as = NULL;
cols->children = g_list_append(cols->children, childdata);
cols->taborder = g_list_append(cols->taborder, child);
gtk_widget_set_parent(child, GTK_WIDGET(cols));
#if GTK_CHECK_VERSION(2, 0, 0)
gtk_container_set_focus_chain(GTK_CONTAINER(cols), cols->taborder);
#endif
if (gtk_widget_get_realized(GTK_WIDGET(cols)))
gtk_widget_realize(child);
if (gtk_widget_get_visible(GTK_WIDGET(cols)) &&
gtk_widget_get_visible(child)) {
if (gtk_widget_get_mapped(GTK_WIDGET(cols)))
gtk_widget_map(child);
gtk_widget_queue_resize(child);
}
}
/**
* eel_gtk_container_child_add:
*
* @container: A GtkContainer widget.
* @child: A non NULL unparented child.
*
* Add a @child to a @container. The @child is realized, mapped
* and resized if needed. This is usually called from the "GtkContainer::add"
* method of the @container. The @child cannot be NULL.
*/
void
eel_gtk_container_child_add (GtkContainer *container,
GtkWidget *child)
{
GtkWidget *widget;
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (GTK_IS_WIDGET (child));
widget = GTK_WIDGET (container);
gtk_widget_set_parent (child, widget);
if (gtk_widget_get_realized (widget))
{
gtk_widget_realize (child);
}
if (gtk_widget_get_mapped (widget)
&& gtk_widget_get_visible (child))
{
if (gtk_widget_get_mapped (widget))
{
gtk_widget_map (child);
}
gtk_widget_queue_resize (child);
}
}
static void
gtk_application_window_real_map (GtkWidget *widget)
{
GtkApplicationWindow *window = GTK_APPLICATION_WINDOW (widget);
/* XXX could eliminate this by tweaking gtk_window_map */
if (window->priv->menubar)
gtk_widget_map (window->priv->menubar);
#ifdef GDK_WINDOWING_WAYLAND
{
GdkWindow *gdkwindow;
GtkApplication *application;
application = gtk_window_get_application (GTK_WINDOW (window));
gdkwindow = gtk_widget_get_window (widget);
if (GDK_IS_WAYLAND_WINDOW (gdkwindow) && window->priv->session)
{
gdk_wayland_window_set_dbus_properties_libgtk_only (gdkwindow,
g_application_get_application_id (G_APPLICATION (application)),
gtk_application_get_app_menu_object_path (application),
gtk_application_get_menubar_object_path (application),
window->priv->object_path,
g_application_get_dbus_object_path (G_APPLICATION (application)),
g_dbus_connection_get_unique_name (window->priv->session));
}
}
#endif
GTK_WIDGET_CLASS (gtk_application_window_parent_class)->map (widget);
}
void columns_add(Columns *cols, GtkWidget *child,
gint colstart, gint colspan)
{
ColumnsChild *childdata;
g_return_if_fail(cols != NULL);
g_return_if_fail(IS_COLUMNS(cols));
g_return_if_fail(child != NULL);
g_return_if_fail(child->parent == NULL);
childdata = g_new(ColumnsChild, 1);
childdata->widget = child;
childdata->colstart = colstart;
childdata->colspan = colspan;
childdata->force_left = FALSE;
cols->children = g_list_append(cols->children, childdata);
cols->taborder = g_list_append(cols->taborder, child);
gtk_widget_set_parent(child, GTK_WIDGET(cols));
if (GTK_WIDGET_REALIZED(cols))
gtk_widget_realize(child);
if (GTK_WIDGET_VISIBLE(cols) && GTK_WIDGET_VISIBLE(child)) {
if (GTK_WIDGET_MAPPED(cols))
gtk_widget_map(child);
gtk_widget_queue_resize(child);
}
}
static void
menu_item_style_set (GtkImage *image,
gpointer data)
{
GtkWidget *widget;
GdkPixbuf *pixbuf;
GtkIconSize icon_size = (GtkIconSize) GPOINTER_TO_INT (data);
int icon_height;
gboolean is_mapped;
if (!gtk_icon_size_lookup (icon_size, NULL, &icon_height))
return;
pixbuf = gtk_image_get_pixbuf (image);
if (!pixbuf)
return;
if (gdk_pixbuf_get_height (pixbuf) == icon_height)
return;
widget = GTK_WIDGET (image);
is_mapped = gtk_widget_get_mapped (widget);
if (is_mapped)
gtk_widget_unmap (widget);
gtk_image_set_from_pixbuf (image, NULL);
if (is_mapped)
gtk_widget_map (widget);
}
static void
exo_wrap_table_add (GtkContainer *container,
GtkWidget *widget)
{
ExoWrapTable *table = EXO_WRAP_TABLE (container);
/* take over ownership */
gtk_widget_set_parent (widget, GTK_WIDGET (table));
/* add the child to our internal list */
table->priv->children = g_list_append (table->priv->children, widget);
/* realize the widget if required */
if (gtk_widget_get_realized (GTK_WIDGET (container)))
gtk_widget_realize (widget);
/* map the widget if required */
if (gtk_widget_get_visible (GTK_WIDGET (container)) && gtk_widget_get_visible (widget))
{
if (gtk_widget_get_mapped (GTK_WIDGET (container)))
gtk_widget_map (widget);
}
/* queue a resize on the table */
gtk_widget_queue_resize (GTK_WIDGET (container));
}
static void
awt_gtk_panel_map (GtkWidget *widget)
{
AWTGtkPanel *panel;
GtkWidget *child;
GList *children;
g_return_if_fail (widget != NULL);
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
panel = AWT_GTK_PANEL (widget);
children = panel->children;
while (children)
{
child = children->data;
children = children->next;
if (GTK_WIDGET_VISIBLE (child) &&
!GTK_WIDGET_MAPPED (child))
gtk_widget_map (child);
}
gdk_window_show (widget->window);
}
void
moz_container_map (GtkWidget *widget)
{
MozContainer *container;
GList *tmp_list;
GtkWidget *tmp_child;
g_return_if_fail (IS_MOZ_CONTAINER(widget));
container = MOZ_CONTAINER (widget);
gtk_widget_set_mapped(widget, TRUE);
tmp_list = container->children;
while (tmp_list) {
tmp_child = ((MozContainerChild *)tmp_list->data)->widget;
if (gtk_widget_get_visible(tmp_child)) {
if (!gtk_widget_get_mapped(tmp_child))
gtk_widget_map(tmp_child);
}
tmp_list = tmp_list->next;
}
gdk_window_show (gtk_widget_get_window(widget));
}
static void
gtk_pizza_map (GtkWidget *widget)
{
GtkPizza *pizza;
GtkPizzaChild *child;
GList *children;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_PIZZA (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
pizza = GTK_PIZZA (widget);
children = pizza->children;
while (children)
{
child = children->data;
children = children->next;
if ( GTK_WIDGET_VISIBLE (child->widget) &&
!GTK_WIDGET_MAPPED (child->widget) &&
!GTK_WIDGET_IS_OFFSCREEN (child->widget))
{
gtk_widget_map (child->widget);
}
}
gdk_window_show (widget->window);
gdk_window_show (pizza->bin_window);
}
void
gdl_dock_add_floating_item (GdlDock *dock,
GdlDockItem *item,
gint x,
gint y,
gint width,
gint height)
{
GdlDock *new_dock;
g_return_if_fail (dock != NULL);
g_return_if_fail (item != NULL);
new_dock = GDL_DOCK (g_object_new (GDL_TYPE_DOCK,
"master", GDL_DOCK_OBJECT_GET_MASTER (dock),
"floating", TRUE,
"width", width,
"height", height,
"floatx", x,
"floaty", y,
NULL));
if (GTK_WIDGET_VISIBLE (dock)) {
gtk_widget_show (GTK_WIDGET (new_dock));
if (GTK_WIDGET_MAPPED (dock))
gtk_widget_map (GTK_WIDGET (new_dock));
/* Make the widget resize. */
gtk_widget_queue_resize (GTK_WIDGET (new_dock));
}
gdl_dock_add_item (GDL_DOCK (new_dock), item, GDL_DOCK_TOP);
}
void
_shell_embedded_window_realize (ShellEmbeddedWindow *window)
{
g_return_if_fail (SHELL_IS_EMBEDDED_WINDOW (window));
if (gtk_widget_get_visible (GTK_WIDGET (window)))
gtk_widget_map (GTK_WIDGET (window));
}
void
_cinnamon_embedded_window_realize (CinnamonEmbeddedWindow *window)
{
g_return_if_fail (CINNAMON_IS_EMBEDDED_WINDOW (window));
if (gtk_widget_get_visible (GTK_WIDGET (window)))
gtk_widget_map (GTK_WIDGET (window));
}
static void
mate_druid_map (GtkWidget *widget)
{
MateDruid *druid;
g_return_if_fail (widget != NULL);
g_return_if_fail (MATE_IS_DRUID (widget));
druid = MATE_DRUID (widget);
GTK_WIDGET_SET_FLAGS (druid, GTK_MAPPED);
#if 0
gtk_widget_map (druid->back);
if (druid->_priv->show_finish)
gtk_widget_map (druid->finish);
else
gtk_widget_map (druid->next);
if (druid->_priv->show_help)
gtk_widget_map (druid->help);
gtk_widget_map (druid->cancel);
#endif
gtk_widget_map (druid->_priv->bbox);
if (druid->_priv->current &&
GTK_WIDGET_VISIBLE (druid->_priv->current) &&
!GTK_WIDGET_MAPPED (druid->_priv->current)) {
gtk_widget_map (GTK_WIDGET (druid->_priv->current));
}
}
void TestController::setHidden(bool hidden)
{
if (!m_mainWebView)
return;
if (hidden)
gtk_widget_unmap(GTK_WIDGET(m_mainWebView->platformView()));
else
gtk_widget_map(GTK_WIDGET(m_mainWebView->platformView()));
}
static void
foo_canvas_widget_map (FooCanvasItem *item)
{
FooCanvasWidget *witem = FOO_CANVAS_WIDGET (item);
if (parent_class->map)
(* parent_class->map) (item);
if (witem->widget && gtk_widget_get_visible (witem->widget))
gtk_widget_map (witem->widget);
}
static void
gtk_ellipsis_map (GtkWidget *widget)
{
GtkEllipsisPrivate *priv = GTK_ELLIPSIS (widget)->priv;
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
if (priv->event_window)
gdk_window_show (priv->event_window);
if (priv->expanded)
gtk_widget_map (GTK_BIN (widget)->child);
else if (priv->label)
{
gtk_widget_map (priv->label);
gtk_widget_map (priv->ellipsis_label);
}
}
int
clip_GTK_WIDGETMAP(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
CHECKCWID(cwid,GTK_IS_WIDGET);
gtk_widget_map(cwid->widget);
return 0;
err:
return 1;
}
static void
gtk_application_window_real_map (GtkWidget *widget)
{
GtkApplicationWindow *window = GTK_APPLICATION_WINDOW (widget);
/* XXX could eliminate this by tweaking gtk_window_map */
if (window->priv->menubar)
gtk_widget_map (window->priv->menubar);
GTK_WIDGET_CLASS (gtk_application_window_parent_class)->map (widget);
}
static void
hildon_home_window_map (GtkWidget *widget)
{
HildonHomeWindow *window;
HildonHomeWindowPrivate *priv;
GtkWidget *child;
window = HILDON_HOME_WINDOW (widget);
priv = window->priv;
child = GTK_BIN (widget)->child;
if (GTK_WIDGET_CLASS (hildon_home_window_parent_class)->map)
GTK_WIDGET_CLASS (hildon_home_window_parent_class)->map (widget);
if (GTK_IS_WIDGET (child))
gtk_widget_map (child);
if (GTK_IS_WIDGET (priv->titlebar))
gtk_widget_map (priv->titlebar);
}
static void
gtk_expander_map (GtkWidget *widget)
{
GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
if (priv->label_widget)
gtk_widget_map (priv->label_widget);
GTK_WIDGET_CLASS (gtk_expander_parent_class)->map (widget);
if (priv->event_window)
gdk_window_show (priv->event_window);
}
void gMainWindow::remap()
{
if (!isVisible())
return;
gtk_widget_unmap(border);
gtk_widget_map(border);
if (_skip_taskbar) { setSkipTaskBar(false); setSkipTaskBar(true); }
if (top_only) { setTopOnly(false); setTopOnly(true); }
if (sticky) { setSticky(false); setSticky(true); }
if (stack) { setStacking(0); setStacking(stack); }
X11_set_window_type(handle(), _type);
}
void
_cinnamon_embedded_window_set_actor (CinnamonEmbeddedWindow *window,
CinnamonGtkEmbed *actor)
{
g_return_if_fail (CINNAMON_IS_EMBEDDED_WINDOW (window));
window->priv->actor = actor;
if (actor &&
CLUTTER_ACTOR_IS_REALIZED (actor) &&
gtk_widget_get_visible (GTK_WIDGET (window)))
gtk_widget_map (GTK_WIDGET (window));
}
void
_shell_embedded_window_set_actor (ShellEmbeddedWindow *window,
ShellGtkEmbed *actor)
{
g_return_if_fail (SHELL_IS_EMBEDDED_WINDOW (window));
window->priv->actor = actor;
if (actor &&
CLUTTER_ACTOR_IS_REALIZED (actor) &&
gtk_widget_get_visible (GTK_WIDGET (window)))
gtk_widget_map (GTK_WIDGET (window));
}
/* FIXME: GnomeDruid bug workaround. */
static void
gb_gnome_druid_show_page (GtkWidget *parent, GtkWidget *new_page)
{
/* Hopefully we don't need this for GNOME 2. */
#if 0
if (GTK_WIDGET_REALIZED (parent))
gtk_widget_realize (new_page);
if (GTK_WIDGET_VISIBLE (parent) && GTK_WIDGET_VISIBLE (new_page))
{
if (GTK_WIDGET_MAPPED (parent))
gtk_widget_map (new_page);
gtk_widget_queue_resize (new_page);
}
#endif
}