gtk/gtkviwindow.c

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