/**
* 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);
}
}
/**
* hildon_remote_texture_set_show_full:
* @self: A #HildonRemoteTexture
* @show: A boolean flag setting the visibility of the remote texture.
* @opacity: Desired opacity setting
*
* Send a message to the window manager setting the visibility of
* the remote texture. This will only affect the visibility of
* the remote texture set by the compositing window manager in its own
* rendering pipeline, after X has drawn the window to the off-screen
* buffer. This setting, naturally, has no effect if the #HildonRemoteTexture
* widget is not visible in X11 terms (i.e. realized and mapped).
*
* Furthermore, if a widget is parented, its final visibility will be
* affected by that of the parent window.
*
* The opacity setting ranges from zero (0), being completely transparent
* to 255 (0xff) being fully opaque.
*
* If the remote texture WM-counterpart is not ready, the show message
* will be queued until the WM is ready for it.
*
* Since: 2.2
**/
void
hildon_remote_texture_set_show_full (HildonRemoteTexture *self,
gint show,
gint opacity)
{
HildonRemoteTexturePrivate
*priv = HILDON_REMOTE_TEXTURE_GET_PRIVATE (self);
GtkWidget *widget = GTK_WIDGET (self);
if (opacity > 255)
opacity = 255;
if (opacity < 0)
opacity = 0;
priv->show = show;
priv->opacity = opacity;
priv->set_show = 1;
if (GTK_WIDGET_MAPPED (widget) && priv->ready)
{
/* Defer show messages until the remote texture is parented
* and the parent window is mapped */
if (!priv->parent || !GTK_WIDGET_MAPPED (GTK_WIDGET (priv->parent)))
return;
hildon_remote_texture_send_message (self,
show_atom,
show, opacity,
0, 0, 0);
priv->set_show = 0;
}
}
/**
* hildon_remote_texture_set_position:
* @self: A #HildonRemoteTexture
* @x: Desired X coordinate
* @y: Desired Y coordinate
* @width: Desired width
* @height: Desired height
*
* Send a message to the window manager setting the offset of the remote
* texture in the window (in Remote texture's pixels). The texture
* is also subject to the animation effects rendered by the compositing
* window manager on that window (like those by task switcher).
*
* If the remote texture WM-counterpart is not ready, the show message
* will be queued until the WM is ready for it.
*
* Since: 2.2
**/
void
hildon_remote_texture_set_position (HildonRemoteTexture *self,
gint x,
gint y,
gint width,
gint height)
{
HildonRemoteTexturePrivate
*priv = HILDON_REMOTE_TEXTURE_GET_PRIVATE (self);
GtkWidget *widget = GTK_WIDGET (self);
priv->x = x;
priv->y = y;
priv->width = width;
priv->height = height;
priv->set_position = 1;
if (GTK_WIDGET_MAPPED (widget) && priv->ready)
{
/* Defer messages until the remote texture is parented
* and the parent window is mapped */
if (!priv->parent || !GTK_WIDGET_MAPPED (GTK_WIDGET (priv->parent)))
return;
hildon_remote_texture_send_message (self,
position_atom,
x, y,
width, height, 0);
priv->set_position = 0;
}
}
/**
* hildon_remote_texture_set_offset:
* @self: A #HildonRemoteTexture
* @x: Desired X offset
* @y: Desired Y offset
*
* Send a message to the window manager setting the offset of the remote
* texture in the window (in Remote texture's pixels). The texture
* is also subject to the animation effects rendered by the compositing
* window manager on that window (like those by task switcher).
*
* If the remote texture WM-counterpart is not ready, the show message
* will be queued until the WM is ready for it.
*
* Since: 2.2
**/
void
hildon_remote_texture_set_offset (HildonRemoteTexture *self,
double x,
double y)
{
HildonRemoteTexturePrivate
*priv = HILDON_REMOTE_TEXTURE_GET_PRIVATE (self);
GtkWidget *widget = GTK_WIDGET (self);
priv->offset_x = x;
priv->offset_y = y;
priv->set_offset = 1;
if (GTK_WIDGET_MAPPED (widget) && priv->ready)
{
/* Defer messages until the remote texture is parented
* and the parent window is mapped */
if (!priv->parent || !GTK_WIDGET_MAPPED (GTK_WIDGET (priv->parent)))
return;
hildon_remote_texture_send_message (self,
offset_atom,
(gint)(x*65536), (gint)(y*65536),
0, 0, 0);
priv->set_offset = 0;
}
}
/**
* hildon_remote_texture_set_image:
* @self: A #HildonRemoteTexture
* @key: The key that would be used with shmget in hildon-desktop. The key
* should probably be created with ftok, and the relevant shared memory
* area should be created before this call.
* @width: width of image in pixels
* @height: height of image in pixels
* @bpp: BYTES per pixel - usually 2,3 or 4
*
* Since: 2.2
*/
void
hildon_remote_texture_set_image (HildonRemoteTexture *self,
key_t key,
guint width,
guint height,
guint bpp)
{
HildonRemoteTexturePrivate
*priv = HILDON_REMOTE_TEXTURE_GET_PRIVATE (self);
GtkWidget *widget = GTK_WIDGET (self);
priv->set_shm = 1;
priv->shm_key = key;
priv->shm_width = width;
priv->shm_height = height;
priv->shm_bpp = bpp;
if (GTK_WIDGET_MAPPED (widget) && priv->ready)
{
/* Defer messages until the remote texture is parented
* and the parent window is mapped */
if (!priv->parent || !GTK_WIDGET_MAPPED (GTK_WIDGET (priv->parent)))
return;
hildon_remote_texture_send_message (self,
shm_atom,
priv->shm_key,
priv->shm_width,
priv->shm_height,
priv->shm_bpp,
0);
priv->set_shm = 0;
}
}
/**
* hildon_remote_texture_set_scalex:
* @self: A #HildonRemoteTexture
* @x_scale: The scale factor for the memory area to be rendered in the X-axis
* @y_scale: The scale factor for the memory area to be rendered in the X-axis
*
* Since: 2.2
**/
void
hildon_remote_texture_set_scale (HildonRemoteTexture *self,
double x_scale,
double y_scale)
{
HildonRemoteTexturePrivate
*priv = HILDON_REMOTE_TEXTURE_GET_PRIVATE (self);
GtkWidget *widget = GTK_WIDGET (self);
priv->scale_x = x_scale;
priv->scale_y = y_scale;
priv->set_scale = 1;
if (GTK_WIDGET_MAPPED (widget) && priv->ready)
{
/* Defer messages until the remote texture is parented
* and the parent window is mapped */
if (!priv->parent || !GTK_WIDGET_MAPPED (GTK_WIDGET (priv->parent)))
return;
hildon_remote_texture_send_message (self,
scale_atom,
priv->scale_x * (1 << 16),
priv->scale_y * (1 << 16),
0, 0, 0);
priv->set_scale = 0;
}
}
/**
* 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");
}
}
//----------------------------- Messages -------------------------------------
// This shows a simple dialog box with a label and an 'OK' button.
void
showMessageBox(const std::string &message,
GtkMessageType type/*=GTK_MESSAGE_ERROR*/,
GtkWidget *transient_widget/*=NULL*/)
{
GtkWidget* dialog;
GtkWindow* transientParent = NULL;
// Make transient if necessary
if(transient_widget) {
GtkWidget* toplevel = getToplevel(transient_widget);
if(toplevel &&
GTK_IS_WINDOW(toplevel) &&
GTK_WIDGET_MAPPED(toplevel))
transientParent = GTK_WINDOW(toplevel);
}
dialog = gtk_message_dialog_new(transientParent,
GTK_DIALOG_MODAL,
type,
GTK_BUTTONS_OK,
"%s", message.c_str());
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
runModalBox(dialog);
gtk_widget_destroy(dialog);
}
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));
}
}
static gboolean
gail_select_watcher (GSignalInvocationHint *ihint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
GObject *object;
GtkWidget *widget;
object = g_value_get_object (param_values + 0);
g_return_val_if_fail (GTK_IS_WIDGET(object), FALSE);
widget = GTK_WIDGET (object);
if (!GTK_WIDGET_MAPPED (widget))
{
g_signal_connect (widget, "map",
G_CALLBACK (gail_map_cb),
NULL);
}
else
gail_finish_select (widget);
return TRUE;
}
// This shows a question dialog box response can be (YES/NO/CANCEL)
gint
showAskingBox(const std::string& message,
GtkMessageType type,
const GtkButtonsType buttonsType,
GtkWidget* transient_widget)
{
GtkWidget *dialog;
GtkWindow *transient_parent(NULL);
// Make transient if necessary
if (transient_widget)
{
GtkWidget *toplevel = getToplevel(transient_widget);
if (toplevel && GTK_IS_WINDOW (toplevel) && GTK_WIDGET_MAPPED (toplevel))
transient_parent=GTK_WINDOW(toplevel);
}
dialog = gtk_message_dialog_new (transient_parent,
GTK_DIALOG_MODAL,
type,
buttonsType,
"%s", message.c_str());
//gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_window_set_position(GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
// Suspend AReVi Scheduler
gint result=runModalBox(dialog);
gtk_widget_destroy (dialog);
return result;
}
static void
mate_druid_remove (GtkContainer *widget,
GtkWidget *child)
{
MateDruid *druid;
GList *list;
g_return_if_fail (widget != NULL);
g_return_if_fail (MATE_IS_DRUID (widget));
g_return_if_fail (child != NULL);
druid = MATE_DRUID (widget);
list = g_list_find (druid->_priv->children, child);
/* Is it a page? */
if (list != NULL) {
/* If we are mapped and visible, we want to deal with changing the page. */
if ((GTK_WIDGET_MAPPED (GTK_WIDGET (widget))) &&
(list->data == (gpointer) druid->_priv->current)) {
if (list->next != NULL)
mate_druid_set_page (druid, MATE_DRUID_PAGE (list->next->data));
else if (list->prev != NULL)
mate_druid_set_page (druid, MATE_DRUID_PAGE (list->prev->data));
else
/* Removing the only child, just set current to NULL */
druid->_priv->current = NULL;
}
}
druid->_priv->children = g_list_remove (druid->_priv->children, child);
gtk_widget_unparent (child);
}
static void
mate_druid_unmap (GtkWidget *widget)
{
MateDruid *druid;
g_return_if_fail (widget != NULL);
g_return_if_fail (MATE_IS_DRUID (widget));
druid = MATE_DRUID (widget);
GTK_WIDGET_UNSET_FLAGS (druid, GTK_MAPPED);
#if 0
gtk_widget_unmap (druid->back);
if (druid->_priv->show_finish)
gtk_widget_unmap (druid->finish);
else
gtk_widget_unmap (druid->next);
gtk_widget_unmap (druid->cancel);
if (druid->_priv->show_help)
gtk_widget_unmap (druid->help);
#endif
gtk_widget_unmap (druid->_priv->bbox);
if (druid->_priv->current &&
GTK_WIDGET_VISIBLE (druid->_priv->current) &&
GTK_WIDGET_MAPPED (druid->_priv->current))
gtk_widget_unmap (GTK_WIDGET (druid->_priv->current));
}
//------------------------- Color Selection -----------------------------------
// Open Dlg for color selection return true, if color changed
bool
showColorBox(const std::string &title,
GdkColor &colorInOut,
GtkWidget *transient_widget/*=NULL*/)
{
GtkWidget *dialog;
GtkColorSelection *colorsel;
gint response;
dialog = gtk_color_selection_dialog_new (title.c_str());
// Make transient if necessary
if (transient_widget)
{
GtkWidget *toplevel = getToplevel(transient_widget);
if (toplevel && GTK_IS_WINDOW (toplevel) && GTK_WIDGET_MAPPED (toplevel))
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (toplevel));
}
colorsel = GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (dialog)->colorsel);
gtk_color_selection_set_previous_color (colorsel, &colorInOut);
gtk_color_selection_set_current_color (colorsel, &colorInOut);
gtk_color_selection_set_has_palette (colorsel, TRUE);
response = runModalBox(dialog);
if (response == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_color (colorsel,&colorInOut);
}
gtk_widget_destroy (dialog);
return (response == GTK_RESPONSE_OK);
}
/* Zru¹ení GDK/X oken widgetu */
static void gtk_ev_unrealize(GtkWidget *widget)
{
GtkEv *ev;
g_return_if_fail(GTK_IS_EV(widget));
ev = GTK_EV(widget);
/* Schovat okna */
if(GTK_WIDGET_MAPPED(widget))
gtk_widget_unmap(widget);
GTK_WIDGET_UNSET_FLAGS(widget, GTK_MAPPED);
/* Zru¹it vnitøní okno (GtkEv.ev_win) */
if(ev->ev_win) {
gdk_window_set_user_data(ev->ev_win, NULL);
gdk_window_destroy(ev->ev_win);
ev->ev_win = NULL;
}
/* Zru¹it hlavní okno widgetu (GtkEv.window), zru¹it pøíznak realizace */
if(GTK_WIDGET_CLASS(parent_class))
GTK_WIDGET_CLASS(parent_class)->unrealize(widget);
}
/* The window is being destroyed. */
static void
vga_unrealize(GtkWidget *widget)
{
VGAText * vga;
#ifdef VGA_DEBUG
fprintf(stderr, "vga_unrealize()\n");
#endif
g_return_if_fail(widget != NULL);
g_return_if_fail(VGA_IS_TEXT(widget));
vga = VGA_TEXT(widget);
if (GTK_WIDGET_MAPPED(widget))
{
gtk_widget_unmap(widget);
}
/* Remove the GDK Window */
if (widget->window != NULL)
{
gdk_window_destroy(widget->window);
widget->window = NULL;
}
/* Mark that we no longer have a GDK window */
GTK_WIDGET_UNSET_FLAGS(widget, GTK_REALIZED);
}
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
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);
}
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);
}
/**
* gtk_tool_item_set_use_drag_window:
* @tool_item: a #GtkToolItem
* @use_drag_window: Whether @tool_item has a drag window.
*
* Sets whether @tool_item has a drag window. When %TRUE the
* toolitem can be used as a drag source through gtk_drag_source_set().
* When @tool_item has a drag window it will intercept all events,
* even those that would otherwise be sent to a child of @tool_item.
*
* Since: 2.4
**/
void
gtk_tool_item_set_use_drag_window (GtkToolItem *toolitem,
gboolean use_drag_window)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (toolitem));
use_drag_window = use_drag_window != FALSE;
if (toolitem->priv->use_drag_window != use_drag_window)
{
toolitem->priv->use_drag_window = use_drag_window;
if (use_drag_window)
{
if (!toolitem->priv->drag_window && GTK_WIDGET_REALIZED (toolitem))
{
create_drag_window(toolitem);
if (GTK_WIDGET_MAPPED (toolitem))
gdk_window_show (toolitem->priv->drag_window);
}
}
else
{
destroy_drag_window (toolitem);
}
}
}
static void zbar_gtk_unrealize (GtkWidget *widget)
{
if(GTK_WIDGET_MAPPED(widget))
gtk_widget_unmap(widget);
ZBarGtk *self = ZBAR_GTK(widget);
if(!self->_private)
return;
ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(self->_private);
if(zbar->video_enabled) {
zbar->video_enabled = FALSE;
GValue *msg = zbar_gtk_new_value(G_TYPE_INT);
g_value_set_int(msg, 0);
g_async_queue_push(zbar->queue, msg);
}
zbar_window_attach(zbar->window, NULL, 0);
GTK_WIDGET_UNSET_FLAGS(widget, GTK_REALIZED);
gdk_window_set_user_data(widget->window, NULL);
gdk_window_destroy(widget->window);
widget->window = NULL;
}
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
create_input_dialog (void)
{
static GtkWidget *inputd = NULL;
if (!inputd)
{
inputd = gtk_input_dialog_new ();
g_signal_connect (inputd, "destroy",
G_CALLBACK (input_dialog_destroy), &inputd);
g_signal_connect_swapped (GTK_INPUT_DIALOG (inputd)->close_button,
"clicked",
G_CALLBACK (gtk_widget_hide),
inputd);
gtk_widget_hide (GTK_INPUT_DIALOG (inputd)->save_button);
gtk_widget_show (inputd);
}
else
{
if (!GTK_WIDGET_MAPPED(inputd))
gtk_widget_show(inputd);
else
gdk_window_raise(inputd->window);
}
}
static gboolean
idle_do_action (gpointer data)
{
GtkWidget *item;
GtkWidget *item_parent;
GailMenuItem *menu_item;
gboolean item_mapped;
menu_item = GAIL_MENU_ITEM (data);
menu_item->action_idle_handler = 0;
item = GTK_ACCESSIBLE (menu_item)->widget;
if (item == NULL /* State is defunct */ ||
!GTK_WIDGET_SENSITIVE (item) || !GTK_WIDGET_VISIBLE (item))
return FALSE;
item_parent = gtk_widget_get_parent (item);
gtk_menu_shell_select_item (GTK_MENU_SHELL (item_parent), item);
item_mapped = GTK_WIDGET_MAPPED (item);
/*
* This is what is called when <Return> is pressed for a menu item
*/
g_signal_emit_by_name (item_parent, "activate_current",
/*force_hide*/ 1);
if (!item_mapped)
ensure_menus_unposted (menu_item);
return FALSE;
}
static void
gtk_icon_entry_map (GtkWidget *widget)
{
GtkIconEntryPrivate *priv;
GdkCursor *cursor;
if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
{
int i;
GTK_WIDGET_CLASS (parent_class)->map (widget);
priv = GTK_ICON_ENTRY_GET_PRIVATE (widget);
for (i = 0; i < MAX_ICONS; i++)
{
if (priv->icons[i].pixbuf != NULL)
gdk_window_show (priv->icons[i].window);
if (priv->icons[i].custom_cursor == TRUE && !priv->icons[i].insensitive)
{
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
priv->icons[i].cursor_type);
gdk_window_set_cursor (priv->icons[i].window, cursor);
gdk_cursor_unref (cursor);
}
}
GTK_WIDGET_CLASS (parent_class)->map (widget);
}
}
static gint
find_tab_num_at_pos (NautilusNotebook *notebook, gint abs_x, gint abs_y)
{
GtkPositionType tab_pos;
int page_num = 0;
GtkNotebook *nb = GTK_NOTEBOOK (notebook);
GtkWidget *page;
tab_pos = gtk_notebook_get_tab_pos (GTK_NOTEBOOK (notebook));
if (GTK_NOTEBOOK (notebook)->first_tab == NULL)
{
return AFTER_ALL_TABS;
}
/* For some reason unfullscreen + quick click can
cause a wrong click event to be reported to the tab */
if (!is_in_notebook_window(notebook, abs_x, abs_y))
{
return NOT_IN_APP_WINDOWS;
}
while ((page = gtk_notebook_get_nth_page (nb, page_num)))
{
GtkWidget *tab;
gint max_x, max_y;
gint x_root, y_root;
tab = gtk_notebook_get_tab_label (nb, page);
g_return_val_if_fail (tab != NULL, -1);
if (!GTK_WIDGET_MAPPED (GTK_WIDGET (tab)))
{
page_num++;
continue;
}
gdk_window_get_origin (GDK_WINDOW (tab->window),
&x_root, &y_root);
max_x = x_root + tab->allocation.x + tab->allocation.width;
max_y = y_root + tab->allocation.y + tab->allocation.height;
if (((tab_pos == GTK_POS_TOP)
|| (tab_pos == GTK_POS_BOTTOM))
&&(abs_x<=max_x))
{
return page_num;
}
else if (((tab_pos == GTK_POS_LEFT)
|| (tab_pos == GTK_POS_RIGHT))
&& (abs_y<=max_y))
{
return page_num;
}
page_num++;
}
return AFTER_ALL_TABS;
}
static void
gail_item_real_initialize (AtkObject *obj,
gpointer data)
{
GailItem *item = GAIL_ITEM (obj);
GtkWidget *label;
ATK_OBJECT_CLASS (parent_class)->initialize (obj, data);
item->textutil = NULL;
item->text = NULL;
label = get_label_from_container (GTK_WIDGET (data));
if (GTK_IS_LABEL (label))
{
if (GTK_WIDGET_MAPPED (label))
gail_item_init_textutil (item, label);
else
g_signal_connect (label,
"map",
G_CALLBACK (gail_item_label_map_gtk),
item);
}
obj->role = ATK_ROLE_LIST_ITEM;
}
/**
* hildon_remote_texture_update_area:
* @self: A #HildonRemoteTexture
* @x: offset of damaged area in pixels
* @y: offset of damaged area in pixels
* @width: width of damaged area in pixels
* @height: height of damaged area in pixels
*
* This signals to hildon-desktop that a specific region of the memory area
* has changed. This will trigger a redraw and will update the relevant tiles
* of the texture.
*
* Since: 2.2
*/
void
hildon_remote_texture_update_area (HildonRemoteTexture *self,
gint x,
gint y,
gint width,
gint height)
{
HildonRemoteTexturePrivate
*priv = HILDON_REMOTE_TEXTURE_GET_PRIVATE (self);
GtkWidget *widget = GTK_WIDGET (self);
if (priv->damage_x1==priv->damage_x2 || priv->damage_y1==priv->damage_y2)
{
priv->damage_x1 = x;
priv->damage_y1 = y;
priv->damage_x2 = x+width;
priv->damage_y2 = y+height;
}
else
{
if (x<priv->damage_x1) priv->damage_x1 = x;
if (y<priv->damage_y1) priv->damage_y1 = y;
if (x+width>priv->damage_x2) priv->damage_x2 = x+width;
if (y+height>priv->damage_y2) priv->damage_y2 = y+height;
}
priv->set_damage = 1;
if (GTK_WIDGET_MAPPED (widget) && priv->ready)
{
/* Defer messages until the remote texture is parented
* and the parent window is mapped */
if (!priv->parent || !GTK_WIDGET_MAPPED (GTK_WIDGET (priv->parent)))
return;
hildon_remote_texture_send_message (self,
damage_atom,
priv->damage_x1,
priv->damage_y1,
priv->damage_x2 - priv->damage_x1,
priv->damage_y2 - priv->damage_y1,
0);
priv->set_damage = 0;
priv->damage_x1 = 0;
priv->damage_y1 = 0;
priv->damage_x2 = 0;
priv->damage_y2 = 0;
}
}
gboolean nsgtk_widget_get_mapped(GtkWidget *widget)
{
#if GTK_CHECK_VERSION(2,20,0)
return gtk_widget_get_mapped(widget);
#else
return GTK_WIDGET_MAPPED(widget);
#endif
}
