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