plugins/gvim/gtkvim.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27
  28 #include "gtkvim.h"
  29 #include <gdk/gdkx.h>
  30 #include <stdarg.h>
  31 #include <stdlib.h>
  32
  33
  34 /* Local data */
  35 static GtkWidgetClass *parent_class = NULL;
  36
  37 /* Args */
  38 enum {
  39     ARG_0,
  40     ARG_SERVER_NAME,
  41 };
  42
  43 /* Forward declararations */
  44 static void gtk_vim_class_init      (GtkVimClass  *class);
  45 static void gtk_vim_init            (GtkVim       *vim);
  46 static void gtk_vim_set_arg         (GtkObject    *object,
  47                                      GtkArg       *arg,
  48                                      guint         arg_id);
  49 static void gtk_vim_get_arg         (GtkObject    *object,
  50                                      GtkArg       *arg,
  51                                      guint         arg_id);
  52 static void gtk_vim_realize         (GtkWidget    *widget);
  53 static void gtk_vim_unrealize       (GtkWidget    *widget);
  54 static gint gtk_vim_delete_event    (GtkWidget    *widget,
  55                                      GdkEventAny  *event);
  56
  57
  58 GtkType
  59 gtk_vim_get_type (void)
  60 {
  61     static GtkType vim_type = 0;
  62
  63     if (!vim_type)
  64         {
  65             static const GtkTypeInfo vim_info =
  66             {
  67                 "GtkVim",
  68                 sizeof (GtkVim),
  69                 sizeof (GtkVimClass),
  70                 (GtkClassInitFunc) gtk_vim_class_init,
  71                 (GtkObjectInitFunc) gtk_vim_init,
  72                 /* reserved_1 */ NULL,
  73                 /* reserved_2 */ NULL,
  74                 (GtkClassInitFunc) NULL,
  75             };
  76
  77             vim_type = gtk_type_unique (GTK_TYPE_SOCKET, &vim_info);
  78         }
  79
  80     return vim_type;
  81 }
  82
  83
  84 static void
  85 gtk_vim_class_init (GtkVimClass *class)
  86 {
  87     GtkObjectClass *object_class;
  88     GtkWidgetClass *widget_class;
  89
  90     object_class = GTK_OBJECT_CLASS (class);
  91     widget_class = GTK_WIDGET_CLASS (class);
  92     parent_class = gtk_type_class (GTK_TYPE_SOCKET);
  93
  94     gtk_object_add_arg_type ("GtkVim::server_name", GTK_TYPE_STRING, GTK_ARG_READABLE, ARG_SERVER_NAME);
  95
  96     object_class->set_arg      = gtk_vim_set_arg;
  97     object_class->get_arg      = gtk_vim_get_arg;
  98     widget_class->delete_event = gtk_vim_delete_event;
  99     widget_class->realize      = gtk_vim_realize;
 100     widget_class->unrealize    = gtk_vim_unrealize;
 101 }
 102
 103 static void
 104 plug_added (GtkWidget *widget,
 105             void *data)
 106 {
 107     gtk_widget_show (widget);
 108 }
 109
 110 static gboolean
 111 plug_removed (GtkWidget *widget,
 112               void *data)
 113 {
 114     gtk_widget_hide (widget);
 115     return TRUE;
 116 }
 117
 118 static void
 119 gtk_vim_init (GtkVim *vim)
 120 {
 121     vim->server_name = NULL;
 122     vim->init_cols   = 0;
 123     vim->init_rows   = 0;
 124     vim->init_files  = g_strdup ("");
 125
 126     g_signal_connect (GTK_WIDGET (vim), "plug_added", G_CALLBACK (plug_added), NULL);
 127     g_signal_connect (GTK_WIDGET (vim), "plug_removed", G_CALLBACK (plug_removed), NULL);
 128 }
 129
 130 /*
 131  * Args. are initial character cols/rows size of widget, plus NULL terminated
 132  * list of filenames to edit and/or gvim arguments.
 133  * You may of course give everything in one string with space separators.
 134  * But you still need the NULL.
 135  */
 136 GtkWidget*
 137 gtk_vim_new (gint   init_cols,
 138              gint   init_rows,
 139              const gchar *filename,
 140              ...)
 141 {
 142     GtkVim *vim;
 143
 144     vim = gtk_type_new (gtk_vim_get_type ());
 145
 146     if (init_cols <= 0  &&  init_rows <= 0)
 147     {
 148         vim->init_cols = vim->init_rows = 0;
 149     }
 150     else
 151     {
 152         vim->init_cols   = (init_cols <= 0  ?  80  :  init_cols);
 153         vim->init_rows   = (init_rows <= 0  ?  24  :  init_rows);
 154     }
 155
 156     if (filename)
 157     {
 158         va_list args;
 159         gchar  *arg, *tmp;
 160
 161         va_start( args, filename );
 162
 163         vim->init_files = g_strdup(filename);
 164         for (arg = (gchar *)va_arg( args, gchar * );  arg; )
 165         {
 166             tmp = vim->init_files;
 167             vim->init_files = g_strconcat( tmp, " ", arg, NULL );
 168             g_free( tmp );
 169         }
 170
 171         va_end(args);
 172     }
 173     else
 174     {
 175         vim->init_files = g_strdup("");
 176     }
 177
 178     return GTK_WIDGET (vim);
 179 }
 180
 181
 182 static void
 183 gtk_vim_set_arg (GtkObject    *object,
 184                  GtkArg       *arg,
 185                  guint         arg_id)
 186 {
 187     GtkVim *vim;
 188
 189     vim = GTK_VIM (object);
 190
 191     switch (arg_id)
 192     {
 193         default:
 194             break;
 195     }
 196 }
 197
 198 static void
 199 gtk_vim_get_arg (GtkObject    *object,
 200                  GtkArg       *arg,
 201                  guint         arg_id)
 202 {
 203     GtkVim *vim;
 204
 205     vim = GTK_VIM (object);
 206
 207     switch (arg_id)
 208     {
 209         case ARG_SERVER_NAME:
 210             GTK_VALUE_STRING (*arg) = g_strdup (vim->server_name);
 211             break;
 212         default:
 213             arg->type = GTK_TYPE_INVALID;
 214             break;
 215     }
 216 }
 217
 218 static gint
 219 gtk_vim_delete_event (GtkWidget    *widget,
 220                       GdkEventAny  *event)
 221 {
 222     GtkVim *vim;
 223
 224     vim = GTK_VIM (widget);
 225
 226     if (!vim->server_name)  return TRUE;
 227
 228     if (vim->socket.plug_window)
 229     {
 230         gchar *cmd;
 231         cmd = g_strdup_printf(
 232             "gvim --servername %s --remote-send '<C-\\><C-N>:qa<CR>'",
 233             vim->server_name );
 234         system(cmd);
 235         g_free(cmd);
 236     }
 237
 238     /*
 239      * Eventually, I think this ought to ask vim to quit, and wait for it's
 240      * 'save changes' dialogue to return ok/no, and then return here
 241      * accordingly.
 242      * But we don't have that I/F yet, so just return TRUE ("OK to delete").
 243      * So for now, don't select 'Cancel' from a vim 'save changes' prompt!
 244      */
 245     return TRUE;
 246 }
 247
 248 static void
 249 gtk_vim_realize (GtkWidget *widget)
 250 {
 251     GtkVim    *vim;
 252     gchar     *cmd, *xid_str;
 253
 254     /* Do socket realize */
 255     parent_class->realize(widget);
 256
 257     vim = GTK_VIM (widget);
 258
 259     if (!widget->parent)
 260     {
 261         g_error( "gtk_vim_realize(): no parent" );
 262         return;
 263     }
 264     else if (!widget->parent->window)
 265     {
 266         g_error( "gtk_vim_realize(): no parent window" );
 267         return;
 268     }
 269
 270     /* Ensure GDK has created our window so we know it's ID */
 271     gdk_flush();
 272     if (!widget->window)
 273     {
 274         g_error( "gtk_vim_realize(): no window" );
 275         return;
 276     }
 277
 278     /* Now find XID of sub-window we're to use */
 279     xid_str = g_strdup_printf( "0x%X",
 280 #ifdef GTK1
 281         GDK_WINDOW_XWINDOW(widget->window)
 282 #else
 283         gtk_socket_get_id(&(vim->socket))
 284 #endif
 285     );
 286     vim->server_name = g_strdup_printf( "GtkVim-%s", xid_str );
 287
 288     /* Fork off a gvim (it forks itself) */
 289     if (vim->init_cols == 0  ||  vim->init_rows == 0)
 290     {
 291         cmd = g_strdup_printf(
 292             "gvim --servername %s --socketid %s %s",
 293             vim->server_name, xid_str,
 294             vim->init_files );
 295     }
 296     else
 297     {
 298         cmd = g_strdup_printf(
 299             "gvim -geom %dx%d --servername %s --socketid %s %s",
 300             vim->init_cols, vim->init_rows,
 301             vim->server_name, xid_str,
 302             vim->init_files );
 303     }
 304     system(cmd);
 305
 306     g_free( xid_str );
 307     g_free( cmd );
 308 }
 309
 310
 311 static void
 312 gtk_vim_unrealize (GtkWidget *widget)
 313 {
 314     GtkVim *vim;
 315
 316     vim = GTK_VIM (widget);
 317
 318     if (vim->server_name)
 319     {
 320         g_free (vim->server_name);
 321         vim->server_name = NULL;
 322     }
 323     if (vim->init_files)
 324     {
 325         g_free (vim->init_files);
 326         vim->init_files = NULL;
 327     }
 328
 329     /* Do socket unrealize */
 330     parent_class->unrealize(widget);
 331 }
 332
 333
 334 gchar*
 335 gtk_vim_get_server_name (GtkVim *widget)
 336 {
 337     GtkVim *vim;
 338
 339     g_return_val_if_fail (widget != NULL,  NULL);
 340     g_return_val_if_fail (GTK_IS_VIM (widget),  NULL);
 341
 342     vim = GTK_VIM (widget);
 343
 344     return g_strdup (vim->server_name);
 345 }
 346
 347
 348 void
 349 gtk_vim_edit (GtkVim *widget,
 350               const gchar     *filename,
 351               ...)
 352 {
 353     GtkVim *vim;
 354     va_list args;
 355     gchar *files = NULL;
 356         gchar *arg, *tmp, *cmd;
 357
 358     g_return_if_fail (widget != NULL);
 359     g_return_if_fail (GTK_IS_VIM (widget));
 360     g_return_if_fail (filename != NULL);
 361
 362     vim = GTK_VIM (widget);
 363
 364     /*
 365         g_return_if_fail (vim->server_name != NULL);
 366     g_return_if_fail (vim->socket.plug_window != NULL);
 367         */
 368
 369         g_message ("Adding files to edit");
 370     va_start( args, filename );
 371
 372         /* If the server is not yet started, put the files in init files list */
 373         if (vim->server_name)
 374         {
 375                 files = g_strdup(filename);
 376         }
 377         else
 378         {
 379                 tmp = vim->init_files;
 380                 vim->init_files = g_strconcat(tmp, " ", filename, NULL );
 381                 g_free( tmp );
 382         }
 383     for (arg = (gchar *)va_arg( args, gchar * );  arg; )
 384     {
 385                 if (vim->server_name)
 386                 {
 387                         tmp = files;
 388                         files = g_strconcat( tmp, " ", arg, NULL );
 389                         g_free( tmp );
 390                 }
 391                 else
 392                 {
 393             tmp = vim->init_files;
 394             vim->init_files = g_strconcat( tmp, " ", arg, NULL );
 395             g_free( tmp );
 396                 }
 397     }
 398
 399     va_end(args);
 400
 401         if (!vim->server_name)
 402                 return;
 403
 404     cmd = g_strdup_printf(
 405         "gvim --servername %s --remote-send '<C-\\><C-N>:drop %s<CR>'",
 406         vim->server_name, files );
 407     system(cmd);
 408
 409     g_free(cmd);
 410     g_free(files);
 411 }
 412
 413
 414 void
 415 gtk_vim_remote_send (GtkVim *widget,
 416                      const gchar     *keys)
 417 {
 418     GtkVim *vim;
 419     gchar  *cmd;
 420
 421     g_return_if_fail (widget != NULL);
 422     g_return_if_fail (GTK_IS_VIM (widget));
 423     g_return_if_fail (keys != NULL);
 424
 425     vim = GTK_VIM (widget);
 426
 427     g_return_if_fail (vim->server_name != NULL);
 428     g_return_if_fail (vim->socket.plug_window != NULL);
 429
 430     cmd = g_strdup_printf(
 431         "gvim --servername %s --remote-send '%s'",
 432         vim->server_name, keys );
 433     system(cmd);
 434
 435     g_free(cmd);
 436 }
 437
 438
 439 void
 440 gtk_vim_goto( GtkVim *widget,
 441               const gchar     *buffer,
 442               gint       line,
 443               gint       column )
 444 {
 445     GtkVim *vim;
 446     gchar  *cmd, *vimcmd;
 447
 448     g_return_if_fail (widget != NULL);
 449     g_return_if_fail (GTK_IS_VIM (widget));
 450     g_return_if_fail (line > 0  &&  column >= 0);
 451
 452     vim = GTK_VIM (widget);
 453
 454     g_return_if_fail (vim->server_name != NULL);
 455     g_return_if_fail (vim->socket.plug_window != NULL);
 456
 457     if (buffer)
 458     {
 459         vimcmd = g_strdup_printf(
 460             "<C-\\><C-N>:buffer %s<cr>%dG%d|",
 461             buffer, line, column );
 462     }
 463     else
 464     {
 465         vimcmd = g_strdup_printf(
 466             "<C-\\><C-N>%dG%d|",
 467             line, column );
 468     }
 469
 470     cmd = g_strdup_printf(
 471         "gvim --servername %s --remote-send '%s'",
 472         vim->server_name, vimcmd );
 473     system(cmd);
 474
 475     g_free(cmd);
 476     g_free(vimcmd);
 477 }