adapt to handle PangoColor

2001-01-26  Havoc Pennington  <hp@redhat.com>

	* gtk/gtktextlayout.c (convert_color): adapt to handle PangoColor

	* gtk/gtktreeview.c (gtk_tree_view_widget_to_tree_coords): fix to
	not offset by TREE_VIEW_HEADER_HEIGHT
	(gtk_tree_view_tree_to_widget_coords): fix to not offset by
	TREE_VIEW_HEADER_HEIGHT

	* configure.in (included_loaders): for me, --with-included-loaders
	generates the error "the specified loader yes does not exist",
	i.e. the arg defaults to "yes", so change test for value ""
	to test for value "yes", and include all loaders in that case.

	* gtk/gtkrbtree.c (_gtk_rbtree_get_depth): new function

	* gtk/gtktreeview.c (gtk_tree_view_get_cell_rect): fix to properly
	handle TREE_VIEW_VERTICAL_SEPARATOR
	(gtk_tree_view_bin_expose): fix to consider the row offset as
	pointing halfway into vertical separator.
	(gtk_tree_view_draw_node_focus_rect): ditto

	* gtk/gtkdebug.h, gtk/gtkmain.c (gtk_init_check): Add
	--gtk-debug=updates, which causes gdk_window_set_debug_updates
	(TRUE) to be called.

	* gdk/gdkwindow.c (gdk_window_set_debug_updates): Allow enabling a
	debug mode where the invalid region is colored in on invalidate,
	so you can see the flicker and know whether your redraw code is
	doing a good job.

	* gtk/gtktreeview.c (gtk_tree_view_queue_draw_node): Work in
	tree window coordinates (clip rect is in tree window coords)

	* gtk/Makefile.am: add gtktreednd.[hc]

	* gtk/gtkliststore.c: implement gtktreednd interfaces.

	* gtk/gtktreednd.c, gtk/gtktreednd.h: New interface to support
	drag-and-drop data operations on a model (so we can set up tree
	drag-and-drop automatically)

	* gtk/testgtk.c: Add a window to change sensitivity in the
	GtkLabel test; add a way to change the entry frame in GtkEntry
	test

	* gtk/gtkentry.c (gtk_entry_set_has_frame):
	(gtk_entry_get_has_frame): new functions to remove the frame
	around an entry
	(gtk_entry_size_request): shrink requisition if no frame
	(gtk_entry_draw_focus): don't draw frame if no frame

	* gtk/gtkstyle.c (gtk_default_draw_check): draw custom look for
	checks inside a cell renderer
	(gtk_default_draw_option): ditto for options

	* gtk/gtktreeviewcolumn.c (update_button_contents): add/remove
	children from the alignment, not the button
	(gtk_tree_view_column_init): ref/sink the column, to emulate
	GObject refcounting.

	* gtk/gtkcellrenderer.c (gtk_cell_renderer_init): ref/sink

	* gtk/gtkcellrenderertoggle.c (gtk_cell_renderer_toggle_render):
	Use theme functions to draw the toggles

	* gdk/gdkpango.c (gdk_pango_get_gc): use GdkRGB to alloc colors

	* gdk/gdkpango.h, gdk/gdkpango.c: Add GdkPangoAttrStipple and
	GdkPangoAttrEmbossed to use in rendering insensitive text

	* gdk/gdkpango.c (gdk_draw_layout_line): render new properties

	* gtk/gtkstyle.c (gtk_default_draw_layout): handle sensitivity
	using new GDK features

1 files changed, 232 insertions, 13 deletions

diff --git a/gtk/gtkliststore.c b/gtk/gtkliststore.c
index b045f2e60d..ef3300430f 100644
--- a/gtk/gtkliststore.c
+++ b/gtk/gtkliststore.c
@@ -22,6 +22,7 @@
 #include "gtkliststore.h"
 #include "gtktreedatalist.h"
 #include "gtksignal.h"
+#include "gtktreednd.h"
 #include <gobject/gvaluecollector.h>
 
 #define G_SLIST(x) ((GSList *) x)
@@ -39,6 +40,8 @@ static guint list_store_signals[LAST_SIGNAL] = { 0 };
 static void         gtk_list_store_init            (GtkListStore      *list_store);
 static void         gtk_list_store_class_init      (GtkListStoreClass *class);
 static void         gtk_list_store_tree_model_init (GtkTreeModelIface *iface);
+static void         gtk_list_store_drag_source_init(GtkTreeDragSourceIface *iface);
+static void         gtk_list_store_drag_dest_init  (GtkTreeDragDestIface   *iface);
 static guint        gtk_list_store_get_flags       (GtkTreeModel      *tree_model);
 static gint         gtk_list_store_get_n_columns   (GtkTreeModel      *tree_model);
 static GType        gtk_list_store_get_column_type (GtkTreeModel      *tree_model,
@@ -69,6 +72,15 @@ static gboolean     gtk_list_store_iter_parent     (GtkTreeModel      *tree_mode
 						    GtkTreeIter       *iter,
 						    GtkTreeIter       *child);
 
+static gboolean gtk_list_store_drag_data_delete   (GtkTreeDragSource *drag_source,
+                                                   GtkTreePath       *path);
+static gboolean gtk_list_store_drag_data_get      (GtkTreeDragSource *drag_source,
+                                                   GtkTreePath       *path,
+                                                   GtkSelectionData  *selection_data);
+static gboolean gtk_list_store_drag_data_received (GtkTreeDragDest   *drag_dest,
+                                                   GtkTreePath       *dest,
+                                                   GtkSelectionData  *selection_data);
+
 
 GtkType
 gtk_list_store_get_type (void)
@@ -97,10 +109,30 @@ gtk_list_store_get_type (void)
 	NULL
       };
 
+      static const GInterfaceInfo drag_source_info =
+      {
+	(GInterfaceInitFunc) gtk_list_store_drag_source_init,
+	NULL,
+	NULL
+      };
+
+      static const GInterfaceInfo drag_dest_info =
+      {
+	(GInterfaceInitFunc) gtk_list_store_drag_dest_init,
+	NULL,
+	NULL
+      };
+      
       list_store_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkListStore", &list_store_info, 0);
       g_type_add_interface_static (list_store_type,
 				   GTK_TYPE_TREE_MODEL,
 				   &tree_model_info);
+      g_type_add_interface_static (list_store_type,
+				   GTK_TYPE_TREE_DRAG_SOURCE,
+				   &drag_source_info);
+      g_type_add_interface_static (list_store_type,
+				   GTK_TYPE_TREE_DRAG_DEST,
+				   &drag_dest_info);
     }
 
   return list_store_type;
@@ -168,6 +200,19 @@ gtk_list_store_tree_model_init (GtkTreeModelIface *iface)
 }
 
 static void
+gtk_list_store_drag_source_init (GtkTreeDragSourceIface *iface)
+{
+  iface->drag_data_delete = gtk_list_store_drag_data_delete;
+  iface->drag_data_get = gtk_list_store_drag_data_get;
+}
+
+static void
+gtk_list_store_drag_dest_init   (GtkTreeDragDestIface   *iface)
+{
+  iface->drag_data_received = gtk_list_store_drag_data_received;
+}
+
+static void
 gtk_list_store_init (GtkListStore *list_store)
 {
   list_store->root = NULL;
@@ -646,21 +691,17 @@ remove_link_saving_prev (GSList  *list,
   return list;
 }
 
-void
-gtk_list_store_remove (GtkListStore *list_store,
-		       GtkTreeIter  *iter)
+static void
+gtk_list_store_remove_silently (GtkListStore *list_store,
+                                GtkTreeIter  *iter,
+                                GtkTreePath  *path)
 {
-  GtkTreePath *path;
-
-  g_return_if_fail (list_store != NULL);
-  g_return_if_fail (GTK_IS_LIST_STORE (list_store));
-  g_return_if_fail (iter->user_data != NULL);
-  
   if (G_SLIST (iter->user_data)->data)
-    _gtk_tree_data_list_free ((GtkTreeDataList *) G_SLIST (iter->user_data)->data,
-			      list_store->column_headers);
-
-  path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter);
+    {
+      _gtk_tree_data_list_free ((GtkTreeDataList *) G_SLIST (iter->user_data)->data,
+                                list_store->column_headers);
+      G_SLIST (iter->user_data)->data = NULL;
+    }
 
   {
     GSList *prev = NULL;
@@ -674,6 +715,23 @@ gtk_list_store_remove (GtkListStore *list_store,
   }
   
   list_store->stamp ++;
+}
+
+void
+gtk_list_store_remove (GtkListStore *list_store,
+		       GtkTreeIter  *iter)
+{
+  GtkTreePath *path;
+
+  g_return_if_fail (list_store != NULL);
+  g_return_if_fail (GTK_IS_LIST_STORE (list_store));
+  g_return_if_fail (iter->user_data != NULL);
+  
+
+  path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter);
+
+  gtk_list_store_remove_silently (list_store, iter, path);
+
   gtk_signal_emit_by_name (GTK_OBJECT (list_store),
 			   "deleted",
 			   path);
@@ -901,3 +959,164 @@ gtk_list_store_append (GtkListStore *list_store,
 			   path, iter);
   gtk_tree_path_free (path);
 }
+
+static gboolean
+gtk_list_store_drag_data_delete (GtkTreeDragSource *drag_source,
+                                 GtkTreePath       *path)
+{
+  GtkTreeIter iter;
+  g_return_val_if_fail (GTK_IS_LIST_STORE (drag_source), FALSE);
+  
+  if (gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_source),
+                               &iter,
+                               path))
+    {
+      gtk_list_store_remove (GTK_LIST_STORE (drag_source),
+                             &iter);
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+static gboolean
+gtk_list_store_drag_data_get (GtkTreeDragSource *drag_source,
+                              GtkTreePath       *path,
+                              GtkSelectionData  *selection_data)
+{
+  g_return_val_if_fail (GTK_IS_LIST_STORE (drag_source), FALSE);
+
+  /* Note that we don't need to handle the GTK_TREE_MODEL_ROW
+   * target, because the default handler does it for us, but
+   * we do anyway for the convenience of someone maybe overriding the
+   * default handler.
+   */
+
+  if (gtk_selection_data_set_tree_row (selection_data,
+                                       GTK_TREE_MODEL (drag_source),
+                                       path))
+    {
+      return TRUE;
+    }
+  else
+    {
+      /* FIXME handle text targets at least. */
+    }
+
+  return FALSE;
+}
+
+static gboolean
+gtk_list_store_drag_data_received (GtkTreeDragDest   *drag_dest,
+                                   GtkTreePath       *dest,
+                                   GtkSelectionData  *selection_data)
+{
+  GtkTreeModel *tree_model;
+  GtkListStore *list_store;
+  GtkTreeModel *src_model = NULL;
+  GtkTreePath *src_path = NULL;
+  gboolean retval = FALSE;
+  
+  g_return_val_if_fail (GTK_IS_LIST_STORE (drag_dest), FALSE);
+
+  tree_model = GTK_TREE_MODEL (drag_dest);
+  list_store = GTK_LIST_STORE (drag_dest);
+  
+  if (gtk_selection_data_get_tree_row (selection_data,
+                                       &src_model,
+                                       &src_path) &&
+      src_model == tree_model)
+    {
+      /* Copy the given row to a new position */
+      GtkTreeIter src_iter;
+      GtkTreeIter dest_iter;
+      GtkTreePath *prev;
+      
+      if (!gtk_tree_model_get_iter (src_model,
+                                    &src_iter,
+                                    src_path))
+        goto out;
+
+      /* Get the path to insert _after_ (dest is the path to insert _before_) */
+      prev = gtk_tree_path_copy (dest);
+
+      if (!gtk_tree_path_prev (prev))
+        {
+          /* dest was the first spot in the list; which means we are supposed
+           * to prepend.
+           */
+          gtk_list_store_prepend (GTK_LIST_STORE (tree_model),
+                                  &dest_iter);
+          
+          retval = TRUE;
+        }
+      else
+        {
+          if (gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_model),
+                                       &dest_iter,
+                                       prev))
+            {
+              GtkTreeIter tmp_iter = dest_iter;
+              gtk_list_store_insert_after (GTK_LIST_STORE (tree_model),
+                                           &dest_iter,
+                                           &tmp_iter);
+              retval = TRUE;
+            }
+        }
+
+      gtk_tree_path_free (prev);
+      
+      /* If we succeeded in creating dest_iter, copy data from src
+       */
+      if (retval)
+        {
+          GtkTreeDataList *dl = G_SLIST (src_iter.user_data)->data;
+          GtkTreeDataList *copy_head = NULL;
+          GtkTreeDataList *copy_prev = NULL;
+          GtkTreeDataList *copy_iter = NULL;
+          gint col;
+
+          col = 0;
+          while (dl)
+            {
+              copy_iter = _gtk_tree_data_list_node_copy (dl,
+                                                         list_store->column_headers[col]);
+
+              g_print ("copied col %d type %s\n", col,
+                       g_type_name (list_store->column_headers[col]));
+              
+              if (copy_head == NULL)
+                copy_head = copy_iter;
+
+              if (copy_prev)
+                copy_prev->next = copy_iter;
+
+              copy_prev = copy_iter;
+
+              dl = dl->next;
+              ++col;
+            }
+          
+          G_SLIST (dest_iter.user_data)->data = copy_head;
+          
+          gtk_signal_emit_by_name (GTK_OBJECT (tree_model),
+                                   "changed",
+                                   NULL, &dest_iter);
+        }
+    }
+  else
+    {
+      /* FIXME maybe add some data targets eventually, or handle text
+       * targets in the simple case.
+       */
+    }
+
+ out:
+  
+  if (src_path)
+    gtk_tree_path_free (src_path);
+  
+  return retval;  
+}