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