tilda-terminal.c

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