gtkwidget.c

gtk是linux一款强大的夸平台的图形化开发工具

      if (widget->parent &&
	  GTK_WIDGET_MAPPED (widget->parent) &&
	  !GTK_WIDGET_MAPPED (widget))
	gtk_widget_map (widget);
    }
}

/*************************************************************
 * gtk_widget_show_now:
 *   Show a widget, and if it is an unmapped toplevel widget
 *   wait for the map_event before returning
 *
 *   Warning: This routine will call the main loop recursively.
 *       
 *   arguments:
 *     
 *   results:
 *************************************************************/

static void
gtk_widget_show_map_callback (GtkWidget *widget, GdkEvent *event, gint *flag)
{
  *flag = TRUE;
  gtk_signal_disconnect_by_data (GTK_OBJECT (widget), flag);
}

void
gtk_widget_show_now (GtkWidget *widget)
{
  gint flag = FALSE;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));

  /* make sure we will get event */
  if (!GTK_WIDGET_MAPPED (widget) &&
      GTK_WIDGET_TOPLEVEL (widget))
    {
      gtk_widget_show (widget);

      gtk_signal_connect (GTK_OBJECT (widget), "map_event",
			  GTK_SIGNAL_FUNC (gtk_widget_show_map_callback), 
			  &flag);

      while (!flag)
	gtk_main_iteration();
    }
  else
    gtk_widget_show (widget);
}

/*****************************************
 * gtk_widget_hide:
 *
 *   arguments:
 *
 *   results:
 *****************************************/

void
gtk_widget_hide (GtkWidget *widget)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));
  
  if (GTK_WIDGET_VISIBLE (widget))
    {
      gtk_signal_emit (GTK_OBJECT (widget), widget_signals[HIDE]);
      if (!GTK_WIDGET_TOPLEVEL (widget))
	gtk_widget_queue_resize (widget);
    }
}

static void
gtk_widget_real_hide (GtkWidget *widget)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));
  
  if (GTK_WIDGET_VISIBLE (widget))
    {
      GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
      
      if (GTK_WIDGET_MAPPED (widget))
	gtk_widget_unmap (widget);
    }
}

gint
gtk_widget_hide_on_delete (GtkWidget      *widget)
{
  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
  
  gtk_widget_hide (widget);
  
  return TRUE;
}

void
gtk_widget_show_all (GtkWidget *widget)
{
  GtkWidgetClass *class;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));

  class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);

  if (class->show_all)
    class->show_all (widget);
}

void
gtk_widget_hide_all (GtkWidget *widget)
{
  GtkWidgetClass *class;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));

  class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);

  if (class->hide_all)
    class->hide_all (widget);
}

/*****************************************
 * gtk_widget_map:
 *
 *   arguments:
 *
 *   results:
 *****************************************/

void
gtk_widget_map (GtkWidget *widget)
{
  g_return_if_fail (GTK_IS_WIDGET (widget));
  g_return_if_fail (GTK_WIDGET_VISIBLE (widget) == TRUE);
  
  if (!GTK_WIDGET_MAPPED (widget))
    {
      if (!GTK_WIDGET_REALIZED (widget))
	gtk_widget_realize (widget);

      gtk_signal_emit (GTK_OBJECT (widget), widget_signals[MAP]);

      if (GTK_WIDGET_NO_WINDOW (widget))
	gtk_widget_queue_draw (widget);
    }
}

/*****************************************
 * gtk_widget_unmap:
 *
 *   arguments:
 *
 *   results:
 *****************************************/

void
gtk_widget_unmap (GtkWidget *widget)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));
  
  if (GTK_WIDGET_MAPPED (widget))
    {
      if (GTK_WIDGET_NO_WINDOW (widget))
	gtk_widget_queue_clear_child (widget);
      gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNMAP]);
    }
}

/*****************************************
 * gtk_widget_realize:
 *
 *   arguments:
 *
 *   results:
 *****************************************/

void
gtk_widget_realize (GtkWidget *widget)
{
  gint events;
  GdkExtensionMode mode;
  GtkWidgetShapeInfo *shape_info;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));
  
  if (!GTK_WIDGET_REALIZED (widget))
    {
      /*
	if (GTK_IS_CONTAINER (widget) && !GTK_WIDGET_NO_WINDOW (widget))
	  g_message ("gtk_widget_realize(%s)", gtk_type_name (GTK_WIDGET_TYPE (widget)));
      */
      
      if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
	gtk_widget_realize (widget->parent);

      gtk_widget_ensure_style (widget);
      
      gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REALIZE]);
      
      if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
	{
	  shape_info = gtk_object_get_data (GTK_OBJECT (widget),
					    shape_info_key);
	  gdk_window_shape_combine_mask (widget->window,
					 shape_info->shape_mask,
					 shape_info->offset_x,
					 shape_info->offset_y);
	}
      
      if (!GTK_WIDGET_NO_WINDOW (widget))
	{
	  mode = gtk_widget_get_extension_events (widget);
	  if (mode != GDK_EXTENSION_EVENTS_NONE)
	    {
	      events = gtk_widget_get_events (widget);
	      gdk_input_set_extension_events (widget->window, events, mode);
	    }
	}
      
    }
}

/*****************************************
 * gtk_widget_unrealize:
 *
 *   arguments:
 *
 *   results:
 *****************************************/

void
gtk_widget_unrealize (GtkWidget *widget)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));

  if (GTK_WIDGET_REDRAW_PENDING (widget))
    gtk_widget_redraw_queue_remove (widget);
  
  if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
    gtk_widget_shape_combine_mask (widget, NULL, -1, -1);

  if (GTK_WIDGET_REALIZED (widget))
    {
      gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNREALIZE]);
      GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);
    }
}

/*****************************************
 * gtk_widget_queue_draw:
 *
 *   arguments:
 *
 *   results:
 *****************************************/

typedef struct _GtkDrawData GtkDrawData;
struct _GtkDrawData {
  GdkRectangle rect;
  GdkWindow *window;
};

static GMemChunk   *draw_data_mem_chunk = NULL;
static GSList      *draw_data_free_list = NULL;
static const gchar *draw_data_key  = "gtk-draw-data";
static GQuark       draw_data_key_id = 0;
static const gchar *draw_data_tmp_key  = "gtk-draw-data-tmp";
static GQuark       draw_data_tmp_key_id = 0;

static gint gtk_widget_idle_draw (gpointer data);

static void
gtk_widget_queue_draw_data (GtkWidget *widget,
			    gint       x,
			    gint       y,
			    gint       width,
			    gint       height,
			    GdkWindow *window)
{
  GSList      *node;
  GtkDrawData *data;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (!(width < 0 || height < 0) || window == NULL);

  if ((width != 0) && (height != 0) && GTK_WIDGET_DRAWABLE (widget))
    {
      if (!draw_data_key_id)
	draw_data_key_id = g_quark_from_static_string (draw_data_key);
      
      if (draw_data_free_list)
	{
	  node = draw_data_free_list;
	  data = node->data;
	  draw_data_free_list = draw_data_free_list->next;
	}
      else
	{
	  if (!draw_data_mem_chunk)
	    draw_data_mem_chunk = g_mem_chunk_create (GtkDrawData, 64,
						      G_ALLOC_ONLY);
	  data = g_chunk_new (GtkDrawData, draw_data_mem_chunk);
	  node = g_slist_alloc();
	  node->data = data;
	}

      data->rect.x = x;
      data->rect.y = y;

      if ((width < 1 && height < 1) ||
	  (width >= widget->allocation.width &&
	   height >= widget->allocation.height))
	GTK_PRIVATE_SET_FLAG (widget, GTK_FULLDRAW_PENDING);

      if ((width < 0) || (height < 0))
	{
	  data->rect.width = 0;
	  data->rect.height = 0;
	}
      else
	{
	  data->rect.width = width;
	  data->rect.height = height;
	}
      data->window = window;
      
      if ((width < 0) || (height < 0))
	{
	  GSList *draw_data_list = 
	    gtk_object_get_data_by_id (GTK_OBJECT (widget),
				       draw_data_key_id);
	  if (draw_data_list)
	    draw_data_free_list = g_slist_concat (draw_data_list,
						  draw_data_free_list);
	  node->next = NULL;
	}
      else
	node->next = gtk_object_get_data_by_id (GTK_OBJECT (widget),
						draw_data_key_id);

      if (!GTK_WIDGET_REDRAW_PENDING (widget))
	{
	  GTK_PRIVATE_SET_FLAG (widget, GTK_REDRAW_PENDING);
	  if (gtk_widget_redraw_queue == NULL)
	    gtk_idle_add_priority (GTK_PRIORITY_REDRAW,
				   gtk_widget_idle_draw,
				   NULL);
	  gtk_widget_redraw_queue = g_slist_prepend (gtk_widget_redraw_queue, widget);
	}

      gtk_object_set_data_by_id (GTK_OBJECT (widget), draw_data_key_id, node);
    }
}

void	   
gtk_widget_queue_draw_area (GtkWidget *widget,
			    gint       x,
			    gint       y,
			    gint       width,
			    gint       height)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));

  if (widget->window && gdk_window_is_viewable (widget->window) &&
      !gtk_widget_is_offscreen (widget))
    gtk_widget_queue_draw_data (widget, x, y, width, height, NULL);
}

void	   
gtk_widget_queue_draw (GtkWidget *widget)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));

  if (widget->window && gdk_window_is_viewable (widget->window) &&
      !gtk_widget_is_offscreen (widget))
    gtk_widget_queue_draw_data (widget, 0, 0, -1, -1, NULL);
}

void	   
gtk_widget_queue_clear_area (GtkWidget *widget,
			     gint       x,
			     gint       y,
			     gint       width,
			     gint       height)
{
  GtkWidget *parent;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_WIDGET (widget));

  if (!(widget->window && gdk_window_is_viewable (widget->window)) ||
      gtk_widget_is_offscreen (widget))
    return;

  /* Find the correct widget */

  if (GTK_WIDGET_NO_WINDOW (widget))
    {
      parent = widget;
      while (parent && GTK_WIDGET_NO_WINDOW (parent))
	parent = parent->parent;
      
      if (parent)
	gtk_widget_queue_draw_data (parent, x, y, width, height, widget->window);
    }
  else
    {
      if (widget->parent)
	{
	  gint wx, wy, wwidth, wheight;
	  /* Translate widget relative to window-relative */
	  
	  gdk_window_get_position (widget->window, &wx, &wy);
	  x -= wx - widget->allocation.x;
	  y -= wy - widget->allocation.y;
	  
	  gdk_window_get_size (widget->window, &wwidth, &wheight);

	  if (x + width <= 0 || y + height <= 0 ||
	      x >= wwidth || y >= wheight)
	    return;
	  
	  if (x < 0)
	    {
	      width += x;  x = 0;
	    }
	  if (y < 0)
	    {
	      height += y; y = 0;
	    }
	  if (x + width > wwidth)
	    width = wwidth - x;
	  if (y + height > wheight)
	    height = wheight - y;
	}

      gtk_widget_queue_draw_data (widget, x, y, width, height, widget->window);
    }
}

static void
gtk_widget_redraw_queue_remove (GtkWidget *widget)
{
  GSList *draw_data_list;
  GSList *tmp_list;

  g_return_if_fail (GTK_WIDGET_REDRAW_PENDING (widget));

  gtk_widget_redraw_queue = g_slist_remove (gtk_widget_redraw_queue, widget);

  draw_data_list = gtk_object_get_data_by_id (GTK_OBJECT (widget),
					      draw_data_key_id);
  tmp_list = g_slist_last (draw_data_list);
  if (tmp_list)
    {
      tmp_list->next = draw_data_free_list;
      draw_data_free_list = draw_data_list;
    }

  gtk_object_set_data_by_id (GTK_OBJECT (widget),
			     draw_data_key_id,
			     NULL);
  
  GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
  GTK_PRIVATE_UNSET_FLAG (widget, GTK_FULLDRAW_PENDING);
}

void	   
gtk_widget_queue_clear (GtkWidget *widget)