gtk/gtkviwindow.c

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