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_screen), 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     /* work around gcc bug */
 186     volatile guint mymax = max;
 187     volatile guint mysize = size;
 188
 189     vi_screen = GTK_VI_SCREEN(vi->vi_screen);
 190     vi_screen->vadj->value = top;
 191     vi_screen->vadj->upper = mymax;
 192     vi_screen->vadj->page_size =
 193         vi_screen->vadj->page_increment = mysize;
 194     gtk_signal_handler_block(GTK_OBJECT(vi_screen->vadj), vi->value_changed);
 195     gtk_adjustment_changed(vi_screen->vadj);
 196     /*
 197     gtk_adjustment_value_changed(vi_screen->vadj);
 198     */
 199     gtk_signal_handler_unblock(GTK_OBJECT(vi_screen->vadj), vi->value_changed);
 200 }
 201
 202 /*
 203  * PUBLIC: void gtk_vi_quit __P((GtkViWindow*, gint));
 204  */
 205 void
 206 gtk_vi_quit(vi, write)
 207     GtkViWindow *vi;
 208     gint write;
 209 {
 210     if (write)
 211         vi->ipviwin->wq(vi->ipviwin);
 212     else
 213         vi->ipviwin->quit(vi->ipviwin);
 214 }
 215
 216 /*
 217  * PUBLIC: void gtk_vi_key_press_event __P((GtkViWindow*, GdkEventKey*));
 218  */
 219 void
 220 gtk_vi_key_press_event(window, event)
 221     GtkViWindow *window;
 222     GdkEventKey *event;
 223 {
 224 #if 0
 225     static struct {
 226         guint key;
 227         gint offset;
 228     } table[] = {
 229         {GDK_Home,      GTK_STRUCT_OFFSET(IPVI, c_bol)      },
 230         //{VI_C_BOTTOM, GTK_STRUCT_OFFSET(IPVI, c_bottom)   },
 231         {GDK_End,       GTK_STRUCT_OFFSET(IPVI, c_eol)      },
 232         {GDK_Insert,    GTK_STRUCT_OFFSET(IPVI, c_insert)   },
 233         {GDK_Left,      GTK_STRUCT_OFFSET(IPVI, c_left)     },
 234         {GDK_Right,     GTK_STRUCT_OFFSET(IPVI, c_right)    },
 235         //{VI_C_TOP,    GTK_STRUCT_OFFSET(IPVI, c_top)      },
 236     };
 237 #endif
 238     static struct {
 239         guint   keyval;
 240         char    key;
 241     } table[] = {
 242         { GDK_Left,         'h' },
 243         { GDK_Right,        'l' },
 244         { GDK_Up,           'k' },
 245         { GDK_Down,         'j' },
 246         { GDK_Page_Up,      'B' - '@' },
 247         { GDK_Page_Down,    'F' - '@' },
 248     };
 249     char key = event->keyval;
 250     int i;
 251
 252 #if 0
 253     for (i = 0; i < sizeof(table)/sizeof(*table); ++i)
 254         if (table[i].key == event->keyval) {
 255             int (*fun) __P((IPVI*)) =
 256                 *(int (**) __P((IPVI*)) )(((char *)vi->ipvi)+table[i].offset);
 257             fun(vi->ipvi);
 258             return;
 259         }
 260 #endif
 261     for (i = 0; i < sizeof(table)/sizeof(*table); ++i)
 262         if (table[i].keyval == event->keyval) {
 263             window->ipviwin->string(window->ipviwin, &table[i].key, 1);
 264             return;
 265         }
 266
 267     if (event->state & GDK_CONTROL_MASK) {
 268         if ((key >= 'a') && (key <= 'z'))
 269             key -= 'a' - 'A';
 270         key -= '@';
 271     }
 272     /*
 273     fprintf(stderr, "key_press %d %d %d %c %p\n",
 274         event->length, event->keyval, event->keyval, key, ipvi);
 275     */
 276     if (event->length > 0)
 277         window->ipviwin->string(window->ipviwin, &key, 1);
 278 }
 279
 280
 281
 282 static int
 283 vi_key_press_event(vi_screen, event, vi)
 284     GtkViWindow *vi;
 285     GtkWidget *vi_screen;
 286     GdkEventKey *event;
 287 {
 288     gint handled;
 289
 290     handled = gtk_accel_groups_activate (GTK_OBJECT (vi),
 291                     event->keyval, (GdkModifierType) event->state);
 292     if (handled)
 293         return 1;
 294
 295     gtk_vi_key_press_event(vi, event);
 296     gtk_signal_emit_stop_by_name(GTK_OBJECT(vi_screen), "key_press_event");
 297     /* handled */
 298     return 1;
 299 }
 300
 301 static void
 302 vi_map(table, vi_screen)
 303         GtkWidget *vi_screen;
 304         GtkWidget *table;
 305 {
 306         gtk_widget_grab_focus(vi_screen);
 307 }
 308
 309 static void
 310 vi_resized(vi_screen, rows, cols, ipviwin)
 311     int rows,cols;
 312     IPVIWIN *ipviwin;
 313     GtkWidget *vi_screen;
 314 {
 315         GtkViWindow *vi_window = GTK_VI_WINDOW((GtkVi*)(ipviwin->private_data));
 316
 317         ipviwin->resize(ipviwin, rows, cols);
 318         vi_window->resized = 1;
 319 }
 320
 321 static void
 322 vi_adjustment_value_changed (adjustment, ipviwin)
 323     GtkAdjustment *adjustment;
 324     IPVIWIN *ipviwin;
 325 {
 326         GtkViWindow *vi_window = GTK_VI_WINDOW((GtkVi*)(ipviwin->private_data));
 327
 328         if (vi_window->resized)
 329                 ipviwin->c_settop(ipviwin, adjustment->value);
 330 }
 331
 332
 333 static void
 334 vi_input_func (gpointer data, gint source, GdkInputCondition condition)
 335 {
 336     IPVIWIN *ipviwin = (IPVIWIN *) data;
 337
 338     (void)ipviwin->input(ipviwin, source);
 339 }
 340
 341 static void
 342 vi_init_window (GtkViWindow *window)
 343 {
 344     static struct ip_si_operations ipsi_ops_gtk = {
 345         vi_addstr,
 346         vi_attribute,
 347         vi_bell,
 348         vi_busyoff,
 349         vi_busyon,
 350         vi_clrtoeol,
 351         vi_deleteln,
 352         vi_discard,
 353         vi_editopt,
 354         vi_insertln,
 355         vi_move,
 356         vi_quit,
 357         vi_redraw,
 358         vi_refresh,
 359         vi_rename,
 360         vi_rewrite,
 361         vi_scrollbar,
 362         vi_select,
 363         vi_split,
 364         vi_ex_init,
 365         vi_vi_init,
 366 /*
 367         vi_fork,
 368 */
 369     };
 370     GtkVi *vi = window->vi;
 371
 372     vi->ipvi->new_window(vi->ipvi, &window->ipviwin);
 373
 374     window->ipviwin->private_data = window;
 375     window->ipviwin->set_ops(window->ipviwin, &ipsi_ops_gtk);
 376     window->input_func = gtk_input_add_full(window->ipviwin->ifd,
 377                             GDK_INPUT_READ,
 378                             vi_input_func, 0, (gpointer)window->ipviwin, 0);
 379 }
 380
 381 static int
 382 vi_addstr(ipviwin, str, len)
 383         IPVIWIN *ipviwin;
 384         const char *str;
 385         u_int32_t len;
 386 {
 387         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 388
 389         gtk_vi_screen_addstr(GTK_VI_SCREEN(vi->vi_screen), str, len);
 390         return (0);
 391 }
 392
 393 static int
 394 vi_attribute(ipviwin,attribute,on)
 395         IPVIWIN *ipviwin;
 396         u_int32_t   attribute, on;
 397 {
 398         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 399
 400         gtk_vi_screen_attribute(GTK_VI_SCREEN(vi->vi_screen), attribute, on);
 401         return (0);
 402 }
 403
 404 static int
 405 vi_bell(ipbp)
 406         IPVIWIN *ipbp;
 407 {
 408     /*
 409     fprintf(stderr, "vi_bell\n");
 410     */
 411 #if 0
 412         /*
 413          * XXX
 414          * Future... implement visible bell.
 415          */
 416         XBell(XtDisplay(__vi_screen->area), 0);
 417 #endif
 418         return (0);
 419 }
 420
 421 static int
 422 vi_busyon (IPVIWIN* ipviwin, const char *a, u_int32_t s)
 423 {
 424     /*
 425     fprintf(stderr, "vi_busyon\n");
 426     */
 427 #if 0
 428         __vi_set_cursor(__vi_screen, 1);
 429 #endif
 430         return (0);
 431 }
 432
 433 static int
 434 vi_busyoff(ipbp)
 435         IPVIWIN *ipbp;
 436 {
 437     /*
 438     fprintf(stderr, "vi_busyoff\n");
 439     */
 440 #if 0
 441         __vi_set_cursor(__vi_screen, 0);
 442 #endif
 443         return (0);
 444 }
 445
 446 static int
 447 vi_clrtoeol(ipviwin)
 448         IPVIWIN *ipviwin;
 449 {
 450         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 451
 452         gtk_vi_screen_clrtoel(GTK_VI_SCREEN(vi->vi_screen));
 453         return 0;
 454 }
 455
 456 static int
 457 vi_deleteln(ipviwin)
 458         IPVIWIN *ipviwin;
 459 {
 460         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 461
 462         gtk_vi_screen_deleteln(GTK_VI_SCREEN(vi->vi_screen));
 463         return (0);
 464 }
 465
 466 static int
 467 vi_editopt (IPVIWIN* a, const char *b, u_int32_t c,
 468                             const char *d, u_int32_t e, u_int32_t f)
 469 {
 470     /*
 471     fprintf(stderr, "%p %p vi_editopt\n", a, a->private_data);
 472     */
 473 #if 0
 474         /* XXX: Nothing. */
 475 #endif
 476         return (0);
 477 }
 478
 479
 480 static int
 481 vi_discard(ipbp)
 482         IPVIWIN *ipbp;
 483 {
 484     /*
 485     fprintf(stderr, "vi_discard\n");
 486     */
 487 #if 0
 488         /* XXX: Nothing. */
 489 #endif
 490         return (0);
 491 }
 492
 493 static int
 494 vi_insertln(ipviwin)
 495         IPVIWIN *ipviwin;
 496 {
 497         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 498
 499     gtk_vi_screen_insertln(GTK_VI_SCREEN(vi->vi_screen));
 500     return (0);
 501 }
 502
 503 static int
 504 vi_move(ipviwin, row, col)
 505         IPVIWIN *ipviwin;
 506         u_int32_t row;
 507         u_int32_t col;
 508 {
 509         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 510
 511         gtk_vi_screen_move(GTK_VI_SCREEN(vi->vi_screen), row, col);
 512         return (0);
 513 }
 514
 515 static int
 516 vi_redraw(ipviwin)
 517         IPVIWIN *ipviwin;
 518 {
 519         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 520
 521         gtk_widget_draw(GTK_WIDGET(vi->vi_screen), NULL);
 522         return (0);
 523 }
 524
 525 static int
 526 vi_refresh(ipviwin)
 527         IPVIWIN *ipviwin;
 528 {
 529         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 530
 531         gtk_vi_screen_refresh(GTK_VI_SCREEN(vi->vi_screen));
 532         return (0);
 533 }
 534
 535 static int
 536 vi_quit(ipviwin)
 537         IPVIWIN *ipviwin;
 538 {
 539         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 540
 541         gtk_input_remove(vi->input_func);
 542         gtk_widget_destroy(GTK_WIDGET(vi));
 543         return (0);
 544 }
 545
 546 static int
 547 vi_rename(ipviwin, str, len)
 548         IPVIWIN *ipviwin;
 549         const char *str;
 550         u_int32_t len;
 551 {
 552         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 553
 554         gchar* name = g_strndup(str, len);
 555         gtk_signal_emit_by_name(GTK_OBJECT(vi), "rename", name);
 556         g_free(name);
 557         return (0);
 558 }
 559
 560 static int
 561 vi_rewrite(ipviwin, row)
 562         IPVIWIN *ipviwin;
 563         u_int32_t row;
 564 {
 565         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 566
 567         gtk_vi_screen_rewrite(GTK_VI_SCREEN(vi->vi_screen), row);
 568         return (0);
 569 }
 570
 571
 572 static int
 573 vi_scrollbar(ipviwin, top, size, max)
 574         IPVIWIN *ipviwin;
 575         u_int32_t top, size, max;
 576 {
 577         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 578
 579         gtk_vi_window_scrollbar(vi, top, size, max);
 580
 581         return (0);
 582 }
 583
 584 static int vi_select (IPVIWIN* a, const char * b, u_int32_t c)
 585 {
 586     /*
 587     fprintf(stderr, "vi_select\n");
 588     */
 589 #if 0
 590         /* XXX: Nothing. */
 591 #endif
 592         return (0);
 593 }
 594
 595 static int
 596 vi_split(ipbp)
 597         IPVIWIN *ipbp;
 598 {
 599     fprintf(stderr, "vi_split\n");
 600 #if 0
 601         /* XXX: Nothing. */
 602 #endif
 603         return (0);
 604 }
 605
 606 static int
 607 vi_ex_init(ipviwin)
 608         IPVIWIN *ipviwin;
 609 {
 610         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 611
 612 /*
 613         gtk_vi_show_term(vi, 1);
 614 */
 615         return 0;
 616 }
 617
 618 static int
 619 vi_vi_init(ipviwin)
 620         IPVIWIN *ipviwin;
 621 {
 622         GtkViWindow* vi = (GtkViWindow*)(ipviwin->private_data);
 623
 624 /*
 625         gtk_vi_show_term(vi, 0);
 626 */
 627         return 0;
 628 }