dist/nvi/gtk/gtkviwindow.c

   1 /*      $NetBSD$ */
   2
   3 /* change further to gtkviwindow have no knowledge of ipvi */
   4 #include "config.h"
   5
   6 #include <gdk/gdkkeysyms.h>
   7 #include <gtk/gtk.h>
   8 #if 0
   9 #ifdef HAVE_ZVT
  10 #include <zvt/zvtterm.h>
  11 #include <zvt/vt.h>
  12 #endif
  13 #endif
  14
  15 #include "../common/common.h"
  16 #include "../ipc/ip.h"
  17
  18 #include "gtkvi.h"
  19 #include "gtkviscreen.h"
  20 #include "gtkviwindow.h"
  21 #include "extern.h"
  22
  23 enum {
  24     RENAME,
  25     LAST_SIGNAL
  26 };
  27
  28 static void gtk_vi_window_class_init     (GtkViWindowClass   *klass);
  29 static void gtk_vi_window_init           (GtkViWindow        *vi);
  30 static void gtk_vi_window_destroy        (GtkObject *object);
  31
  32 static int vi_key_press_event __P((GtkWidget*, GdkEventKey*, GtkViWindow*));
  33 static void vi_map __P((GtkWidget *, GtkWidget*));
  34 static void vi_resized __P((GtkWidget *, int, int, IPVIWIN*));
  35 static void vi_adjustment_value_changed __P((GtkAdjustment *, IPVIWIN *));
  36
  37 static void vi_input_func __P((gpointer , gint , GdkInputCondition));
  38
  39 static void vi_init_window __P((GtkViWindow *window, int));
  40
  41 static int vi_addstr __P((IPVIWIN*, const char *, u_int32_t));
  42 static int vi_waddstr __P((IPVIWIN*, const CHAR_T *, u_int32_t));
  43 static int vi_attribute __P((IPVIWIN*,u_int32_t  ,u_int32_t   ));
  44 static int vi_bell __P((IPVIWIN*));
  45 static int vi_busyon __P((IPVIWIN*, const char *, u_int32_t));
  46 static int vi_busyoff __P((IPVIWIN*));
  47 static int vi_clrtoeol __P((IPVIWIN*));
  48 static int vi_deleteln __P((IPVIWIN*));
  49 static int vi_discard __P((IPVIWIN*));
  50 static int vi_editopt __P((IPVIWIN*, const char *, u_int32_t,
  51                             const char *, u_int32_t, u_int32_t));
  52 static int vi_insertln __P((IPVIWIN*));
  53 static int vi_move __P((IPVIWIN*, u_int32_t, u_int32_t));
  54 static int vi_quit __P((IPVIWIN*));
  55 static int vi_redraw __P((IPVIWIN*));
  56 static int vi_refresh __P((IPVIWIN*));
  57 static int vi_rename __P((IPVIWIN*, const char *, u_int32_t));
  58 static int vi_rewrite __P((IPVIWIN*, u_int32_t));
  59 static int vi_scrollbar __P((IPVIWIN*, u_int32_t, u_int32_t , u_int32_t ));
  60 static int vi_select __P((IPVIWIN*, const char *, u_int32_t));
  61 static int vi_split __P((IPVIWIN*));
  62 static int vi_ex_init __P((IPVIWIN*));
  63 static int vi_vi_init __P((IPVIWIN*));
  64 static int vi_fork __P((IPVIWIN*));
  65
  66 static GtkWidgetClass *parent_class = NULL;
  67 static guint vi_window_signals[LAST_SIGNAL] = { 0 };
  68
  69 GtkType
  70 gtk_vi_window_get_type (void)
  71 {
  72   static GtkType vi_window_type = 0;
  73
  74   if (!vi_window_type)
  75     {
  76       static const GtkTypeInfo vi_window_info =
  77       {
  78         "GtkViWindow",
  79         sizeof (GtkViWindow),
  80         sizeof (GtkViWindowClass),
  81         (GtkClassInitFunc) gtk_vi_window_class_init,
  82         (GtkObjectInitFunc) gtk_vi_window_init,
  83         /* reserved_1 */ NULL,
  84         /* reserved_2 */ NULL,
  85         (GtkClassInitFunc) NULL,
  86       };
  87
  88       vi_window_type = gtk_type_unique (GTK_TYPE_NOTEBOOK, &vi_window_info);
  89     }
  90
  91   return vi_window_type;
  92 }
  93
  94 static void
  95 gtk_vi_window_class_init (GtkViWindowClass *class)
  96 {
  97   GtkObjectClass *object_class;
  98
  99   object_class = (GtkObjectClass*) class;
 100   parent_class = gtk_type_class (GTK_TYPE_WIDGET);
 101
 102   vi_window_signals[RENAME] =
 103     gtk_signal_new ("rename",
 104                     GTK_RUN_FIRST,
 105                     GTK_CLASS_TYPE(object_class),
 106                     GTK_SIGNAL_OFFSET (GtkViScreenClass, rename),
 107                     gtk_marshal_VOID__STRING,
 108                     GTK_TYPE_NONE, 1, GTK_TYPE_STRING, 0);
 109
 110 #ifndef HAVE_PANGO
 111   gtk_object_class_add_signals(object_class, vi_window_signals, LAST_SIGNAL);
 112 #endif
 113
 114   object_class->destroy = gtk_vi_window_destroy;
 115 }
 116
 117 static void
 118 gtk_vi_window_init (GtkViWindow *vi)
 119 {
 120 }
 121
 122 GtkWidget *
 123 gtk_vi_window_new (GtkVi *vi)
 124 {
 125     GtkViWindow* window;
 126     GtkWidget *vi_widget;
 127     GtkWidget *vscroll;
 128     GtkWidget *table;
 129     GtkWidget *term;
 130     int        fd;
 131 #ifdef HAVE_ZVT
 132     int        pty[2];
 133 #endif
 134
 135     window = gtk_type_new(gtk_vi_window_get_type());
 136
 137     window->vi = vi;
 138     //vi->vi_window = GTK_WIDGET(window);
 139
 140     vi_widget = gtk_vi_screen_new(NULL);
 141     gtk_widget_show(GTK_WIDGET(vi_widget));
 142     /*
 143     vi->vi = vi_widget;
 144     */
 145     window->vi_screen = vi_widget;
 146
 147     vscroll = gtk_vscrollbar_new(GTK_VI_SCREEN(vi_widget)->vadj);
 148     gtk_widget_show(vscroll);
 149
 150     table = gtk_table_new(2, 2, FALSE);
 151     gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(vi_widget),
 152         0, 1, 0, 1);
 153     gtk_table_attach(GTK_TABLE(table), vscroll, 1, 2, 0, 1,
 154         (GtkAttachOptions)0, GTK_FILL, 0, 0);
 155     gtk_widget_show(table);
 156     gtk_signal_connect(GTK_OBJECT(table), "map", GTK_SIGNAL_FUNC(vi_map),
 157                         vi_widget/*->ipvi*/);
 158     window->table = table;
 159
 160
 161     gtk_notebook_set_show_tabs(GTK_NOTEBOOK(window), FALSE);
 162     gtk_notebook_set_show_border(GTK_NOTEBOOK(window), FALSE);
 163     gtk_notebook_append_page(GTK_NOTEBOOK(window), table, NULL);
 164
 165     term = 0;
 166     fd = -1;
 167
 168 #if 0
 169 #ifdef HAVE_ZVT
 170     term = zvt_term_new();
 171     zvt_term_set_blink(ZVT_TERM(term), FALSE);
 172     zvt_term_get_ptys(ZVT_TERM(term), 0, pty);
 173     fd = pty[1]; /* slave */
 174     gtk_widget_show(term);
 175     gtk_notebook_append_page(GTK_NOTEBOOK(window), term, NULL);
 176 #endif
 177 #endif
 178     window->term = term;
 179
 180     vi_init_window(window, fd);
 181
 182     gtk_signal_connect(GTK_OBJECT(vi_widget), "resized",
 183         GTK_SIGNAL_FUNC(vi_resized), window->ipviwin);
 184     gtk_signal_connect(GTK_OBJECT(vi_widget), "key_press_event",
 185         (GtkSignalFunc) vi_key_press_event, window);
 186     window->value_changed =
 187         gtk_signal_connect(GTK_OBJECT(GTK_VI_SCREEN(vi_widget)->vadj),
 188             "value_changed",
 189             (GtkSignalFunc) vi_adjustment_value_changed, window->ipviwin);
 190
 191     return GTK_WIDGET(window);
 192 }
 193
 194 static void
 195 gtk_vi_window_destroy (GtkObject *object)
 196 {
 197   GtkViWindow *vi_window;
 198
 199   g_return_if_fail (object != NULL);
 200   g_return_if_fail (GTK_IS_VI_WINDOW (object));
 201
 202   vi_window = (GtkViWindow*) object;
 203
 204   if (vi_window->table) {
 205     gtk_signal_disconnect_by_data(GTK_OBJECT(vi_window->table),
 206                                   vi_window->vi_screen);
 207     vi_window->table = 0;
 208   }
 209
 210   if (vi_window->vi_screen) {
 211     gtk_signal_disconnect_by_data(GTK_OBJECT(vi_window->vi_screen),
 212                                   vi_window->ipviwin);
 213     gtk_signal_disconnect(GTK_OBJECT(GTK_VI_SCREEN(vi_window->vi_screen)->vadj),
 214         vi_window->value_changed);
 215     gtk_widget_destroy(vi_window->vi_screen);
 216     vi_window->vi_screen = 0;
 217   }
 218
 219   GTK_OBJECT_CLASS(parent_class)->destroy (object);
 220 }
 221
 222 void
 223 gtk_vi_window_scrollbar(GtkViWindow *vi, guint top, guint size, guint max)
 224 {
 225     GtkViScreen *vi_screen;
 226     /* work around gcc bug */
 227     volatile guint mymax = max;
 228     volatile guint mysize = size;
 229
 230     vi_screen = GTK_VI_SCREEN(vi->vi_screen);
 231     vi_screen->vadj->value = top;
 232     vi_screen->vadj->upper = mymax;
 233     vi_screen->vadj->page_size =
 234         vi_screen->vadj->page_increment = mysize;
 235     gtk_signal_handler_block(GTK_OBJECT(vi_screen->vadj), vi->value_changed);
 236     gtk_adjustment_changed(vi_screen->vadj);
 237     /*
 238     gtk_adjustment_value_changed(vi_screen->vadj);
 239     */
 240     gtk_signal_handler_unblock(GTK_OBJECT(vi_screen->vadj), vi->value_changed);
 241 }
 242
 243 /*
 244  * PUBLIC: void gtk_vi_quit __P((GtkViWindow*, gint));
 245  */
 246 void
 247 gtk_vi_quit(vi, write)
 248     GtkViWindow *vi;
 249     gint write;
 250 {
 251     if (write)
 252         vi->ipviwin->wq(vi->ipviwin);
 253     else
 254         vi->ipviwin->quit(vi->ipviwin);
 255 }
 256
 257 /*
 258  * PUBLIC: void gtk_vi_show_term __P((GtkViWindow*, gint));
 259  */
 260 void
 261 gtk_vi_show_term(window, show)
 262     GtkViWindow *window;
 263     gint show;
 264 {
 265     gtk_notebook_set_page(GTK_NOTEBOOK(window), show ? 1 : 0);
 266 }
 267
 268 /*
 269  * PUBLIC: void gtk_vi_key_press_event __P((GtkViWindow*, GdkEventKey*));
 270  */
 271 void
 272 gtk_vi_key_press_event(window, event)
 273     GtkViWindow *window;
 274     GdkEventKey *event;
 275 {
 276 #if 0
 277     static struct {
 278         guint key;
 279         gint offset;
 280     } table[] = {
 281         {GDK_Home,      GTK_STRUCT_OFFSET(IPVI, c_bol)      },
 282         //{VI_C_BOTTOM, GTK_STRUCT_OFFSET(IPVI, c_bottom)   },
 283         {GDK_End,       GTK_STRUCT_OFFSET(IPVI, c_eol)      },
 284         {GDK_Insert,    GTK_STRUCT_OFFSET(IPVI, c_insert)   },
 285         {GDK_Left,      GTK_STRUCT_OFFSET(IPVI, c_left)     },
 286         {GDK_Right,     GTK_STRUCT_OFFSET(IPVI, c_right)    },
 287         //{VI_C_TOP,    GTK_STRUCT_OFFSET(IPVI, c_top)      },
 288     };
 289 #endif
 290     static struct {
 291         guint   keyval;
 292         char    key;
 293     } table[] = {
 294         { GDK_Left,         'h' },
 295         { GDK_Right,        'l' },
 296         { GDK_Up,           'k' },
 297         { GDK_Down,         'j' },
 298         { GDK_Page_Up,      'B' - '@' },
 299         { GDK_Page_Down,    'F' - '@' },
 300     };
 301     char key = event->keyval;
 302     int i;
 303
 304 #if 0
 305     for (i = 0; i < sizeof(table)/sizeof(*table); ++i)
 306         if (table[i].key == event->keyval) {
 307             int (*fun) __P((IPVI*)) =
 308                 *(int (**) __P((IPVI*)) )(((char *)vi->ipvi)+table[i].offset);
 309             fun(vi->ipvi);
 310             return;
 311         }
 312 #endif
 313     for (i = 0; i < sizeof(table)/sizeof(*table); ++i)
 314         if (table[i].keyval == event->keyval) {
 315             window->ipviwin->string(window->ipviwin, &table[i].key, 1);
 316             return;
 317         }
 318
 319     if (event->state & GDK_CONTROL_MASK) {
 320         if ((key >= 'a') && (key <= 'z'))
 321             key -= 'a' - 'A';
 322         key -= '@';
 323     }
 324     /*
 325     fprintf(stderr, "key_press %d %d %d %c %p\n",
 326         event->length, event->keyval, event->keyval, key, ipvi);
 327     */
 328     if (event->length > 0)
 329         window->ipviwin->string(window->ipviwin, &key, 1);
 330 }
 331
 332
 333
 334 static int
 335 vi_key_press_event(vi_screen, event, vi)
 336     GtkViWindow *vi;
 337     GtkWidget *vi_screen;
 338     GdkEventKey *event;
 339 {
 340     gint handled;
 341
 342     handled = gtk_accel_groups_activate (GTK_OBJECT (vi),
 343                     event->keyval, (GdkModifierType) event->state);
 344     if (handled)
 345         return 1;
 346
 347     gtk_vi_key_press_event(vi, event);
 348     gtk_signal_emit_stop_by_name(GTK_OBJECT(vi_screen), "key_press_event");
 349     /* handled */
 350     return 1;
 351 }
 352
 353 static void
 354 vi_map(table, vi_screen)
 355         GtkWidget *vi_screen;
 356         GtkWidget *table;
 357 {
 358         gtk_widget_grab_focus(vi_screen);
 359 }
 360
 361 static void
 362 vi_resized(vi_screen, rows, cols, ipviwin)
 363     int rows,cols;
 364     IPVIWIN *ipviwin;
 365     GtkWidget *vi_screen;
 366 {
 367         GtkViWindow *vi_window = GTK_VI_WINDOW((GtkVi*)(ipviwin->private_data));
 368
 369         ipviwin->resize(ipviwin, rows, cols);
 370         vi_window->resized = 1;
 371 }
 372
 373 static void
 374 vi_adjustment_value_changed (adjustment, ipviwin)
 375     GtkAdjustment *adjustment;
 376     IPVIWIN *ipviwin;
 377 {
 378         GtkViWindow *vi_window = GTK_VI_WINDOW((GtkVi*)(ipviwin->private_data));
 379
 380         if (vi_window->resized)
 381                 ipviwin->c_settop(ipviwin, adjustment->value);
 382 }
 383
 384
 385 static void
 386 vi_input_func (gpointer data, gint source, GdkInputCondition condition)
 387 {
 388     IPVIWIN *ipviwin = (IPVIWIN *) data;
 389
 390     (void)ipviwin->input(ipviwin, source);
 391 }
 392
 393 static void
 394 vi_init_window (GtkViWindow *window, int fd)
 395 {
 396     static struct ip_si_operations ipsi_ops_gtk = {
 397         vi_addstr,
 398         vi_attribute,
 399         vi_bell,
 400         vi_busyoff,
 401         vi_busyon,
 402         vi_clrtoeol,
 403         vi_deleteln,
 404         vi_discard,
 405         vi_editopt,
 406         vi_insertln,
 407         vi_move,
 408         vi_quit,
 409         vi_redraw,
 410         vi_refresh,
 411         vi_rename,
 412         vi_rewrite,
 413         vi_scrollbar,
 414         vi_select,
 415         vi_split,
 416         (IPFunc_a)vi_waddstr,
 417     };
 418     GtkVi *vi = window->vi;
 419
 420     vi->ipvi->new_window(vi->ipvi, &window->ipviwin, fd);
 421
 422     window->ipviwin->private_data = window;
 423     window->ipviwin->set_ops(window->ipviwin, &ipsi_ops_gtk);
 424     window->input_func = gtk_input_add_full(window->ipviwin->ifd,
 425                             GDK_INPUT_READ,
 426                             vi_input_func, 0, (gpointer)window->ipviwin, 0);
 427 }
 428
 429 static int
 430 vi_addstr(ipviwin, str, len)
 431         IPVIWIN *ipviwin;
 432         const char *str;
 433         u_int32_t len;
 434 {
 435         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 436
 437         gtk_vi_screen_addstr(GTK_VI_SCREEN(vi->vi_screen), str, len);
 438         return (0);
 439 }
 440
 441 static int
 442 vi_waddstr(ipviwin, str, len)
 443         IPVIWIN *ipviwin;
 444         const CHAR_T *str;
 445         u_int32_t len;
 446 {
 447         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 448
 449         gtk_vi_screen_waddstr(GTK_VI_SCREEN(vi->vi_screen), str, len/sizeof(CHAR_T));
 450         return (0);
 451 }
 452
 453 static int
 454 vi_attribute(ipviwin,attribute,on)
 455         IPVIWIN *ipviwin;
 456         u_int32_t   attribute, on;
 457 {
 458         GtkViWindow* window = (GtkViWindow*)(ipviwin->private_data);
 459
 460         if (attribute == SA_ALTERNATE) {
 461                 gtk_vi_show_term(window, !on);
 462         }
 463         else
 464                 gtk_vi_screen_attribute(GTK_VI_SCREEN(window->vi_screen), attribute, on);
 465         return (0);
 466 }
 467
 468 static int
 469 vi_bell(ipbp)
 470         IPVIWIN *ipbp;
 471 {
 472     /*
 473     fprintf(stderr, "vi_bell\n");
 474     */
 475 #if 0
 476         /*
 477          * XXX
 478          * Future... implement visible bell.
 479          */
 480         XBell(XtDisplay(__vi_screen->area), 0);
 481 #endif
 482         return (0);
 483 }
 484
 485 static int
 486 vi_busyon (IPVIWIN* ipviwin, const char *a, u_int32_t s)
 487 {
 488     /*
 489     fprintf(stderr, "vi_busyon\n");
 490     */
 491 #if 0
 492         __vi_set_cursor(__vi_screen, 1);
 493 #endif
 494         return (0);
 495 }
 496
 497 static int
 498 vi_busyoff(ipbp)
 499         IPVIWIN *ipbp;
 500 {
 501     /*
 502     fprintf(stderr, "vi_busyoff\n");
 503     */
 504 #if 0
 505         __vi_set_cursor(__vi_screen, 0);
 506 #endif
 507         return (0);
 508 }
 509
 510 static int
 511 vi_clrtoeol(ipviwin)
 512         IPVIWIN *ipviwin;
 513 {
 514         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 515
 516         gtk_vi_screen_clrtoel(GTK_VI_SCREEN(vi->vi_screen));
 517         return 0;
 518 }
 519
 520 static int
 521 vi_deleteln(ipviwin)
 522         IPVIWIN *ipviwin;
 523 {
 524         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 525
 526         gtk_vi_screen_deleteln(GTK_VI_SCREEN(vi->vi_screen));
 527         return (0);
 528 }
 529
 530 static int
 531 vi_editopt (IPVIWIN* a, const char *b, u_int32_t c,
 532                             const char *d, u_int32_t e, u_int32_t f)
 533 {
 534     /*
 535     fprintf(stderr, "%p %p vi_editopt\n", a, a->private_data);
 536     */
 537 #if 0
 538         /* XXX: Nothing. */
 539 #endif
 540         return (0);
 541 }
 542
 543
 544 static int
 545 vi_discard(ipbp)
 546         IPVIWIN *ipbp;
 547 {
 548     /*
 549     fprintf(stderr, "vi_discard\n");
 550     */
 551 #if 0
 552         /* XXX: Nothing. */
 553 #endif
 554         return (0);
 555 }
 556
 557 static int
 558 vi_insertln(ipviwin)
 559         IPVIWIN *ipviwin;
 560 {
 561         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 562
 563     gtk_vi_screen_insertln(GTK_VI_SCREEN(vi->vi_screen));
 564     return (0);
 565 }
 566
 567 static int
 568 vi_move(ipviwin, row, col)
 569         IPVIWIN *ipviwin;
 570         u_int32_t row;
 571         u_int32_t col;
 572 {
 573         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 574
 575         gtk_vi_screen_move(GTK_VI_SCREEN(vi->vi_screen), row, col);
 576         return (0);
 577 }
 578
 579 static int
 580 vi_redraw(ipviwin)
 581         IPVIWIN *ipviwin;
 582 {
 583         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 584
 585         gtk_widget_draw(GTK_WIDGET(vi->vi_screen), NULL);
 586         return (0);
 587 }
 588
 589 static int
 590 vi_refresh(ipviwin)
 591         IPVIWIN *ipviwin;
 592 {
 593         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 594
 595         gtk_vi_screen_refresh(GTK_VI_SCREEN(vi->vi_screen));
 596         return (0);
 597 }
 598
 599 static int
 600 vi_quit(ipviwin)
 601         IPVIWIN *ipviwin;
 602 {
 603         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 604
 605         gtk_input_remove(vi->input_func);
 606         gtk_widget_destroy(GTK_WIDGET(vi));
 607         return (0);
 608 }
 609
 610 static int
 611 vi_rename(ipviwin, str, len)
 612         IPVIWIN *ipviwin;
 613         const char *str;
 614         u_int32_t len;
 615 {
 616         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 617
 618         gchar* name = g_strndup(str, len);
 619         gtk_signal_emit_by_name(GTK_OBJECT(vi), "rename", name);
 620         g_free(name);
 621         return (0);
 622 }
 623
 624 static int
 625 vi_rewrite(ipviwin, row)
 626         IPVIWIN *ipviwin;
 627         u_int32_t row;
 628 {
 629         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 630
 631         gtk_vi_screen_rewrite(GTK_VI_SCREEN(vi->vi_screen), row);
 632         return (0);
 633 }
 634
 635
 636 static int
 637 vi_scrollbar(ipviwin, top, size, max)
 638         IPVIWIN *ipviwin;
 639         u_int32_t top, size, max;
 640 {
 641         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 642
 643         gtk_vi_window_scrollbar(vi, top, size, max);
 644
 645         return (0);
 646 }
 647
 648 static int vi_select (IPVIWIN* a, const char * b, u_int32_t c)
 649 {
 650     /*
 651     fprintf(stderr, "vi_select\n");
 652     */
 653 #if 0
 654         /* XXX: Nothing. */
 655 #endif
 656         return (0);
 657 }
 658
 659 static int
 660 vi_split(ipbp)
 661         IPVIWIN *ipbp;
 662 {
 663     fprintf(stderr, "vi_split\n");
 664 #if 0
 665         /* XXX: Nothing. */
 666 #endif
 667         return (0);
 668 }
 669
 670 static int
 671 vi_ex_init(ipviwin)
 672         IPVIWIN *ipviwin;
 673 {
 674         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 675
 676 /*
 677         gtk_vi_show_term(vi, 1);
 678 */
 679         return 0;
 680 }
 681
 682 static int
 683 vi_vi_init(ipviwin)
 684         IPVIWIN *ipviwin;
 685 {
 686         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 687
 688 /*
 689         gtk_vi_show_term(vi, 0);
 690 */
 691         return 0;
 692 }