gtk/gtkviscreen.c

   1 #include <stdio.h>
   2 #include <string.h>
   3
   4 #include <gtk/gtkmain.h>
   5 #include <gtk/gtksignal.h>
   6 #include "gtkviscreen.h"
   7
   8 #define DEFAULT_VI_SCREEN_WIDTH_CHARS     80
   9 #define DEFAULT_VI_SCREEN_HEIGHT_LINES    25
  10 #define VI_SCREEN_BORDER_ROOM         1
  11
  12 enum {
  13   ARG_0,
  14   ARG_VADJUSTMENT,
  15 };
  16
  17 enum {
  18     RESIZED,
  19     LAST_SIGNAL
  20 };
  21
  22 static void gtk_vi_screen_class_init     (GtkViScreenClass   *klass);
  23 static void gtk_vi_screen_set_arg        (GtkObject      *object,
  24                                           GtkArg         *arg,
  25                                           guint           arg_id);
  26 static void gtk_vi_screen_get_arg        (GtkObject      *object,
  27                                           GtkArg         *arg,
  28                                           guint           arg_id);
  29 static void gtk_vi_screen_init           (GtkViScreen        *vi);
  30 static void gtk_vi_screen_destroy        (GtkObject      *object);
  31 static void gtk_vi_screen_realize        (GtkWidget      *widget);
  32 /*
  33 static void gtk_vi_screen_map (GtkWidget *widget);
  34 static void gtk_vi_screen_unmap (GtkWidget *widget);
  35 */
  36 static void gtk_vi_screen_size_request   (GtkWidget      *widget,
  37                                       GtkRequisition *requisition);
  38 static void gtk_vi_screen_size_allocate  (GtkWidget      *widget,
  39                                       GtkAllocation  *allocation);
  40 /*
  41 static void gtk_vi_screen_adjustment     (GtkAdjustment  *adjustment,
  42                                       GtkViScreen        *text);
  43 */
  44
  45 static void gtk_vi_screen_draw              (GtkWidget         *widget,
  46                                          GdkRectangle      *area);
  47 static gint gtk_vi_screen_expose            (GtkWidget         *widget,
  48                                          GdkEventExpose    *event);
  49
  50 static void recompute_geometry (GtkViScreen* vi);
  51 static void expose_text (GtkViScreen* vi, GdkRectangle *area, gboolean cursor);
  52 static void draw_lines(GtkViScreen *vi, gint y, gint x, gint ymax, gint xmax);
  53 static void mark_lines(GtkViScreen *vi, gint ymin, gint xmin, gint ymax, gint xmax);
  54
  55 static GtkWidgetClass *parent_class = NULL;
  56 static guint vi_screen_signals[LAST_SIGNAL] = { 0 };
  57
  58 #define CharAt(scr,y,x) scr->chars + (y) * scr->cols + x
  59 #define FlagAt(scr,y,x) (scr->reverse + (y) * scr->cols + x)
  60
  61 #define COLOR_STANDARD      0x00
  62 #define COLOR_STANDOUT      0x01
  63
  64 /* XXX */
  65 enum { SA_ALTERNATE, SA_INVERSE };
  66
  67 void
  68 gtk_vi_screen_attribute(GtkViScreen *vi, gint attribute, gint on)
  69 {
  70     switch (attribute) {
  71     case SA_ALTERNATE:
  72         fprintf(stderr, "alternate: %d\n", on);
  73         break;
  74     case SA_INVERSE:
  75         vi->color = on ? COLOR_STANDOUT : COLOR_STANDARD;
  76         break;
  77     }
  78 }
  79
  80 void
  81 gtk_vi_screen_move(GtkViScreen *vi, gint row, gint col)
  82 {
  83     mark_lines(vi, vi->cury, vi->curx, vi->cury+1, vi->curx+1);
  84     vi->curx = col;
  85     vi->cury = row;
  86     mark_lines(vi, vi->cury, vi->curx, vi->cury+1, vi->curx+1);
  87 }
  88
  89 void
  90 gtk_vi_screen_clrtoel (GtkViScreen *vi)
  91 {
  92     memset(CharAt(vi,vi->cury,vi->curx), ' ', vi->cols - vi->curx);
  93     memset(FlagAt(vi,vi->cury,vi->curx), COLOR_STANDARD, vi->cols - vi->curx);
  94     mark_lines(vi, vi->cury, vi->curx, vi->cury+1, vi->cols);
  95 }
  96
  97 void
  98 gtk_vi_screen_addstr(GtkViScreen *vi, const char *str, int len)
  99 {
 100     /*
 101     fprintf(stderr, "%d --%.*s--\n", len, len, str);
 102     */
 103     memcpy(CharAt(vi,vi->cury,vi->curx), str, len);
 104     memset(FlagAt(vi,vi->cury,vi->curx), vi->color, len);
 105     mark_lines(vi, vi->cury, vi->curx, vi->cury+1, vi->curx + len);
 106     if ((vi->curx += len) >= vi->cols) {
 107         if (++vi->cury >= vi->rows) {
 108             vi->cury = vi->rows-1;
 109             vi->curx = vi->cols-1;
 110         } else {
 111             vi->curx = 0;
 112         }
 113     }
 114 }
 115
 116 void
 117 gtk_vi_screen_deleteln(GtkViScreen *vi)
 118 {
 119     gint y = vi->cury;
 120     gint rows = vi->rows - (y+1);
 121
 122     memmove(CharAt(vi,y,0), CharAt(vi,y+1,0), rows * vi->cols);
 123     memset(CharAt(vi,vi->rows-1,0), ' ', vi->cols);
 124     memmove(FlagAt(vi,y,0), FlagAt(vi,y+1,0), rows * vi->cols);
 125     memset(FlagAt(vi,vi->rows-1,0), COLOR_STANDARD, vi->cols);
 126     mark_lines(vi, y, 0, vi->rows, vi->cols);
 127 }
 128
 129 void
 130 gtk_vi_screen_insertln(GtkViScreen *vi)
 131 {
 132     gint y = vi->cury;
 133     gint rows = vi->rows - (y+1);
 134
 135     memmove(CharAt(vi,y+1,0), CharAt(vi,y,0), rows * vi->cols);
 136     memset(CharAt(vi,y,0), ' ', vi->cols);
 137     memmove(FlagAt(vi,y+1,0), FlagAt(vi,y,0), rows * vi->cols);
 138     memset(FlagAt(vi,y,0), COLOR_STANDARD, vi->cols);
 139     mark_lines(vi, y, 0, vi->rows, vi->cols);
 140 }
 141
 142 void
 143 gtk_vi_screen_refresh(GtkViScreen *vi)
 144 {
 145     if (vi->marked_maxy == 0)
 146         return;
 147     draw_lines(vi, vi->marked_y, vi->marked_x, vi->marked_maxy, vi->marked_maxx);
 148     vi->marked_x = vi->cols;
 149     vi->marked_y = vi->rows;
 150     vi->marked_maxx = 0;
 151     vi->marked_maxy = 0;
 152 }
 153
 154 void
 155 gtk_vi_screen_rewrite(GtkViScreen *vi, gint row)
 156 {
 157     memset(FlagAt(vi,row,0), COLOR_STANDARD, vi->cols);
 158     mark_lines(vi, row, 0, row+1, vi->cols);
 159 }
 160
 161 GtkType
 162 gtk_vi_screen_get_type (void)
 163 {
 164   static GtkType vi_screen_type = 0;
 165
 166   if (!vi_screen_type)
 167     {
 168       static const GtkTypeInfo vi_screen_info =
 169       {
 170         "GtkViScreen",
 171         sizeof (GtkViScreen),
 172         sizeof (GtkViScreenClass),
 173         (GtkClassInitFunc) gtk_vi_screen_class_init,
 174         (GtkObjectInitFunc) gtk_vi_screen_init,
 175         /* reserved_1 */ NULL,
 176         /* reserved_2 */ NULL,
 177         (GtkClassInitFunc) NULL,
 178       };
 179
 180       vi_screen_type = gtk_type_unique (GTK_TYPE_WIDGET, &vi_screen_info);
 181     }
 182
 183   return vi_screen_type;
 184 }
 185
 186 static void
 187 gtk_vi_screen_class_init (GtkViScreenClass *class)
 188 {
 189   GtkObjectClass *object_class;
 190   GtkWidgetClass *widget_class;
 191
 192   object_class = (GtkObjectClass*) class;
 193   widget_class = (GtkWidgetClass*) class;
 194   parent_class = gtk_type_class (GTK_TYPE_WIDGET);
 195
 196   vi_screen_signals[RESIZED] =
 197     gtk_signal_new ("resized",
 198                     GTK_RUN_FIRST,
 199                     object_class->type,
 200                     GTK_SIGNAL_OFFSET (GtkViScreenClass, resized),
 201                     gtk_marshal_NONE__INT_INT,
 202                     GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT, 0);
 203
 204   gtk_object_class_add_signals(object_class, vi_screen_signals, LAST_SIGNAL);
 205
 206   gtk_object_add_arg_type ("GtkViScreen::vadjustment",
 207                            GTK_TYPE_ADJUSTMENT,
 208                            GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
 209                            ARG_VADJUSTMENT);
 210
 211   object_class->set_arg = gtk_vi_screen_set_arg;
 212   object_class->get_arg = gtk_vi_screen_get_arg;
 213   object_class->destroy = gtk_vi_screen_destroy;
 214
 215   widget_class->realize = gtk_vi_screen_realize;
 216   /*
 217   widget_class->map = gtk_vi_screen_map;
 218   widget_class->unmap = gtk_vi_screen_unmap;
 219   */
 220   widget_class->size_request = gtk_vi_screen_size_request;
 221   widget_class->size_allocate = gtk_vi_screen_size_allocate;
 222   widget_class->draw = gtk_vi_screen_draw;
 223   widget_class->expose_event = gtk_vi_screen_expose;
 224
 225   class->rename = NULL;
 226   class->resized = NULL;
 227 }
 228
 229 static void
 230 gtk_vi_screen_set_arg (GtkObject        *object,
 231                       GtkArg           *arg,
 232                       guint             arg_id)
 233 {
 234   GtkViScreen *vi_screen;
 235
 236   vi_screen = GTK_VI_SCREEN (object);
 237
 238   switch (arg_id)
 239     {
 240     case ARG_VADJUSTMENT:
 241       gtk_vi_screen_set_adjustment (vi_screen, GTK_VALUE_POINTER (*arg));
 242       break;
 243     default:
 244       break;
 245     }
 246 }
 247
 248 static void
 249 gtk_vi_screen_get_arg (GtkObject        *object,
 250                       GtkArg           *arg,
 251                       guint             arg_id)
 252 {
 253   GtkViScreen *vi_screen;
 254
 255   vi_screen = GTK_VI_SCREEN (object);
 256
 257   switch (arg_id)
 258     {
 259     case ARG_VADJUSTMENT:
 260       GTK_VALUE_POINTER (*arg) = vi_screen->vadj;
 261       break;
 262     default:
 263       arg->type = GTK_TYPE_INVALID;
 264       break;
 265     }
 266 }
 267
 268 static void
 269 gtk_vi_screen_init (GtkViScreen *vi)
 270 {
 271   GtkStyle *style;
 272
 273   GTK_WIDGET_SET_FLAGS (vi, GTK_CAN_FOCUS);
 274
 275   vi->text_area = NULL;
 276   vi->chars = 0;
 277   vi->reverse = 0;
 278   vi->color = COLOR_STANDARD;
 279   vi->cols = 0;
 280   vi->rows = 0;
 281
 282   style = gtk_style_copy(GTK_WIDGET(vi)->style);
 283   style->font = gdk_font_load("fixed");
 284   GTK_WIDGET(vi)->style = style;
 285 }
 286
 287 static void
 288 gtk_vi_screen_destroy (GtkObject *object)
 289 {
 290   GtkViScreen *vi_screen;
 291
 292   g_return_if_fail (object != NULL);
 293   g_return_if_fail (GTK_IS_VI_SCREEN (object));
 294
 295   vi_screen = (GtkViScreen*) object;
 296
 297   /*
 298   gtk_signal_disconnect_by_data (GTK_OBJECT (vi_screen->vadj), vi_screen);
 299   */
 300
 301   GTK_OBJECT_CLASS(parent_class)->destroy (object);
 302 }
 303
 304 GtkWidget*
 305 gtk_vi_screen_new (GtkAdjustment *vadj)
 306 {
 307   GtkWidget *vi;
 308
 309   vi = gtk_widget_new (GTK_TYPE_VI_SCREEN,
 310                          "vadjustment", vadj,
 311                          NULL);
 312
 313
 314   return vi;
 315 }
 316
 317 void
 318 gtk_vi_screen_set_adjustment (GtkViScreen       *vi_screen,
 319                           GtkAdjustment *vadj)
 320 {
 321   g_return_if_fail (vi_screen != NULL);
 322   g_return_if_fail (GTK_IS_VI_SCREEN (vi_screen));
 323   if (vadj)
 324     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
 325   else
 326     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 1.0, 0.0, 1.0, 0.0, 0.0));
 327
 328   if (vi_screen->vadj && (vi_screen->vadj != vadj))
 329     {
 330       gtk_signal_disconnect_by_data (GTK_OBJECT (vi_screen->vadj), vi_screen);
 331       gtk_object_unref (GTK_OBJECT (vi_screen->vadj));
 332     }
 333
 334   if (vi_screen->vadj != vadj)
 335     {
 336       vi_screen->vadj = vadj;
 337       gtk_object_ref (GTK_OBJECT (vi_screen->vadj));
 338       gtk_object_sink (GTK_OBJECT (vi_screen->vadj));
 339
 340       /*
 341       gtk_signal_connect (GTK_OBJECT (vi_screen->vadj), "changed",
 342                           (GtkSignalFunc) gtk_vi_screen_adjustment,
 343                           vi_screen);
 344       gtk_signal_connect (GTK_OBJECT (vi_screen->vadj), "value_changed",
 345                           (GtkSignalFunc) gtk_vi_screen_adjustment,
 346                           vi_screen);
 347       gtk_signal_connect (GTK_OBJECT (vi_screen->vadj), "disconnect",
 348                           (GtkSignalFunc) gtk_vi_screen_disconnect,
 349                           vi_screen);
 350       gtk_vi_screen_adjustment (vadj, vi_screen);
 351       */
 352     }
 353 }
 354
 355 static void
 356 gtk_vi_screen_realize (GtkWidget *widget)
 357 {
 358   GtkViScreen *vi;
 359   GdkWindowAttr attributes;
 360   gint attributes_mask;
 361
 362   g_return_if_fail (widget != NULL);
 363   g_return_if_fail (GTK_IS_VI_SCREEN (widget));
 364
 365   vi = GTK_VI_SCREEN (widget);
 366   GTK_WIDGET_SET_FLAGS (vi, GTK_REALIZED);
 367
 368   attributes.window_type = GDK_WINDOW_CHILD;
 369   attributes.x = widget->allocation.x;
 370   attributes.y = widget->allocation.y;
 371   attributes.width = widget->allocation.width;
 372   attributes.height = widget->allocation.height;
 373   attributes.wclass = GDK_INPUT_OUTPUT;
 374   attributes.visual = gtk_widget_get_visual (widget);
 375   attributes.colormap = gtk_widget_get_colormap (widget);
 376   attributes.event_mask = gtk_widget_get_events (widget);
 377   attributes.event_mask |= (GDK_EXPOSURE_MASK |
 378                             GDK_BUTTON_PRESS_MASK |
 379                             GDK_BUTTON_RELEASE_MASK |
 380                             GDK_BUTTON_MOTION_MASK |
 381                             GDK_ENTER_NOTIFY_MASK |
 382                             GDK_LEAVE_NOTIFY_MASK |
 383                             GDK_KEY_PRESS_MASK);
 384   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 385
 386   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 387   gdk_window_set_user_data (widget->window, vi);
 388
 389   attributes.x = (widget->style->klass->xthickness + VI_SCREEN_BORDER_ROOM);
 390   attributes.y = (widget->style->klass->ythickness + VI_SCREEN_BORDER_ROOM);
 391   attributes.width = MAX (1, (gint)widget->allocation.width - (gint)attributes.x * 2);
 392   attributes.height = MAX (1, (gint)widget->allocation.height - (gint)attributes.y * 2);
 393
 394   vi->text_area = gdk_window_new (widget->window, &attributes, attributes_mask);
 395   gdk_window_set_user_data (vi->text_area, vi);
 396
 397   widget->style = gtk_style_attach (widget->style, widget->window);
 398
 399   /* Can't call gtk_style_set_background here because it's handled specially */
 400   gdk_window_set_background (widget->window, &widget->style->base[GTK_STATE_NORMAL]);
 401   gdk_window_set_background (vi->text_area, &widget->style->base[GTK_STATE_NORMAL]);
 402
 403   vi->gc = gdk_gc_new (vi->text_area);
 404   /* What's this ? */
 405   gdk_gc_set_exposures (vi->gc, TRUE);
 406   gdk_gc_set_foreground (vi->gc, &widget->style->text[GTK_STATE_NORMAL]);
 407
 408   vi->reverse_gc = gdk_gc_new (vi->text_area);
 409   gdk_gc_set_foreground (vi->reverse_gc, &widget->style->base[GTK_STATE_NORMAL]);
 410
 411   gdk_window_show (vi->text_area);
 412
 413   recompute_geometry (vi);
 414 }
 415
 416 static void
 417 gtk_vi_screen_size_request (GtkWidget      *widget,
 418                        GtkRequisition *requisition)
 419 {
 420   gint xthickness;
 421   gint ythickness;
 422   gint char_height;
 423   gint char_width;
 424   GtkViScreen *vi;
 425
 426   g_return_if_fail (widget != NULL);
 427   g_return_if_fail (GTK_IS_VI_SCREEN (widget));
 428   g_return_if_fail (requisition != NULL);
 429
 430   vi = GTK_VI_SCREEN (widget);
 431
 432   xthickness = widget->style->klass->xthickness + VI_SCREEN_BORDER_ROOM;
 433   ythickness = widget->style->klass->ythickness + VI_SCREEN_BORDER_ROOM;
 434
 435   vi->ch_ascent = widget->style->font->ascent;
 436   vi->ch_height = (widget->style->font->ascent + widget->style->font->descent);
 437   vi->ch_width = gdk_text_width (widget->style->font, "A", 1);
 438   char_height = DEFAULT_VI_SCREEN_HEIGHT_LINES * vi->ch_height;
 439   char_width = DEFAULT_VI_SCREEN_WIDTH_CHARS * vi->ch_width;
 440
 441   requisition->width  = char_width  + xthickness * 2;
 442   requisition->height = char_height + ythickness * 2;
 443 }
 444
 445 static void
 446 gtk_vi_screen_size_allocate (GtkWidget     *widget,
 447                         GtkAllocation *allocation)
 448 {
 449   GtkViScreen *vi;
 450
 451   g_return_if_fail (widget != NULL);
 452   g_return_if_fail (GTK_IS_VI_SCREEN (widget));
 453   g_return_if_fail (allocation != NULL);
 454
 455   vi = GTK_VI_SCREEN (widget);
 456
 457   widget->allocation = *allocation;
 458   if (GTK_WIDGET_REALIZED (widget))
 459     {
 460       gdk_window_move_resize (widget->window,
 461                               allocation->x, allocation->y,
 462                               allocation->width, allocation->height);
 463
 464       gdk_window_move_resize (vi->text_area,
 465                               widget->style->klass->xthickness + VI_SCREEN_BORDER_ROOM,
 466                               widget->style->klass->ythickness + VI_SCREEN_BORDER_ROOM,
 467                               MAX (1, (gint)widget->allocation.width - (gint)(widget->style->klass->xthickness +
 468                                                           (gint)VI_SCREEN_BORDER_ROOM) * 2),
 469                               MAX (1, (gint)widget->allocation.height - (gint)(widget->style->klass->ythickness +
 470                                                            (gint)VI_SCREEN_BORDER_ROOM) * 2));
 471
 472       recompute_geometry (vi);
 473     }
 474 }
 475
 476 /*
 477 static void
 478 gtk_vi_screen_adjustment (GtkAdjustment *adjustment,
 479                          GtkViScreen       *vi_screen)
 480 {
 481   g_return_if_fail (adjustment != NULL);
 482   g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 483   g_return_if_fail (vi_screen != NULL);
 484   g_return_if_fail (GTK_IS_VI_SCREEN (vi_screen));
 485
 486 }
 487 */
 488
 489 static void
 490 gtk_vi_screen_draw (GtkWidget    *widget,
 491                GdkRectangle *area)
 492 {
 493   g_return_if_fail (widget != NULL);
 494   g_return_if_fail (GTK_IS_VI_SCREEN (widget));
 495   g_return_if_fail (area != NULL);
 496
 497   if (GTK_WIDGET_DRAWABLE (widget))
 498     {
 499       expose_text (GTK_VI_SCREEN (widget), area, TRUE);
 500       gtk_widget_draw_focus (widget);
 501     }
 502 }
 503
 504 static gint
 505 gtk_vi_screen_expose (GtkWidget      *widget,
 506                  GdkEventExpose *event)
 507 {
 508   g_return_val_if_fail (widget != NULL, FALSE);
 509   g_return_val_if_fail (GTK_IS_VI_SCREEN (widget), FALSE);
 510   g_return_val_if_fail (event != NULL, FALSE);
 511
 512   if (event->window == GTK_VI_SCREEN (widget)->text_area)
 513     {
 514       expose_text (GTK_VI_SCREEN (widget), &event->area, TRUE);
 515     }
 516   else if (event->count == 0)
 517     {
 518       gtk_widget_draw_focus (widget);
 519     }
 520
 521   return FALSE;
 522 }
 523
 524 static void
 525 recompute_geometry (GtkViScreen* vi)
 526 {
 527     //gint xthickness;
 528     //gint ythickness;
 529     gint height;
 530     gint width;
 531     gint rows, cols;
 532
 533     //xthickness = widget->style->klass->xthickness + VI_SCREEN_BORDER_ROOM;
 534     //ythickness = widget->style->klass->ythickness + VI_SCREEN_BORDER_ROOM;
 535
 536     gdk_window_get_size (vi->text_area, &width, &height);
 537
 538     rows = height / vi->ch_height;
 539     cols = width / vi->ch_width;
 540
 541     if (rows == vi->rows && cols == vi->cols)
 542         return;
 543
 544     vi->marked_x = vi->cols = cols;
 545     vi->marked_y = vi->rows = rows;
 546     vi->marked_maxx = 0;
 547     vi->marked_maxy = 0;
 548
 549     g_free(vi->chars);
 550     vi->chars = g_new(gchar, vi->rows*vi->cols);
 551     memset(vi->chars, ' ', vi->rows*vi->cols);
 552     g_free(vi->reverse);
 553     vi->reverse = g_new(gchar, vi->rows*vi->cols);
 554     memset(vi->reverse, 0, vi->rows*vi->cols);
 555
 556     gtk_signal_emit(GTK_OBJECT(vi), vi_screen_signals[RESIZED], vi->rows, vi->cols);
 557 }
 558
 559 static void
 560 expose_text (GtkViScreen* vi, GdkRectangle *area, gboolean cursor)
 561 {
 562     gint ymax;
 563     gint xmax, xmin;
 564
 565     gdk_window_clear_area (vi->text_area, area->x, area->y,
 566                             area->width, area->height);
 567     ymax = MIN((area->y + area->height + vi->ch_height - 1) / vi->ch_height,
 568                 vi->rows);
 569     xmin = area->x / vi->ch_width;
 570     xmax = MIN((area->x + area->width + vi->ch_width - 1) / vi->ch_width,
 571                 vi->cols);
 572     draw_lines(vi, area->y / vi->ch_height, xmin, ymax, xmax);
 573 }
 574
 575 #define Inverse(screen,y,x) \
 576     ((*FlagAt(screen,y,x) == COLOR_STANDOUT) ^ \
 577         (screen->cury == y && screen->curx == x))
 578
 579 static void
 580 draw_lines(GtkViScreen *vi, gint ymin, gint xmin, gint ymax, gint xmax)
 581 {
 582     gint y, x, len;
 583     gchar *line;
 584     GdkGC *fg, *bg;
 585
 586     for (y = ymin, line = vi->chars + y*vi->cols;
 587                              y < ymax; ++y, line += vi->cols) {
 588         for (x = xmin; x < xmax; x+=len) {
 589             gchar inverse;
 590             for (inverse = Inverse(vi,y,x), len = 1;
 591                     x+len < xmax && Inverse(vi,y,x+len) == inverse; ++len);
 592             if (inverse) {
 593                 fg = vi->reverse_gc;
 594                 bg = vi->gc;
 595             } else {
 596                 bg = vi->reverse_gc;
 597                 fg = vi->gc;
 598             }
 599             gdk_draw_rectangle(vi->text_area, bg, 1, x * vi->ch_width,
 600                                 y * vi->ch_height, len * vi->ch_width,
 601                                 vi->ch_height);
 602             gdk_draw_text (vi->text_area, GTK_WIDGET(vi)->style->font, fg,
 603                             x * vi->ch_width,
 604                             y * vi->ch_height + vi->ch_ascent,
 605                             line+x, len);
 606         }
 607     }
 608 }
 609
 610 static void
 611 mark_lines(GtkViScreen *vi, gint ymin, gint xmin, gint ymax, gint xmax)
 612 {
 613     if (ymin < vi->marked_y) vi->marked_y = ymin;
 614     if (xmin < vi->marked_x) vi->marked_x = xmin;
 615     if (ymax > vi->marked_maxy) vi->marked_maxy = ymax;
 616     if (xmax > vi->marked_maxx) vi->marked_maxx = xmax;
 617 }