tilda-terminal.c

   1 #include "tilda.h"
   2 #include "tilda-terminal.h"
   3 #include "tilda-terminal-dbus-glue.h"
   4
   5 static void
   6 tilda_terminal_dbus_register_object (TildaTerminal *tt)
   7 {
   8         gchar *object_path;
   9
  10         // Register this object with DBus
  11         object_path = g_strdup_printf ("/net/sourceforge/Tilda/Window%d/Terminal%d",
  12                                                                    tt->window_number, tt->number);
  13         dbus_g_connection_register_g_object (dbus_connection, object_path, G_OBJECT(tt));
  14         g_free (object_path);
  15 }
  16
  17 static GObjectClass *parent_class = NULL;
  18
  19 /* API */
  20
  21 /*
  22  * All GObject stuff is below. You probably don't need to change this...
  23  */
  24
  25 enum tilda_terminal_properties {
  26         TILDA_TERMINAL_NUMBER = 1,
  27         TILDA_TERMINAL_WINDOW_NUMBER,
  28
  29         /* All non-constructor-only properties */
  30         TILDA_TERMINAL_BACKGROUND_IMAGE,
  31         TILDA_TERMINAL_SHELL,
  32         TILDA_TERMINAL_FONT,
  33         TILDA_TERMINAL_TITLE,
  34         TILDA_TERMINAL_WORKING_DIRECTORY,
  35
  36         TILDA_TERMINAL_SCROLLBACK_LINES,
  37         TILDA_TERMINAL_TRANSPARENCY_PERCENT,
  38
  39         TILDA_TERMINAL_BACKSPACE_BINDING,
  40         TILDA_TERMINAL_DELETE_BINDING,
  41         TILDA_TERMINAL_DYNAMIC_TITLE,
  42         TILDA_TERMINAL_EXIT_ACTION,
  43 };
  44
  45 static void
  46 tilda_terminal_instance_init (GTypeInstance *instance,
  47                                                           gpointer       g_class)
  48 {
  49         TildaTerminal *self = (TildaTerminal *) instance;
  50
  51         /* Initialize instance members and allocate any necessary memory here.
  52          * NOTE: any constructor-time values will be set later. */
  53         self->dispose_has_run = FALSE;
  54         self->number = 0;
  55
  56         self->vte_term = vte_terminal_new ();
  57         self->scrollbar = gtk_vscrollbar_new (VTE_TERMINAL(self->vte_term)->adjustment);
  58         self->hbox = gtk_hbox_new (FALSE, 0);
  59 }
  60
  61 static void
  62 tilda_terminal_set_property (GObject      *object,
  63                                                          guint         property_id,
  64                                                          const GValue *value,
  65                                                          GParamSpec   *pspec)
  66 {
  67         TildaTerminal *self = (TildaTerminal *) object;
  68
  69         switch (property_id) {
  70
  71                 case TILDA_TERMINAL_NUMBER:
  72                         self->number = g_value_get_int (value);
  73                         g_print ("terminal number: %d\n", self->number);
  74                         break;
  75
  76                 case TILDA_TERMINAL_WINDOW_NUMBER:
  77                         self->window_number = g_value_get_int (value);
  78                         g_print ("terminal parent window number: %d\n", self->window_number);
  79                         break;
  80
  81                 case TILDA_TERMINAL_BACKGROUND_IMAGE:
  82                         g_free (self->background_image);
  83                         self->background_image = g_value_dup_string (value);
  84                         // TODO: Actually set it in self->vte_term
  85                         g_print ("terminal back img: %s\n", self->background_image);
  86                         break;
  87
  88                 case TILDA_TERMINAL_SHELL:
  89                         g_free (self->shell);
  90                         self->shell = g_value_dup_string (value);
  91                         g_print ("terminal shell: %s\n", self->shell);
  92                         break;
  93
  94                 case TILDA_TERMINAL_FONT:
  95                         g_free (self->font);
  96                         self->font = g_value_dup_string (value);
  97                         vte_terminal_set_font_from_string (VTE_TERMINAL(self->vte_term), self->font);
  98                         g_print ("terminal font: %s\n", self->font);
  99                         break;
 100
 101                 case TILDA_TERMINAL_TITLE:
 102                         g_free (self->title);
 103                         self->title = g_value_dup_string (value);
 104                         g_print ("terminal title: %s\n", self->title);
 105                         break;
 106
 107                 case TILDA_TERMINAL_WORKING_DIRECTORY:
 108                         g_free (self->working_directory);
 109                         self->working_directory = g_value_dup_string (value);
 110                         g_print ("terminal wrk dir: %s\n", self->working_directory);
 111                         break;
 112
 113                 case TILDA_TERMINAL_SCROLLBACK_LINES:
 114                         self->scrollback_lines = g_value_get_int (value);
 115                         g_print ("terminal scrollback lines: %d\n", self->scrollback_lines);
 116                         break;
 117
 118                 case TILDA_TERMINAL_TRANSPARENCY_PERCENT:
 119                         self->transparency_percent = g_value_get_int (value);
 120                         g_print ("terminal transp percent: %d\n", self->transparency_percent);
 121                         break;
 122
 123                 case TILDA_TERMINAL_BACKSPACE_BINDING:
 124                         self->backspace_binding = g_value_get_int (value);
 125                         //vte_terminal_set_backspace_binding (VTE_TERMINAL(self->vte_term), self->backspace_binding);
 126                         g_print ("terminal backspace key: %d\n", self->backspace_binding);
 127                         break;
 128
 129                 case TILDA_TERMINAL_DELETE_BINDING:
 130                         self->delete_binding = g_value_get_int (value);
 131                         //vte_terminal_set_delete_binding (VTE_TERMINAL(self->vte_term), self->delete_binding);
 132                         g_print ("terminal delete key: %d\n", self->delete_binding);
 133                         break;
 134
 135                 case TILDA_TERMINAL_DYNAMIC_TITLE:
 136                         self->dynamic_title = g_value_get_int (value);
 137                         g_print ("terminal dynamic title: %d\n", self->dynamic_title);
 138                         break;
 139
 140                 case TILDA_TERMINAL_EXIT_ACTION:
 141                         self->exit_action = g_value_get_int (value);
 142                         g_print ("terminal exit action: %d\n", self->exit_action);
 143                         break;
 144
 145                 default:
 146                         /* We don't have this property... */
 147                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 148                         break;
 149         }
 150 }
 151
 152 static void
 153 tilda_terminal_get_property (GObject    *object,
 154                                                          guint       property_id,
 155                                                          GValue     *value,
 156                                                          GParamSpec *pspec)
 157 {
 158         TildaTerminal *self = (TildaTerminal *) object;
 159
 160         switch (property_id) {
 161
 162                 case TILDA_TERMINAL_NUMBER:
 163                         g_value_set_int (value, self->number);
 164                         break;
 165
 166                 case TILDA_TERMINAL_WINDOW_NUMBER:
 167                         g_value_set_int (value, self->window_number);
 168                         break;
 169
 170                 case TILDA_TERMINAL_BACKGROUND_IMAGE:
 171                         g_value_set_string (value, self->background_image);
 172                         break;
 173
 174                 case TILDA_TERMINAL_SHELL:
 175                         g_value_set_string (value, self->shell);
 176                         break;
 177
 178                 case TILDA_TERMINAL_FONT:
 179                         g_value_set_string (value, self->font);
 180                         break;
 181
 182                 case TILDA_TERMINAL_TITLE:
 183                         g_value_set_string (value, self->title);
 184                         break;
 185
 186                 case TILDA_TERMINAL_WORKING_DIRECTORY:
 187                         g_value_set_string (value, self->working_directory);
 188                         break;
 189
 190                 case TILDA_TERMINAL_SCROLLBACK_LINES:
 191                         g_value_set_int (value, self->scrollback_lines);
 192                         break;
 193
 194                 case TILDA_TERMINAL_TRANSPARENCY_PERCENT:
 195                         g_value_set_int (value, self->transparency_percent);
 196                         break;
 197
 198                 default:
 199                         /* We don't have this property... */
 200                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 201                         break;
 202         }
 203 }
 204
 205 static GObject *
 206 tilda_terminal_constructor (GType                  type,
 207                                                         guint                  n_construct_properties,
 208                                                         GObjectConstructParam *construct_properties)
 209 {
 210         GObject *obj;
 211         TildaTerminal *self;
 212
 213         /* Invoke parent constructor */
 214         TildaTerminalClass *klass;
 215         klass = TILDA_TERMINAL_CLASS (g_type_class_peek (TILDA_TYPE_TERMINAL));
 216         obj = parent_class->constructor (type,
 217                                                                          n_construct_properties,
 218                                                                          construct_properties);
 219
 220         /* Do other stuff here. The object is ready to go now, and all
 221          * ctor properties have been set.
 222          *
 223          * TODO: This is the place to do DBus-init */
 224         self = TILDA_TERMINAL(obj);
 225
 226         /* Pack into the hbox */
 227         gtk_box_pack_end (GTK_BOX(self->hbox), self->scrollbar, FALSE, FALSE, 0);
 228         gtk_box_pack_end (GTK_BOX(self->hbox), self->vte_term, TRUE, TRUE, 0);
 229         gtk_widget_show (self->scrollbar);
 230
 231
 232         g_signal_connect (G_OBJECT(self->vte_term), "child-exited",
 233                                           G_CALLBACK(gtk_main_quit), self);
 234
 235         vte_terminal_fork_command (VTE_TERMINAL(self->vte_term), NULL, NULL, NULL, NULL, FALSE, FALSE, FALSE);
 236
 237         tilda_terminal_dbus_register_object (self);
 238
 239         return obj;
 240 }
 241
 242 static void
 243 tilda_terminal_dispose (GObject *obj)
 244 {
 245         TildaTerminal *self = (TildaTerminal *) obj;
 246
 247         /* We don't want to run dispose twice, so just return immediately */
 248         if (self->dispose_has_run)
 249                 return;
 250
 251         self->dispose_has_run = TRUE;
 252
 253         /*
 254          * In dispose, you are supposed to free all types referenced from this
 255          * object which might themselves hold a reference to self. Generally,
 256          * the most simple solution is to unref all members on which you own a
 257          * reference.
 258          */
 259
 260         /* Chain up to the parent class */
 261         G_OBJECT_CLASS (parent_class)->dispose (obj);
 262 }
 263
 264 static void
 265 tilda_terminal_finalize (GObject *obj)
 266 {
 267         TildaTerminal *self = (TildaTerminal *) obj;
 268
 269         /*
 270          * Here, complete object destruction.
 271          * You might not need to do much...
 272          */
 273
 274         // TODO: g_free() any primitives here
 275         g_free (self->background_image);
 276         g_free (self->shell);
 277         g_free (self->font);
 278         g_free (self->title);
 279         g_free (self->working_directory);
 280
 281
 282         /* Chain up to the parent class */
 283         G_OBJECT_CLASS (parent_class)->finalize (obj);
 284 }
 285
 286 static void
 287 tilda_terminal_class_init (gpointer g_class,
 288                                                    gpointer g_class_data)
 289 {
 290         GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
 291         TildaTerminalClass *klass = TILDA_TERMINAL_CLASS (g_class);
 292         GParamSpec *pspec;
 293
 294         /* Hook our functions to this type */
 295         gobject_class->set_property = tilda_terminal_set_property;
 296         gobject_class->get_property = tilda_terminal_get_property;
 297         gobject_class->dispose = tilda_terminal_dispose;
 298         gobject_class->finalize = tilda_terminal_finalize;
 299         gobject_class->constructor = tilda_terminal_constructor;
 300
 301         parent_class = g_type_class_peek_parent (klass);
 302
 303         /* Hook the TildaTerminal type into DBus */
 304         dbus_g_object_type_install_info (tilda_terminal_get_type(), &dbus_glib_tilda_terminal_object_info);
 305
 306         /* Install all of the properties */
 307         pspec = g_param_spec_int ("number",
 308                                                           "Terminal number",
 309                                                           "Set terminal's number",
 310                                                           0,            // min value
 311                                                           INT_MAX,      // max value
 312                                                           0,            // def value
 313                                                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 314
 315         g_object_class_install_property (gobject_class,
 316                                                                          TILDA_TERMINAL_NUMBER,
 317                                                                          pspec);
 318
 319         pspec = g_param_spec_int ("window-number",
 320                                                           "Number of the window to which this terminal belongs",
 321                                                           "Set the number of the parent window",
 322                                                           0,
 323                                                           INT_MAX,
 324                                                           0x0000beef,
 325                                                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 326
 327         g_object_class_install_property (gobject_class,
 328                                                                          TILDA_TERMINAL_WINDOW_NUMBER,
 329                                                                          pspec);
 330
 331         pspec = g_param_spec_string ("background-image",
 332                                                                  "Terminal's background image",
 333                                                                  "Get/Set terminal's background image",
 334                                                                  NULL,
 335                                                                  G_PARAM_READWRITE);
 336
 337         g_object_class_install_property (gobject_class,
 338                                                                          TILDA_TERMINAL_BACKGROUND_IMAGE,
 339                                                                          pspec);
 340
 341         pspec = g_param_spec_string ("shell",
 342                                                                  "Terminal's shell",
 343                                                                  "Get/Set terminal's shell",
 344                                                                  NULL,
 345                                                                  G_PARAM_READWRITE);
 346
 347         g_object_class_install_property (gobject_class,
 348                                                                          TILDA_TERMINAL_SHELL,
 349                                                                          pspec);
 350
 351         pspec = g_param_spec_string ("font",
 352                                                                  "Terminal's font",
 353                                                                  "Get/Set terminal's font",
 354                                                                  NULL,
 355                                                                  G_PARAM_READWRITE);
 356
 357         g_object_class_install_property (gobject_class,
 358                                                                          TILDA_TERMINAL_FONT,
 359                                                                          pspec);
 360
 361         pspec = g_param_spec_string ("title",
 362                                                                  "Terminal's title",
 363                                                                  "Get/Set terminal's title",
 364                                                                  NULL,
 365                                                                  G_PARAM_READWRITE);
 366
 367         g_object_class_install_property (gobject_class,
 368                                                                          TILDA_TERMINAL_TITLE,
 369                                                                          pspec);
 370
 371         pspec = g_param_spec_string ("working-directory",
 372                                                                  "Terminal's initial working directory",
 373                                                                  "Get/Set terminal's initial working directory",
 374                                                                  NULL,
 375                                                                  G_PARAM_READWRITE);
 376
 377         g_object_class_install_property (gobject_class,
 378                                                                          TILDA_TERMINAL_WORKING_DIRECTORY,
 379                                                                          pspec);
 380
 381         pspec = g_param_spec_int ("scrollback-lines",
 382                                                           "Terminal's scrollback amount (lines)",
 383                                                           "Get/Set terminal's scrollback amount",
 384                                                           0,
 385                                                           INT_MAX, // TODO: artificially limit this?
 386                                                           1000,
 387                                                           G_PARAM_READWRITE);
 388
 389         g_object_class_install_property (gobject_class,
 390                                                                          TILDA_TERMINAL_SCROLLBACK_LINES,
 391                                                                          pspec);
 392
 393         pspec = g_param_spec_int ("transparency-percent",
 394                                                           "Terminal's transparency (percent)",
 395                                                           "Get/Set terminal's transparency",
 396                                                           0,
 397                                                           100,
 398                                                           0,
 399                                                           G_PARAM_READWRITE);
 400
 401         g_object_class_install_property (gobject_class,
 402                                                                          TILDA_TERMINAL_TRANSPARENCY_PERCENT,
 403                                                                          pspec);
 404 }
 405
 406 GType
 407 tilda_terminal_get_type (void)
 408 {
 409         static GType type = 0;
 410
 411         if (type == 0)
 412         {
 413                 static const GTypeInfo info = {
 414                         sizeof (TildaTerminalClass),
 415                         NULL,   /* base_init */
 416                         NULL,   /* base_finalize */
 417                         tilda_terminal_class_init,      /* class_init */
 418                         NULL,   /* class_finalize */
 419                         NULL,   /* class_data */
 420                         sizeof (TildaTerminal),
 421                         0,              /* n_preallocs */
 422                         tilda_terminal_instance_init,   /* instance_init */
 423                 };
 424
 425                 type = g_type_register_static (G_TYPE_OBJECT,
 426                                                                            "TildaTerminalType",
 427                                                                            &info,
 428                                                                            0);
 429         }
 430
 431         return type;
 432 }
 433
 434 #if 0
 435
 436 int main (int argc, char *argv[])
 437 {
 438         GObject *tt;
 439         gint test_number = INT_MIN;
 440         gchar *test_string = NULL;
 441
 442         /* Initialize the GObject type system */
 443         g_type_init ();
 444         gtk_init (&argc, &argv);
 445
 446         tt = g_object_new (TILDA_TYPE_TERMINAL, "number", 10, NULL);
 447         g_object_get (G_OBJECT (tt), "number", &test_number, NULL);
 448         g_assert (test_number == 10);
 449
 450         g_object_unref (G_OBJECT (tt));
 451
 452         tt = g_object_new (TILDA_TYPE_TERMINAL, "number", 22, NULL);
 453         g_object_get (G_OBJECT (tt), "number", &test_number, NULL);
 454         g_assert (test_number == 22);
 455
 456         g_object_set (G_OBJECT (tt), "font", "hello I'm a font");
 457         g_object_set (G_OBJECT (tt), "font", "Bitstream Vera Sans Mono 13");
 458
 459         g_object_get (G_OBJECT (tt), "font", &test_string, NULL);
 460         g_print ("Read Font: %s\n", test_string);
 461         // NOTE: you MUST free the string!!!!
 462         g_free (test_string);
 463
 464         g_object_set (G_OBJECT (tt), "transparency-percent", 50);
 465
 466         g_object_unref (G_OBJECT (tt));
 467
 468         return 0;
 469 }
 470
 471 #endif
 472
 473 /* vim: set ts=4 sts=4 sw=4 noet tw=112: */