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         TILDA_TERMINAL_TW,
  29
  30         /* All non-constructor-only properties */
  31         TILDA_TERMINAL_BACKGROUND_IMAGE,
  32         TILDA_TERMINAL_SHELL,
  33         TILDA_TERMINAL_FONT,
  34         TILDA_TERMINAL_TITLE,
  35         TILDA_TERMINAL_WORKING_DIRECTORY,
  36
  37         TILDA_TERMINAL_SCROLLBACK_LINES,
  38         TILDA_TERMINAL_TRANSPARENCY_PERCENT,
  39
  40         TILDA_TERMINAL_BACKSPACE_BINDING,
  41         TILDA_TERMINAL_DELETE_BINDING,
  42         TILDA_TERMINAL_DYNAMIC_TITLE,
  43         TILDA_TERMINAL_EXIT_ACTION,
  44
  45         TILDA_TERMINAL_SCROLL_BACKGROUND,
  46         TILDA_TERMINAL_SCROLL_ON_OUTPUT,
  47         TILDA_TERMINAL_SCROLL_ON_KEYSTROKE,
  48         TILDA_TERMINAL_ANTIALIASED,
  49         TILDA_TERMINAL_ALLOW_BOLD_TEXT,
  50         TILDA_TERMINAL_CURSOR_BLINKS,
  51         TILDA_TERMINAL_AUDIBLE_BELL,
  52         TILDA_TERMINAL_VISIBLE_BELL,
  53         TILDA_TERMINAL_DOUBLE_BUFFERED,
  54 };
  55
  56 static void
  57 tilda_terminal_instance_init (GTypeInstance *instance,
  58                                                           gpointer       g_class)
  59 {
  60         TildaTerminal *self = (TildaTerminal *) instance;
  61
  62         /* Initialize instance members and allocate any necessary memory here.
  63          * NOTE: any constructor-time values will be set later. */
  64         self->dispose_has_run = FALSE;
  65         self->number = 0;
  66
  67         self->vte_term = vte_terminal_new ();
  68         self->scrollbar = gtk_vscrollbar_new (VTE_TERMINAL(self->vte_term)->adjustment);
  69         self->hbox = gtk_hbox_new (FALSE, 0);
  70 }
  71
  72 static void
  73 tilda_terminal_set_property (GObject      *object,
  74                                                          guint         property_id,
  75                                                          const GValue *value,
  76                                                          GParamSpec   *pspec)
  77 {
  78         TildaTerminal *self = (TildaTerminal *) object;
  79
  80         switch (property_id) {
  81
  82                 case TILDA_TERMINAL_NUMBER:
  83                         self->number = g_value_get_int (value);
  84                         g_print ("terminal number: %d\n", self->number);
  85                         break;
  86
  87                 case TILDA_TERMINAL_WINDOW_NUMBER:
  88                         self->window_number = g_value_get_int (value);
  89                         g_print ("terminal parent window number: %d\n", self->window_number);
  90                         break;
  91
  92                 case TILDA_TERMINAL_TW:
  93                         self->parent_window = g_value_get_pointer (value);
  94                         g_print ("terminal parent window: 0x%x\n", self->parent_window);
  95                         g_print ("terminal parent window number (direct): %d\n", TILDA_WINDOW(self->parent_window)->number);
  96                         break;
  97
  98                 case TILDA_TERMINAL_BACKGROUND_IMAGE:
  99                         g_free (self->background_image);
 100                         self->background_image = g_value_dup_string (value);
 101                         vte_terminal_set_background_image_file (VTE_TERMINAL(self->vte_term), self->background_image);
 102                         g_print ("terminal back img: %s\n", self->background_image);
 103                         break;
 104
 105                 case TILDA_TERMINAL_SHELL:
 106                         g_free (self->shell);
 107                         self->shell = g_value_dup_string (value);
 108                         g_print ("terminal shell: %s\n", self->shell);
 109                         break;
 110
 111                 case TILDA_TERMINAL_FONT:
 112                         g_free (self->font);
 113                         self->font = g_value_dup_string (value);
 114                         vte_terminal_set_font_from_string_full (VTE_TERMINAL(self->vte_term),
 115                                                                                                         self->font,
 116                                                                                                         self->antialiased);
 117                         g_print ("terminal font: %s\n", self->font);
 118                         break;
 119
 120                 case TILDA_TERMINAL_TITLE:
 121                         g_free (self->title);
 122                         self->title = g_value_dup_string (value);
 123                         g_print ("terminal title: %s\n", self->title);
 124                         break;
 125
 126                 case TILDA_TERMINAL_WORKING_DIRECTORY:
 127                         g_free (self->working_directory);
 128                         self->working_directory = g_value_dup_string (value);
 129                         g_print ("terminal wrk dir: %s\n", self->working_directory);
 130                         break;
 131
 132                 case TILDA_TERMINAL_SCROLLBACK_LINES:
 133                         self->scrollback_lines = g_value_get_int (value);
 134                         vte_terminal_set_scrollback_lines (VTE_TERMINAL(self->vte_term), self->scrollback_lines);
 135                         g_print ("terminal scrollback lines: %d\n", self->scrollback_lines);
 136                         break;
 137
 138                 case TILDA_TERMINAL_TRANSPARENCY_PERCENT:
 139                         self->transparency_percent = g_value_get_int (value);
 140                         g_print ("terminal transp percent: %d\n", self->transparency_percent);
 141                         break;
 142
 143                 case TILDA_TERMINAL_BACKSPACE_BINDING:
 144                         self->backspace_binding = g_value_get_int (value);
 145                         vte_terminal_set_backspace_binding (VTE_TERMINAL(self->vte_term), self->backspace_binding);
 146                         g_print ("terminal backspace key: %d\n", self->backspace_binding);
 147                         break;
 148
 149                 case TILDA_TERMINAL_DELETE_BINDING:
 150                         self->delete_binding = g_value_get_int (value);
 151                         vte_terminal_set_delete_binding (VTE_TERMINAL(self->vte_term), self->delete_binding);
 152                         g_print ("terminal delete key: %d\n", self->delete_binding);
 153                         break;
 154
 155                 case TILDA_TERMINAL_DYNAMIC_TITLE:
 156                         self->dynamic_title = g_value_get_int (value);
 157                         g_print ("terminal dynamic title: %d\n", self->dynamic_title);
 158                         break;
 159
 160                 case TILDA_TERMINAL_EXIT_ACTION:
 161                         self->exit_action = g_value_get_int (value);
 162                         g_print ("terminal exit action: %d\n", self->exit_action);
 163                         break;
 164
 165                 case TILDA_TERMINAL_SCROLL_BACKGROUND:
 166                         self->scroll_background = g_value_get_boolean (value);
 167                         vte_terminal_set_scroll_background (VTE_TERMINAL(self->vte_term), self->scroll_background);
 168                         g_print ("terminal scroll background: %d\n", self->scroll_background);
 169                         break;
 170
 171                 case TILDA_TERMINAL_SCROLL_ON_OUTPUT:
 172                         self->scroll_on_output = g_value_get_boolean (value);
 173                         vte_terminal_set_scroll_on_output (VTE_TERMINAL(self->vte_term), self->scroll_on_output);
 174                         g_print ("terminal scroll on output: %d\n", self->scroll_on_output);
 175                         break;
 176
 177                 case TILDA_TERMINAL_SCROLL_ON_KEYSTROKE:
 178                         self->scroll_on_keystroke = g_value_get_boolean (value);
 179                         vte_terminal_set_scroll_on_keystroke (VTE_TERMINAL(self->vte_term), self->scroll_on_keystroke);
 180                         g_print ("terminal scroll on keystroke: %d\n", self->scroll_on_keystroke);
 181                         break;
 182
 183                 case TILDA_TERMINAL_ANTIALIASED:
 184                         self->antialiased = g_value_get_boolean (value);
 185                         vte_terminal_set_font_from_string_full (VTE_TERMINAL(self->vte_term),
 186                                                                                                         self->font,
 187                                                                                                         self->antialiased);
 188                         g_print ("terminal antialiased: %d\n", self->antialiased);
 189                         break;
 190
 191                 case TILDA_TERMINAL_ALLOW_BOLD_TEXT:
 192                         self->allow_bold_text = g_value_get_boolean (value);
 193                         vte_terminal_set_allow_bold (VTE_TERMINAL(self->vte_term), self->allow_bold_text);
 194                         g_print ("terminal allow bold text: %d\n", self->allow_bold_text);
 195                         break;
 196
 197                 case TILDA_TERMINAL_CURSOR_BLINKS:
 198                         self->cursor_blinks = g_value_get_boolean (value);
 199                         vte_terminal_set_cursor_blinks (VTE_TERMINAL(self->vte_term), self->cursor_blinks);
 200                         g_print ("terminal cursor blinks: %d\n", self->cursor_blinks);
 201                         break;
 202
 203                 case TILDA_TERMINAL_AUDIBLE_BELL:
 204                         self->audible_bell = g_value_get_boolean (value);
 205                         vte_terminal_set_audible_bell (VTE_TERMINAL(self->vte_term), self->audible_bell);
 206                         g_print ("terminal audible bell: %d\n", self->audible_bell);
 207                         break;
 208
 209                 case TILDA_TERMINAL_VISIBLE_BELL:
 210                         self->visible_bell = g_value_get_boolean (value);
 211                         vte_terminal_set_visible_bell (VTE_TERMINAL(self->vte_term), self->visible_bell);
 212                         g_print ("terminal visible bell: %d\n", self->visible_bell);
 213                         break;
 214
 215                 case TILDA_TERMINAL_DOUBLE_BUFFERED:
 216                         self->double_buffered = g_value_get_boolean (value);
 217                         gtk_widget_set_double_buffered (GTK_WIDGET(self->vte_term), self->double_buffered);
 218                         g_print ("terminal double buffered: %d\n", self->double_buffered);
 219                         break;
 220
 221                 default:
 222                         /* We don't have this property... */
 223                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 224                         break;
 225         }
 226 }
 227
 228 static void
 229 tilda_terminal_get_property (GObject    *object,
 230                                                          guint       property_id,
 231                                                          GValue     *value,
 232                                                          GParamSpec *pspec)
 233 {
 234         TildaTerminal *self = (TildaTerminal *) object;
 235
 236         switch (property_id) {
 237
 238                 case TILDA_TERMINAL_NUMBER:
 239                         g_value_set_int (value, self->number);
 240                         break;
 241
 242                 case TILDA_TERMINAL_WINDOW_NUMBER:
 243                         g_value_set_int (value, self->window_number);
 244                         break;
 245
 246                 case TILDA_TERMINAL_TW:
 247                         g_value_set_pointer (value, self->parent_window);
 248                         break;
 249
 250                 case TILDA_TERMINAL_BACKGROUND_IMAGE:
 251                         g_value_set_string (value, self->background_image);
 252                         break;
 253
 254                 case TILDA_TERMINAL_SHELL:
 255                         g_value_set_string (value, self->shell);
 256                         break;
 257
 258                 case TILDA_TERMINAL_FONT:
 259                         g_value_set_string (value, self->font);
 260                         break;
 261
 262                 case TILDA_TERMINAL_TITLE:
 263                         g_value_set_string (value, self->title);
 264                         break;
 265
 266                 case TILDA_TERMINAL_WORKING_DIRECTORY:
 267                         g_value_set_string (value, self->working_directory);
 268                         break;
 269
 270                 case TILDA_TERMINAL_SCROLLBACK_LINES:
 271                         g_value_set_int (value, self->scrollback_lines);
 272                         break;
 273
 274                 case TILDA_TERMINAL_TRANSPARENCY_PERCENT:
 275                         g_value_set_int (value, self->transparency_percent);
 276                         break;
 277
 278                 case TILDA_TERMINAL_BACKSPACE_BINDING:
 279                         g_value_set_int (value, self->backspace_binding);
 280                         break;
 281
 282                 case TILDA_TERMINAL_DELETE_BINDING:
 283                         g_value_set_int (value, self->delete_binding);
 284                         break;
 285
 286                 case TILDA_TERMINAL_DYNAMIC_TITLE:
 287                         g_value_set_int (value, self->dynamic_title);
 288                         break;
 289
 290                 case TILDA_TERMINAL_EXIT_ACTION:
 291                         g_value_set_int (value, self->exit_action);
 292                         break;
 293
 294                 case TILDA_TERMINAL_SCROLL_BACKGROUND:
 295                         g_value_set_boolean (value, self->scroll_background);
 296                         break;
 297
 298                 case TILDA_TERMINAL_SCROLL_ON_OUTPUT:
 299                         g_value_set_boolean (value, self->scroll_on_output);
 300                         break;
 301
 302                 case TILDA_TERMINAL_SCROLL_ON_KEYSTROKE:
 303                         g_value_set_boolean (value, self->scroll_on_keystroke);
 304                         break;
 305
 306                 case TILDA_TERMINAL_ANTIALIASED:
 307                         g_value_set_boolean (value, self->antialiased);
 308                         break;
 309
 310                 case TILDA_TERMINAL_ALLOW_BOLD_TEXT:
 311                         g_value_set_boolean (value, self->allow_bold_text);
 312                         break;
 313
 314                 case TILDA_TERMINAL_CURSOR_BLINKS:
 315                         g_value_set_boolean (value, self->cursor_blinks);
 316                         break;
 317
 318                 case TILDA_TERMINAL_AUDIBLE_BELL:
 319                         g_value_set_boolean (value, self->audible_bell);
 320                         break;
 321
 322                 case TILDA_TERMINAL_VISIBLE_BELL:
 323                         g_value_set_boolean (value, self->visible_bell);
 324                         break;
 325
 326                 case TILDA_TERMINAL_DOUBLE_BUFFERED:
 327                         g_value_set_boolean (value, self->double_buffered);
 328                         break;
 329
 330                 default:
 331                         /* We don't have this property... */
 332                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 333                         break;
 334         }
 335 }
 336
 337 static GObject *
 338 tilda_terminal_constructor (GType                  type,
 339                                                         guint                  n_construct_properties,
 340                                                         GObjectConstructParam *construct_properties)
 341 {
 342         GObject *obj;
 343         TildaTerminal *self;
 344
 345         /* Invoke parent constructor */
 346         TildaTerminalClass *klass;
 347         klass = TILDA_TERMINAL_CLASS (g_type_class_peek (TILDA_TYPE_TERMINAL));
 348         obj = parent_class->constructor (type,
 349                                                                          n_construct_properties,
 350                                                                          construct_properties);
 351
 352         /* Do other stuff here. The object is ready to go now, and all
 353          * ctor properties have been set.
 354          *
 355          * TODO: This is the place to do DBus-init */
 356         self = TILDA_TERMINAL(obj);
 357
 358         /* Pack into the hbox */
 359         gtk_box_pack_end (GTK_BOX(self->hbox), self->scrollbar, FALSE, FALSE, 0);
 360         gtk_box_pack_end (GTK_BOX(self->hbox), self->vte_term, TRUE, TRUE, 0);
 361         gtk_widget_show (self->scrollbar);
 362
 363
 364         g_signal_connect (G_OBJECT(self->vte_term), "child-exited",
 365                                           G_CALLBACK(gtk_main_quit), self);
 366
 367         vte_terminal_fork_command (VTE_TERMINAL(self->vte_term), NULL, NULL, NULL, NULL, FALSE, FALSE, FALSE);
 368
 369         tilda_terminal_dbus_register_object (self);
 370
 371         return obj;
 372 }
 373
 374 static void
 375 tilda_terminal_dispose (GObject *obj)
 376 {
 377         TildaTerminal *self = (TildaTerminal *) obj;
 378
 379         /* We don't want to run dispose twice, so just return immediately */
 380         if (self->dispose_has_run)
 381                 return;
 382
 383         self->dispose_has_run = TRUE;
 384
 385         /*
 386          * In dispose, you are supposed to free all types referenced from this
 387          * object which might themselves hold a reference to self. Generally,
 388          * the most simple solution is to unref all members on which you own a
 389          * reference.
 390          */
 391
 392         /* Chain up to the parent class */
 393         G_OBJECT_CLASS (parent_class)->dispose (obj);
 394 }
 395
 396 static void
 397 tilda_terminal_finalize (GObject *obj)
 398 {
 399         TildaTerminal *self = (TildaTerminal *) obj;
 400
 401         /*
 402          * Here, complete object destruction.
 403          * You might not need to do much...
 404          */
 405
 406         // TODO: g_free() any primitives here
 407         g_free (self->background_image);
 408         g_free (self->shell);
 409         g_free (self->font);
 410         g_free (self->title);
 411         g_free (self->working_directory);
 412
 413
 414         /* Chain up to the parent class */
 415         G_OBJECT_CLASS (parent_class)->finalize (obj);
 416 }
 417
 418 static void
 419 tilda_terminal_class_init (gpointer g_class,
 420                                                    gpointer g_class_data)
 421 {
 422         GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
 423         TildaTerminalClass *klass = TILDA_TERMINAL_CLASS (g_class);
 424         GParamSpec *pspec;
 425
 426         /* Hook our functions to this type */
 427         gobject_class->set_property = tilda_terminal_set_property;
 428         gobject_class->get_property = tilda_terminal_get_property;
 429         gobject_class->dispose = tilda_terminal_dispose;
 430         gobject_class->finalize = tilda_terminal_finalize;
 431         gobject_class->constructor = tilda_terminal_constructor;
 432
 433         parent_class = g_type_class_peek_parent (klass);
 434
 435         /* Hook the TildaTerminal type into DBus */
 436         dbus_g_object_type_install_info (tilda_terminal_get_type(), &dbus_glib_tilda_terminal_object_info);
 437
 438         /* Install all of the properties */
 439         pspec = g_param_spec_int ("number",
 440                                                           "Terminal number",
 441                                                           "Set terminal's number",
 442                                                           0,            // min value
 443                                                           INT_MAX,      // max value
 444                                                           0,            // def value
 445                                                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 446
 447         g_object_class_install_property (gobject_class,
 448                                                                          TILDA_TERMINAL_NUMBER,
 449                                                                          pspec);
 450
 451         pspec = g_param_spec_int ("window-number",
 452                                                           "Number of the window to which this terminal belongs",
 453                                                           "Set the number of the parent window",
 454                                                           0,
 455                                                           INT_MAX,
 456                                                           0x0000beef,
 457                                                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 458
 459         g_object_class_install_property (gobject_class,
 460                                                                          TILDA_TERMINAL_WINDOW_NUMBER,
 461                                                                          pspec);
 462
 463         pspec = g_param_spec_pointer ("parent-window",
 464                                                                   "Pointer to terminal's parent TildaWindow",
 465                                                                   "Set the pointer to the terminal's parent TildaWindow",
 466                                                                   G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 467
 468         g_object_class_install_property (gobject_class,
 469                                                                          TILDA_TERMINAL_TW,
 470                                                                          pspec);
 471
 472         pspec = g_param_spec_string ("background-image",
 473                                                                  "Terminal's background image",
 474                                                                  "Get/Set terminal's background image",
 475                                                                  NULL,
 476                                                                  G_PARAM_READWRITE);
 477
 478         g_object_class_install_property (gobject_class,
 479                                                                          TILDA_TERMINAL_BACKGROUND_IMAGE,
 480                                                                          pspec);
 481
 482         pspec = g_param_spec_string ("shell",
 483                                                                  "Terminal's shell",
 484                                                                  "Get/Set terminal's shell",
 485                                                                  NULL,
 486                                                                  G_PARAM_READWRITE);
 487
 488         g_object_class_install_property (gobject_class,
 489                                                                          TILDA_TERMINAL_SHELL,
 490                                                                          pspec);
 491
 492         pspec = g_param_spec_string ("font",
 493                                                                  "Terminal's font",
 494                                                                  "Get/Set terminal's font",
 495                                                                  NULL,
 496                                                                  G_PARAM_READWRITE);
 497
 498         g_object_class_install_property (gobject_class,
 499                                                                          TILDA_TERMINAL_FONT,
 500                                                                          pspec);
 501
 502         pspec = g_param_spec_string ("title",
 503                                                                  "Terminal's title",
 504                                                                  "Get/Set terminal's title",
 505                                                                  NULL,
 506                                                                  G_PARAM_READWRITE);
 507
 508         g_object_class_install_property (gobject_class,
 509                                                                          TILDA_TERMINAL_TITLE,
 510                                                                          pspec);
 511
 512         pspec = g_param_spec_string ("working-directory",
 513                                                                  "Terminal's initial working directory",
 514                                                                  "Get/Set terminal's initial working directory",
 515                                                                  NULL,
 516                                                                  G_PARAM_READWRITE);
 517
 518         g_object_class_install_property (gobject_class,
 519                                                                          TILDA_TERMINAL_WORKING_DIRECTORY,
 520                                                                          pspec);
 521
 522         pspec = g_param_spec_int ("scrollback-lines",
 523                                                           "Terminal's scrollback amount (lines)",
 524                                                           "Get/Set terminal's scrollback amount",
 525                                                           0,
 526                                                           INT_MAX, // TODO: artificially limit this?
 527                                                           1000,
 528                                                           G_PARAM_READWRITE);
 529
 530         g_object_class_install_property (gobject_class,
 531                                                                          TILDA_TERMINAL_SCROLLBACK_LINES,
 532                                                                          pspec);
 533
 534         pspec = g_param_spec_int ("transparency-percent",
 535                                                           "Terminal's transparency (percent)",
 536                                                           "Get/Set terminal's transparency",
 537                                                           0,
 538                                                           100,
 539                                                           0,
 540                                                           G_PARAM_READWRITE);
 541
 542         g_object_class_install_property (gobject_class,
 543                                                                          TILDA_TERMINAL_TRANSPARENCY_PERCENT,
 544                                                                          pspec);
 545
 546         pspec = g_param_spec_int ("backspace-binding",
 547                                                           "Terminal's backspace binding",
 548                                                           "Get/Set terminal's backspace key binding",
 549                                                           VTE_ERASE_AUTO,
 550                                                           VTE_ERASE_DELETE_SEQUENCE,
 551                                                           VTE_ERASE_AUTO,
 552                                                           G_PARAM_READWRITE);
 553
 554         g_object_class_install_property (gobject_class,
 555                                                                          TILDA_TERMINAL_BACKSPACE_BINDING,
 556                                                                          pspec);
 557
 558         pspec = g_param_spec_int ("delete-binding",
 559                                                           "Terminal's delete binding",
 560                                                           "Get/Set terminal's delete key binding",
 561                                                           VTE_ERASE_AUTO,
 562                                                           VTE_ERASE_DELETE_SEQUENCE,
 563                                                           VTE_ERASE_AUTO,
 564                                                           G_PARAM_READWRITE);
 565
 566         g_object_class_install_property (gobject_class,
 567                                                                          TILDA_TERMINAL_DELETE_BINDING,
 568                                                                          pspec);
 569
 570         pspec = g_param_spec_int ("dynamic-title",
 571                                                           "Terminal's dynamic title generation method",
 572                                                           "Get/Set terminal's dynamic title generation method",
 573                                                           0,
 574                                                           INT_MAX,
 575                                                           0,
 576                                                           G_PARAM_READWRITE);
 577
 578         g_object_class_install_property (gobject_class,
 579                                                                          TILDA_TERMINAL_DYNAMIC_TITLE,
 580                                                                          pspec);
 581
 582         pspec = g_param_spec_int ("exit-action",
 583                                                           "Terminal's action upon child exit",
 584                                                           "Get/Set terminal's action upon child exit",
 585                                                           0,
 586                                                           INT_MAX,
 587                                                           0,
 588                                                           G_PARAM_READWRITE);
 589
 590         g_object_class_install_property (gobject_class,
 591                                                                          TILDA_TERMINAL_EXIT_ACTION,
 592                                                                          pspec);
 593
 594         pspec = g_param_spec_boolean ("scroll-background",
 595                                                                   "Controls terminal's scrolling behavior",
 596                                                                   "Get/Set terminal's scrolling behavior",
 597                                                                   FALSE,
 598                                                                   G_PARAM_READWRITE);
 599
 600         g_object_class_install_property (gobject_class,
 601                                                                          TILDA_TERMINAL_SCROLL_BACKGROUND,
 602                                                                          pspec);
 603
 604         pspec = g_param_spec_boolean ("scroll-on-output",
 605                                                                   "Controls terminal's scrolling behavior on output",
 606                                                                   "Get/Set terminal's scrolling behavior on output",
 607                                                                   FALSE,
 608                                                                   G_PARAM_READWRITE);
 609
 610         g_object_class_install_property (gobject_class,
 611                                                                          TILDA_TERMINAL_SCROLL_ON_OUTPUT,
 612                                                                          pspec);
 613
 614         pspec = g_param_spec_boolean ("scroll-on-keystroke",
 615                                                                   "Controls the terminal's scrolling behavior on keystroke",
 616                                                                   NULL, FALSE, G_PARAM_READWRITE);
 617
 618         g_object_class_install_property (gobject_class,
 619                                                                          TILDA_TERMINAL_SCROLL_ON_KEYSTROKE,
 620                                                                          pspec);
 621
 622         pspec = g_param_spec_boolean ("antialiased",
 623                                                                   "Attempt to antialias fonts",
 624                                                                   NULL, FALSE, G_PARAM_READWRITE);
 625
 626         g_object_class_install_property (gobject_class,
 627                                                                          TILDA_TERMINAL_ANTIALIASED,
 628                                                                          pspec);
 629
 630         pspec = g_param_spec_boolean ("allow-bold-text",
 631                                                                   "Allow bold text",
 632                                                                   NULL, FALSE, G_PARAM_READWRITE);
 633
 634         g_object_class_install_property (gobject_class,
 635                                                                          TILDA_TERMINAL_ALLOW_BOLD_TEXT,
 636                                                                          pspec);
 637
 638         pspec = g_param_spec_boolean ("cursor-blinks",
 639                                                                   NULL, NULL, FALSE, G_PARAM_READWRITE);
 640
 641         g_object_class_install_property (gobject_class,
 642                                                                          TILDA_TERMINAL_CURSOR_BLINKS,
 643                                                                          pspec);
 644
 645         pspec = g_param_spec_boolean ("audible-bell",
 646                                                                   NULL, NULL, FALSE, G_PARAM_READWRITE);
 647
 648         g_object_class_install_property (gobject_class,
 649                                                                          TILDA_TERMINAL_AUDIBLE_BELL,
 650                                                                          pspec);
 651
 652         pspec = g_param_spec_boolean ("visible-bell",
 653                                                                   NULL, NULL, FALSE, G_PARAM_READWRITE);
 654
 655         g_object_class_install_property (gobject_class,
 656                                                                          TILDA_TERMINAL_VISIBLE_BELL,
 657                                                                          pspec);
 658
 659         pspec = g_param_spec_boolean ("double-buffered",
 660                                                                   NULL, NULL, FALSE, G_PARAM_READWRITE);
 661
 662         g_object_class_install_property (gobject_class,
 663                                                                          TILDA_TERMINAL_DOUBLE_BUFFERED,
 664                                                                          pspec);
 665 }
 666
 667 GType
 668 tilda_terminal_get_type (void)
 669 {
 670         static GType type = 0;
 671
 672         if (type == 0)
 673         {
 674                 static const GTypeInfo info = {
 675                         sizeof (TildaTerminalClass),
 676                         NULL,   /* base_init */
 677                         NULL,   /* base_finalize */
 678                         tilda_terminal_class_init,      /* class_init */
 679                         NULL,   /* class_finalize */
 680                         NULL,   /* class_data */
 681                         sizeof (TildaTerminal),
 682                         0,              /* n_preallocs */
 683                         tilda_terminal_instance_init,   /* instance_init */
 684                 };
 685
 686                 type = g_type_register_static (G_TYPE_OBJECT,
 687                                                                            "TildaTerminalType",
 688                                                                            &info,
 689                                                                            0);
 690         }
 691
 692         return type;
 693 }
 694
 695 #if 0
 696
 697 int main (int argc, char *argv[])
 698 {
 699         GObject *tt;
 700         gint test_number = INT_MIN;
 701         gchar *test_string = NULL;
 702
 703         /* Initialize the GObject type system */
 704         g_type_init ();
 705         gtk_init (&argc, &argv);
 706
 707         tt = g_object_new (TILDA_TYPE_TERMINAL, "number", 10, NULL);
 708         g_object_get (G_OBJECT (tt), "number", &test_number, NULL);
 709         g_assert (test_number == 10);
 710
 711         g_object_unref (G_OBJECT (tt));
 712
 713         tt = g_object_new (TILDA_TYPE_TERMINAL, "number", 22, NULL);
 714         g_object_get (G_OBJECT (tt), "number", &test_number, NULL);
 715         g_assert (test_number == 22);
 716
 717         g_object_set (G_OBJECT (tt), "font", "hello I'm a font");
 718         g_object_set (G_OBJECT (tt), "font", "Bitstream Vera Sans Mono 13");
 719
 720         g_object_get (G_OBJECT (tt), "font", &test_string, NULL);
 721         g_print ("Read Font: %s\n", test_string);
 722         // NOTE: you MUST free the string!!!!
 723         g_free (test_string);
 724
 725         g_object_set (G_OBJECT (tt), "transparency-percent", 50);
 726
 727         g_object_unref (G_OBJECT (tt));
 728
 729         return 0;
 730 }
 731
 732 #endif
 733
 734 /* vim: set ts=4 sts=4 sw=4 noet tw=112: */