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