Saved the first steps of the migration to GTK+ v3.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@367 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

1 files changed, 117 insertions, 65 deletions

diff --git a/src/gtkext/gtkbufferview.c b/src/gtkext/gtkbufferview.c
index 7cb1e9b..877b041 100644
--- a/src/gtkext/gtkbufferview.c
+++ b/src/gtkext/gtkbufferview.c
@@ -46,14 +46,17 @@ static gboolean gtk_buffer_view_focus(GtkWidget *, GtkDirectionType);
 /* Assure la gestion des clics de souris sur le composant. */
 static gboolean gtk_buffer_view_button_press(GtkWidget *, GdkEventButton *);
 
-/* Fournit la taille de composant requise pour un plein rendu. */
-static void gtk_buffer_view_size_request(GtkWidget *, GtkRequisition *);
+/* Fournit la hauteur de composant requise pour un plein rendu. */
+static void gtk_buffer_view_get_preferred_height(GtkWidget *, gint *, gint *);
+
+/* Fournit la largeur de composant requise pour un plein rendu. */
+static void gtk_buffer_view_get_preferred_width(GtkWidget *, gint *, gint *);
 
 /* S'adapte à la surface concédée par le composant parent. */
 static void gtk_buffer_view_size_allocate(GtkWidget *, GtkAllocation *);
 
 /* Met à jour l'affichage de la visualisation de code buffer. */
-static gboolean gtk_buffer_view_expose(GtkWidget *, GdkEventExpose *);
+static gboolean gtk_buffer_view_draw(GtkWidget *, cairo_t *);
 
 /* Prend en compte une frappe de touche sur le composant. */
 static gboolean gtk_buffer_view_key_press(GtkWidget *, GdkEventKey *);
@@ -109,9 +112,10 @@ static void gtk_buffer_view_class_init(GtkBufferViewClass *class)
 
     widget_class->focus = gtk_buffer_view_focus;
     widget_class->button_press_event = gtk_buffer_view_button_press;
-    widget_class->size_request = gtk_buffer_view_size_request;
+    widget_class->get_preferred_height = gtk_buffer_view_get_preferred_height;
+    widget_class->get_preferred_width = gtk_buffer_view_get_preferred_width;
     widget_class->size_allocate = gtk_buffer_view_size_allocate;
-    widget_class->expose_event = gtk_buffer_view_expose;
+    widget_class->draw = gtk_buffer_view_draw;
     widget_class->key_press_event = gtk_buffer_view_key_press;
 
     g_signal_new("caret-moved",
@@ -301,10 +305,11 @@ void gtk_buffer_view_compute_real_coord(GtkBufferView *view, gint *x, gint *y)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : widget      = composant GTK à consulter.                     *
-*                requisition = dimensions souhaitées. [OUT]                   *
+*  Paramètres  : widget  = composant GTK à consulter.                         *
+*                minimal = taille minimale. [OUT]                             *
+*                natural = taille idéale. [OUT]                               *
 *                                                                             *
-*  Description : Fournit la taille de composant requise pour un plein rendu.  *
+*  Description : Fournit la hauteur de composant requise pour un plein rendu. *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -312,17 +317,50 @@ void gtk_buffer_view_compute_real_coord(GtkBufferView *view, gint *x, gint *y)
 *                                                                             *
 ******************************************************************************/
 
-static void gtk_buffer_view_size_request(GtkWidget *widget, GtkRequisition *requisition)
+static void gtk_buffer_view_get_preferred_height(GtkWidget *widget, gint *minimal, gint *natural)
 {
     GtkBufferView *view;                    /* Autre version du composant  */
 
     view = GTK_BUFFER_VIEW(widget);
 
     if (view->buffer_view != NULL)
-        g_buffer_view_get_size(view->buffer_view,
-                               &requisition->width, &requisition->height,
-                               *GTK_VIEW_PANEL(view)->display_addr,
-                               *GTK_VIEW_PANEL(view)->display_code);
+        *minimal = g_buffer_view_get_height(view->buffer_view);
+    else
+        *minimal = 0;
+
+    *natural = *minimal;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : widget  = composant GTK à consulter.                         *
+*                minimal = taille minimale. [OUT]                             *
+*                natural = taille idéale. [OUT]                               *
+*                                                                             *
+*  Description : Fournit la largeur de composant requise pour un plein rendu. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_buffer_view_get_preferred_width(GtkWidget *widget, gint *minimal, gint *natural)
+{
+    GtkBufferView *view;                    /* Autre version du composant  */
+
+    view = GTK_BUFFER_VIEW(widget);
+
+    if (view->buffer_view != NULL)
+        *minimal = g_buffer_view_get_width(view->buffer_view,
+                                           *GTK_VIEW_PANEL(view)->display_addr,
+                                           *GTK_VIEW_PANEL(view)->display_code);
+    else
+        *minimal = 0;
+
+    *natural = *minimal;
 
 }
 
@@ -351,10 +389,10 @@ static void gtk_buffer_view_size_allocate(GtkWidget *widget, GtkAllocation *allo
 
     /* Mise à jour GTK */
 
-    widget->allocation = *allocation;
+    gtk_widget_set_allocation(widget, allocation);
 
     if (gtk_widget_get_realized(widget))
-        gdk_window_move_resize(widget->window,
+        gdk_window_move_resize(gtk_widget_get_window(widget),
                                allocation->x, allocation->y,
                                allocation->width, allocation->height);
 
@@ -365,18 +403,18 @@ static void gtk_buffer_view_size_allocate(GtkWidget *widget, GtkAllocation *allo
 
     view = GTK_BUFFER_VIEW(widget);
 
-    g_buffer_view_get_size(view->buffer_view, &width, &height,
-                           *panel->display_addr, *panel->display_code);
+    width = g_buffer_view_get_width(view->buffer_view, *panel->display_addr, *panel->display_code);
+    height = g_buffer_view_get_height(view->buffer_view);
 
     gtk_view_panel_compute_allocation(panel, &valloc);
 
     /* Défilement horizontal */
 
-    panel->hadjustment->page_size = valloc.width;
-    panel->hadjustment->step_increment = valloc.width * 0.1;
-    panel->hadjustment->page_increment = valloc.width * 0.9;
+    gtk_adjustment_set_page_size(panel->hadjustment, valloc.width);
+    gtk_adjustment_set_step_increment(panel->hadjustment, valloc.width * 0.1);
+    gtk_adjustment_set_page_increment(panel->hadjustment, valloc.width * 0.9);
 
-    panel->hadjustment->upper = MAX(width, valloc.width);
+    gtk_adjustment_set_upper(panel->hadjustment, MAX(width, valloc.width));
 
     gtk_view_panel_reclamp_adjustment(panel->hadjustment, &changed);
 
@@ -387,11 +425,11 @@ static void gtk_buffer_view_size_allocate(GtkWidget *widget, GtkAllocation *allo
 
     /* Défilement vertical */
 
-    panel->vadjustment->page_size = valloc.height;
-    panel->vadjustment->step_increment = view->line_height;
-    panel->vadjustment->page_increment = panel->vadjustment->step_increment * 10.0;
+    gtk_adjustment_set_page_size(panel->vadjustment, valloc.height);
+    gtk_adjustment_set_step_increment(panel->vadjustment, view->line_height);
+    gtk_adjustment_set_page_increment(panel->vadjustment, view->line_height * 10.0);
 
-    panel->vadjustment->upper = MAX(height, valloc.height);
+    gtk_adjustment_set_upper(panel->vadjustment, MAX(height, valloc.height));
 
     gtk_view_panel_reclamp_adjustment(panel->vadjustment, &changed);
 
@@ -405,8 +443,8 @@ static void gtk_buffer_view_size_allocate(GtkWidget *widget, GtkAllocation *allo
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : view  = composant GTK à redessiner.                          *
-*                event = informations liées à l'événement.                    *
+*  Paramètres  : widget = composant GTK à redessiner.                         *
+*                cr     = contexte graphique associé à l'événement.           *
 *                                                                             *
 *  Description : Met à jour l'affichage de la visualisation de code buffer.   *
 *                                                                             *
@@ -416,62 +454,75 @@ static void gtk_buffer_view_size_allocate(GtkWidget *widget, GtkAllocation *allo
 *                                                                             *
 ******************************************************************************/
 
-static gboolean gtk_buffer_view_expose(GtkWidget *widget, GdkEventExpose *event)
+static gboolean gtk_buffer_view_draw(GtkWidget *widget, cairo_t *cr)
 {
     GtkBufferView *view;                    /* Autre version du composant  */
     GtkViewPanel *pview;                    /* Autre version du composant  */
-    GtkStyle *style;                        /* Style associé au composant  */
-    GdkDrawable *drawable;                  /* Surface de dessin           */
+    cairo_region_t *region;                 /* Région visible à redessiner */
+    cairo_rectangle_int_t area;             /* Surface correspondante      */
     gint fake_x;                            /* Abscisse virtuelle          */
     gint fake_y;                            /* Ordonnée virtuelle          */
-    GtkStateType state;                     /* Etat du composant           */
-    GtkViewPanelClass *parent_class;        /* Version pure du parent      */
+    GtkStateFlags state;                    /* Etat du composant           */
+    GdkRGBA *color;                         /* Couleur du curseur          */
 
     view = GTK_BUFFER_VIEW(widget);
     widget = GTK_WIDGET(view);
     pview = GTK_VIEW_PANEL(widget);
 
-    drawable = GDK_DRAWABLE(event->window);
-
-    gdk_window_begin_paint_region(drawable, event->region);
-
-    //gdk_gc_set_clip_region(pview->gc, event->region);
-
-    style = gtk_widget_get_style(GTK_WIDGET(view));
+    region = gdk_window_get_visible_region(gtk_widget_get_window(widget));
+    cairo_region_get_extents(region, &area);
+    cairo_region_destroy(region);
 
     fake_x = 0;
     fake_y = 0;
     gtk_buffer_view_compute_fake_coord(view, &fake_x, &fake_y);
 
+
+    do
+    {
+
+
+        GtkStyleContext *context;
+
+
+        context = gtk_widget_get_style_context(widget);
+
+        gtk_render_background(context, cr, 0, 0, 250, 250);
+
+        printf("Passage!\n");
+
+
+    } while (0);
+
+
+
     /* Dessin de la marge gauche */
 
-    state = gtk_widget_get_state(widget);
+    state = gtk_widget_get_state_flags(widget);
 
-    gdk_gc_set_foreground(pview->gc, &style->mid[state]);
+    gtk_style_context_get(gtk_widget_get_style_context(widget), state,
+                          GTK_STYLE_PROPERTY_BACKGROUND_COLOR, &color, NULL);
 
-    gdk_draw_rectangle(drawable, pview->gc, TRUE,
-                       fake_x, event->area.y, view->left_margin, event->area.y + event->area.height);
+    cairo_rectangle(cr, fake_x, area.y,view->left_margin, area.y + area.height);
+    cairo_fill(cr);
 
-    gdk_gc_set_foreground(pview->gc, &style->dark[state]);
+    gtk_style_context_get(gtk_widget_get_style_context(widget), state,
+                          GTK_STYLE_PROPERTY_BORDER_COLOR, &color, NULL);
 
-    gdk_draw_line(drawable, pview->gc,
-                  fake_x + view->left_margin, event->area.y,
-                  fake_x + view->left_margin, event->area.y + event->area.height);
+    cairo_move_to(cr, fake_x + view->left_margin, area.y);
+    cairo_line_to(cr, fake_x + view->left_margin, area.y + area.height);
+    cairo_fill(cr);
 
     /* Eventuelle bordure globale */
 
-    parent_class = g_type_class_peek(g_type_parent(GTK_TYPE_BUFFER_VIEW));
-
-    GTK_WIDGET_CLASS(parent_class)->expose_event(widget, event);
+    GTK_WIDGET_CLASS(gtk_buffer_view_parent_class)->draw(widget, cr);
 
     /* Impression du désassemblage */
 
     if (view->buffer_view != NULL)
-        g_buffer_view_draw(view->buffer_view, event, pview->gc, fake_x, fake_y,
+        g_buffer_view_draw(view->buffer_view, cr, fake_x, fake_y, &area,
                            *pview->display_addr, *pview->display_code);
 
-    gdk_window_end_paint(drawable);
-
     return TRUE;
 
 }
@@ -633,7 +684,8 @@ void gtk_buffer_view_attach_buffer(GtkBufferView *view, GBufferView *buffer, boo
 
     /* Validation finale */
 
-    g_buffer_view_get_size(view->buffer_view, &width, &height, *addr, *code);
+    width = g_buffer_view_get_width(view->buffer_view, *addr, *code);
+    height = g_buffer_view_get_height(view->buffer_view);
 
     width += -view->left_text + 1;
     height += 1;
@@ -754,10 +806,8 @@ static gboolean gtk_buffer_view_refresh_caret(GtkBufferView *view)
 {
     GtkWidget *widget;                      /* Autre version du composant  */
     GdkRectangle area;                      /* Région adaptée à traiter    */
-    GdkDrawable *drawable;                  /* Surface de dessin           */
-    GtkStyle *style;                        /* Style associé au composant  */
-    GtkStateType state;                     /* Etat du composant           */
-    GdkGC *gc;                              /* Contexte graphique          */
+    cairo_t *cr;                            /* Contexte graphique          */
+    GdkRGBA *color;                         /* Couleur du curseur          */
 
     widget = GTK_WIDGET(view);
 
@@ -776,16 +826,18 @@ static gboolean gtk_buffer_view_refresh_caret(GtkBufferView *view)
     {
         view->show_caret = true;
 
-        drawable = GDK_DRAWABLE(widget->window);
-        state = gtk_widget_get_state(widget);
-        style = gtk_widget_get_style(widget);
+        cr = gdk_cairo_create(gtk_widget_get_window(widget));
+
+        gtk_style_context_get(gtk_widget_get_style_context(widget),
+                              gtk_widget_get_state_flags(widget),
+                              GTK_STYLE_PROPERTY_COLOR, &color, NULL);
 
-        gc = gdk_gc_new(drawable);
-        gdk_gc_set_foreground(gc, &style->text[state]);
+        cairo_set_source_rgb(cr, color->red, color->green, color->blue);
 
-        gdk_draw_rectangle(drawable, gc, TRUE, area.x, area.y, area.width, area.height);
+        cairo_rectangle(cr, area.x, area.y, area.width, area.height);
+        cairo_fill(cr);
 
-        gdk_gc_destroy(gc);
+        cairo_destroy(cr);
 
     }