Supported scrolling internally and thus fixed bugs with big binaries.

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

1 files changed, 194 insertions, 66 deletions

diff --git a/src/gtkext/gtkblockview.c b/src/gtkext/gtkblockview.c
index 0a23317..a79b3ff 100644
--- a/src/gtkext/gtkblockview.c
+++ b/src/gtkext/gtkblockview.c
@@ -153,13 +153,21 @@ gtk_text_view2_set_attributes_from_style (GtkTextAttributes  *values,
 /* Procède à l'initialisation de l'afficheur d'un bloc binaire. */
 static void gtk_block_view_init(GtkBlockView *);
 
-
-
 /* Encadre la construction graphique initiale de la visualisation. */
 static void gtk_block_view_realize(GtkWidget *);
 
+/* Fournit la taille de composant requise pour un plein rendu. */
+static void gtk_block_view_size_request(GtkWidget *, GtkRequisition *);
+
+/* S'adapte à la surface concédée par le composant parent. */
+static void gtk_block_view_size_allocate(GtkWidget *, GtkAllocation *);
+
+
 
 
+/* Réagit à un défilement quelconque. */
+static void gtk_block_view_scroll(GtkBlockView *);
+
 /* Définit les lignes du bloc de représentation. */
 static void gtk_block_view_set_rendering_lines(GtkBlockView *, GRenderingLine *, GRenderingLine *);
 
@@ -191,9 +199,6 @@ static bool gtk_block_view_get_address_coordinates(const GtkBlockView *, vmpa_t,
 
 
 static void gtk_block_view_class_init(GtkBlockViewClass *klass);
-static void gtk_block_view_init(GtkBlockView *cpu);
-static void gtk_block_view_size_request(GtkWidget *widget,
-    GtkRequisition *requisition);
 static void gtk_block_view_size_allocate(GtkWidget *widget,
     GtkAllocation *allocation);
 
@@ -203,6 +208,8 @@ static gboolean gtk_block_view_button_press(GtkWidget *, GdkEventButton *event);
 /* Met à jour l'affichage de la vue sous forme de bloc. */
 static gboolean gtk_block_view_expose(GtkWidget *, GdkEventExpose *);
 
+
+
 static void gtk_block_view_destroy(GtkObject *object);
 
 
@@ -480,6 +487,7 @@ static void gtk_block_view_init(GtkBlockView *view)
 
     binview = GTK_BIN_VIEW(view);
 
+    binview->scroll = (scroll_fc)gtk_block_view_scroll;
     binview->set_lines = (set_rendering_lines_fc)gtk_block_view_set_rendering_lines;
     binview->get_coordinates = (get_addr_coordinates_fc)gtk_block_view_get_address_coordinates;
 
@@ -531,7 +539,7 @@ static void gtk_block_view_init(GtkBlockView *view)
         style->left_margin = 10;
         style->right_margin = 10;
 
-        style->wrap_mode = GTK_WRAP_WORD;
+        style->wrap_mode = GTK_WRAP_NONE;
         style->justification = GTK_JUSTIFY_LEFT;
 
         style->direction = gtk_widget_get_direction(view);
@@ -544,49 +552,11 @@ static void gtk_block_view_init(GtkBlockView *view)
 
         //gtk_text_layout_get_size (GTK_BLOCK_VIEW(view)->layout, &width, &height);
 
-        gtk_text_layout_set_screen_width (GTK_BLOCK_VIEW(view)->layout,
-                                          MAX (1, 1000));
-
     }
 
 }
 
 
-
-static void
-gtk_block_view_size_request(GtkWidget *widget,
-    GtkRequisition *requisition)
-{
-  g_return_if_fail(widget != NULL);
-  g_return_if_fail(GTK_IS_BLOCK_VIEW(widget));
-  g_return_if_fail(requisition != NULL);
-
-  requisition->width = 80;
-  requisition->height = 100;
-}
-
-
-static void
-gtk_block_view_size_allocate(GtkWidget *widget,
-    GtkAllocation *allocation)
-{
-  g_return_if_fail(widget != NULL);
-  g_return_if_fail(GTK_IS_BLOCK_VIEW(widget));
-  g_return_if_fail(allocation != NULL);
-
-  widget->allocation = *allocation;
-
-  if (GTK_WIDGET_REALIZED(widget)) {
-     gdk_window_move_resize(
-         widget->window,
-         allocation->x, allocation->y,
-         allocation->width, allocation->height
-     );
-   }
-}
-
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : widget = composant GTK à redessiner.                         *
@@ -615,6 +585,101 @@ static void gtk_block_view_realize(GtkWidget *widget)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : widget      = composant GTK à consulter.                     *
+*                requisition = dimensions souhaitées. [OUT]                   *
+*                                                                             *
+*  Description : Fournit la taille de composant requise pour un plein rendu.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_block_view_size_request(GtkWidget *widget, GtkRequisition *requisition)
+{
+    gtk_text_layout_get_size(GTK_BLOCK_VIEW(widget)->layout,
+                             &requisition->width, &requisition->height);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : view       = composant GTK à mettre à jour.                  *
+*                allocation = étendue accordée à la vue.                      *
+*                                                                             *
+*  Description : S'adapte à la surface concédée par le composant parent.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_block_view_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
+{
+    GtkBinView *view;                       /* Autre version du composant  */
+    gint width;                             /* Largeur de l'objet actuelle */
+    gint height;                            /* Hauteur de l'objet actuelle */
+    GtkAllocation valloc;                   /* Surface utilisable          */
+    gboolean changed;                       /* Changement de valeur ?      */
+
+    /* Mise à jour GTK */
+
+    widget->allocation = *allocation;
+
+    if (GTK_WIDGET_REALIZED(widget))
+        gdk_window_move_resize(widget->window,
+                               allocation->x, allocation->y,
+                               allocation->width, allocation->height);
+
+    view = GTK_BIN_VIEW(widget);
+
+    if (view->hadjustment == NULL || view->vadjustment == NULL)
+        return;
+
+    gtk_text_layout_get_size(GTK_BLOCK_VIEW(view)->layout, &width, &height);
+
+    gtk_bin_view_compute_allocation(view, &valloc);
+
+    /* Défilement horizontal */
+
+    view->hadjustment->page_size = valloc.width;
+    view->hadjustment->step_increment = valloc.width * 0.1;
+    view->hadjustment->page_increment = valloc.width * 0.9;
+
+    view->hadjustment->upper = MAX(width, valloc.width);
+
+    gtk_bin_view_reclamp_adjustment(view->hadjustment, &changed);
+
+    gtk_adjustment_changed(view->hadjustment);
+
+    if (changed)
+        gtk_adjustment_value_changed(view->hadjustment);
+
+    /* Défilement vertical */
+
+    view->vadjustment->page_size = valloc.height;
+    view->vadjustment->step_increment = GTK_BLOCK_VIEW(view)->line_height;
+    view->vadjustment->page_increment = view->vadjustment->step_increment * 10.0;
+
+    view->vadjustment->upper = MAX(height, valloc.height);
+
+    gtk_bin_view_reclamp_adjustment(view->vadjustment, &changed);
+
+    gtk_adjustment_changed(view->vadjustment);
+
+    if (changed)
+        gtk_adjustment_value_changed(view->vadjustment);
+
+}
+
+
+
+
 static gboolean gtk_block_view_button_press(GtkWidget *widget, GdkEventButton *event)
 {
     gboolean result;                        /* Décision à retourner        */
@@ -682,20 +747,67 @@ void gtk_block_view_update_margin(GRenderingLine *line, GtkBlockView *view)
 *                                                                             *
 *  Description : Met à jour l'affichage de la vue sous forme de bloc.         *
 *                                                                             *
-*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
+static void gtk_block_view_compute_fake_coord(GtkBlockView *view, gint *x, gint *y)
+{
+    if (GTK_BIN_VIEW(view)->hadjustment != NULL)
+        *x -= gtk_adjustment_get_value(GTK_BIN_VIEW(view)->hadjustment);
+
+    if (GTK_BIN_VIEW(view)->vadjustment != NULL)
+        *y += gtk_adjustment_get_value(GTK_BIN_VIEW(view)->vadjustment);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : view  = composant GTK à redessiner.                          *
+*                event = informations liées à l'événement.                    *
+*                                                                             *
+*  Description : Met à jour l'affichage de la vue sous forme de bloc.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_block_view_compute_real_coord(GtkBlockView *view, gint *x, gint *y)
 {
-    GtkBlockView *view;
+    if (GTK_BIN_VIEW(view)->hadjustment != NULL)
+        *x += gtk_adjustment_get_value(GTK_BIN_VIEW(view)->hadjustment);
+
+    if (GTK_BIN_VIEW(view)->vadjustment != NULL)
+        *y -= gtk_adjustment_get_value(GTK_BIN_VIEW(view)->vadjustment);
+
+}
 
 
-    //GtkWidget *widget;                      /* Autre version du composant  */
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : view  = composant GTK à redessiner.                          *
+*                event = informations liées à l'événement.                    *
+*                                                                             *
+*  Description : Met à jour l'affichage de la vue sous forme de bloc.         *
+*                                                                             *
+*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
+{
+    GtkBlockView *view;                     /* Autre version du composant  */
     GtkBinView *bview;                      /* Autre version du composant  */
     GtkStyle *style;                        /* Style associé au composant  */
+    gint fake_x;                            /* Abscisse virtuelle          */
+    gint fake_y;                            /* Ordonnée virtuelle          */
     GtkBinViewClass *parent_class;          /* Version pure du parent      */
     GtkTextIter iter;                       /* Point d'insertion           */
     GdkRectangle rect;                      /* Zone d'un point             */
@@ -726,22 +838,22 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
 
     style = gtk_widget_get_style(GTK_WIDGET(view));
 
-
-    //gtk_widget_get_size_request(widget, &width, &height);
-
+    fake_x = 0;
+    fake_y = 0;
+    gtk_block_view_compute_fake_coord(view, &fake_x, &fake_y);
 
     /* Dessin de la marge gauche */
 
     gdk_gc_set_foreground(bview->gc, &style->mid[GTK_WIDGET_STATE(widget)]);
 
     gdk_draw_rectangle(GDK_DRAWABLE(widget->window), bview->gc, TRUE,
-                       0, event->area.y, view->left_margin, event->area.y + event->area.height);
+                       fake_x, event->area.y, view->left_margin, event->area.y + event->area.height);
 
     gdk_gc_set_foreground(bview->gc, &style->dark[GTK_WIDGET_STATE(widget)]);
 
     gdk_draw_line(GDK_DRAWABLE(widget->window), bview->gc,
-                  view->left_margin, event->area.y,
-                  view->left_margin, event->area.y + event->area.height);
+                  fake_x + view->left_margin, event->area.y,
+                  fake_x + view->left_margin, event->area.y + event->area.height);
 
     /* Eventuelle bordure globale */
 
@@ -751,11 +863,13 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
 
     /* Informations individuelles des lignes */
 
-    gtk_text_layout_get_line_at_y(view->layout, &iter, event->area.y, NULL);
+    gtk_text_layout_get_line_at_y(view->layout, &iter, fake_y, NULL);
     gtk_text_layout_get_iter_location(view->layout, &iter, &rect);
 
-    while (rect.y < (event->area.y + event->area.height))
+    while (rect.y < (fake_y + event->area.height))
     {
+        gtk_block_view_compute_real_coord(view, &rect.x, &rect.y);
+
         mark = gtk_text_iter_get_marks(&iter)->data;
 
         line = g_object_get_data(G_OBJECT(mark), "line");
@@ -770,7 +884,7 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
         else pixbuf = NULL;
 
         if (pixbuf != NULL)
-            gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, 10, rect.y,
+            gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, fake_x + 10, rect.y,
                             gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
                             GDK_RGB_DITHER_NORMAL, 0, 0);
 
@@ -779,7 +893,7 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
         {
             pixbuf = GTK_BLOCK_VIEW_GET_CLASS(view)->entry_pix;
 
-            gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, 10, rect.y,
+            gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, fake_x + 10, rect.y,
                             gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
                             GDK_RGB_DITHER_NORMAL, 0, 0);
 
@@ -792,17 +906,10 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
 
     /* Impression du désassemblage */
 
-
-    gtk_text_layout_set_screen_width (GTK_BLOCK_VIEW(bview)->layout,
-                                      MAX (1, 1000));
-
-
-
     gtk_text_layout_draw(GTK_BLOCK_VIEW(bview)->layout, widget, GDK_DRAWABLE(widget->window),
-                         NULL, view->left_text, 0, event->area.x, event->area.y,
+                         NULL, -fake_x + view->left_text, fake_y, event->area.x, event->area.y,
                          event->area.width, event->area.height, &child_exposes);
 
-
     gdk_window_end_paint(GDK_DRAWABLE(widget->window));
 
     return TRUE;
@@ -810,6 +917,8 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
 }
 
 
+
+
 static void
 gtk_block_view_destroy(GtkObject *object)
 {
@@ -903,6 +1012,25 @@ void gtk_block_view_set_format(GtkBlockView *view, const exe_format *format)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : view  = composant GTK à mettre à jour.                       *
+*                                                                             *
+*  Description : Réagit à un défilement quelconque.                           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_block_view_scroll(GtkBlockView *view)
+{
+    gtk_widget_queue_draw(GTK_WIDGET(view));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : view  = composant GTK à mettre à jour.                       *
 *                lines = informations à intégrer.                             *
 *                last  = dernière ligne à intégrer ou NULL pour toutes.       *
 *                                                                             *