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