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