X-Git-Url: https://irasnyder.com/gitweb/?a=blobdiff_plain;f=tilda-window.c;h=1ac2a14ce3960eeaa8429fb57717c4de66ff499f;hb=1cb6e4d2f7d79497dd89828665de713a6175445c;hp=158d33a2ccd5b3856a87cabcf2d7c2af5fe5ec90;hpb=540a3b2f08673c226860cc6a08ed0f15a057da35;p=tilda-gobject.git diff --git a/tilda-window.c b/tilda-window.c index 158d33a..1ac2a14 100644 --- a/tilda-window.c +++ b/tilda-window.c @@ -1,10 +1,46 @@ +#include /* for strcmp() */ +#include /* for gdk_x11_window_set_user_time() */ + #include "tilda.h" +#include "tilda-controller.h" #include "tilda-window.h" #include "tilda-window-dbus-glue.h" +#include "tomboykeybinder.h" + +/** + * Find the TildaTerminal corresponding to the currently selected + * tab in self->notebook. This could go away if TildaTerminal were + * a proper subclass of GtkWidget. + */ +static TildaTerminal * +tilda_window_find_current_terminal (TildaWindow *self) +{ + debug_enter(); + debug_assert (TILDA_IS_WINDOW(self)); + + gint i; + TildaTerminal *ret; + gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK(self->notebook)); + GtkWidget *box = gtk_notebook_get_nth_page (GTK_NOTEBOOK(self->notebook), current_page); + + for (i=0; iterms->len; ++i) + { + ret = g_ptr_array_index (self->terms, i); + + if (ret->hbox == box) + return ret; + } + + debug_printf ("ERROR: unable to find current terminal!\n"); + return NULL; +} static gint -tilda_window_find_next_free_terminal_number (TildaWindow *tw) +tilda_window_find_next_free_terminal_number (TildaWindow *self) { + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + gint i, j; gboolean found; @@ -12,9 +48,9 @@ tilda_window_find_next_free_terminal_number (TildaWindow *tw) { found = FALSE; - for (j=0; jterms->len; ++j) + for (j=0; jterms->len; ++j) { - TildaTerminal *tt = g_ptr_array_index (tw->terms, j); + TildaTerminal *tt = g_ptr_array_index (self->terms, j); if (tt->number == i) { @@ -30,27 +66,48 @@ tilda_window_find_next_free_terminal_number (TildaWindow *tw) return 0; } -static gboolean -tilda_window_add_term (TildaWindow *tw) +/** + * Clean up and remove self completely from the program + * + * Should only be used by DBus... + */ +gboolean +tilda_window_close (TildaWindow *self) { + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + + tilda_controller_delete_window (TILDA_CONTROLLER(self->controller), self->number); + + return TRUE; +} + +gboolean +tilda_window_add_terminal (TildaWindow *self) +{ + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + gint number; TildaTerminal *tt; - number = tilda_window_find_next_free_terminal_number (tw); + number = tilda_window_find_next_free_terminal_number (self); tt = g_object_new (TILDA_TYPE_TERMINAL, "number", number, - "window-number", tw->number, - "parent-window", tw, + "parent-window", self, NULL); - g_ptr_array_add (tw->terms, tt); + g_ptr_array_add (self->terms, tt); GtkWidget *label = gtk_label_new ("Tilda"); - gint index = gtk_notebook_prepend_page (GTK_NOTEBOOK(tw->notebook), tt->hbox, label); - gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK(tw->notebook), tt->hbox, TRUE, TRUE, GTK_PACK_END); - //gtk_notebook_set_current_page (GTK_NOTEBOOK(tw->notebook), index); + gint index = gtk_notebook_prepend_page (GTK_NOTEBOOK(self->notebook), tt->hbox, label); + gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK(self->notebook), tt->hbox, TRUE, TRUE, GTK_PACK_END); + gtk_notebook_set_current_page (GTK_NOTEBOOK(self->notebook), index); + + if (gtk_notebook_get_n_pages (GTK_NOTEBOOK(self->notebook)) > 1) + gtk_notebook_set_show_tabs (GTK_NOTEBOOK(self->notebook), TRUE); - if (gtk_notebook_get_n_pages (GTK_NOTEBOOK(tw->notebook)) > 1) - gtk_notebook_set_show_tabs (GTK_NOTEBOOK(tw->notebook), TRUE); + /* Focus the VTE Terminal */ + gtk_widget_grab_focus (tt->vte_term); return TRUE; } @@ -62,43 +119,47 @@ tilda_window_add_term (TildaWindow *tw) * Return: TRUE on success, FALSE otherwise. */ gboolean -tilda_window_remove_term (TildaWindow *tw, gint terminal_number) +tilda_window_remove_terminal (TildaWindow *self, gint terminal_number) { + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + debug_assert (terminal_number >= 0); + gint i; - for (i=0; iterms->len; ++i) + for (i=0; iterms->len; ++i) { - TildaTerminal *tt = g_ptr_array_index (tw->terms, i); + TildaTerminal *tt = g_ptr_array_index (self->terms, i); if (tt->number == terminal_number) { - gint notebook_index = gtk_notebook_page_num (GTK_NOTEBOOK(tw->notebook), tt->hbox); + gint notebook_index = gtk_notebook_page_num (GTK_NOTEBOOK(self->notebook), tt->hbox); /* Make sure the index was valid */ if (notebook_index == -1) { - g_printerr ("DEBUG ERROR: Bad Notebook Tab\n"); + debug_printf ("ERROR: Bad Notebook Tab\n"); return FALSE; } /* Actually remove the terminal */ - gtk_notebook_remove_page (GTK_NOTEBOOK (tw->notebook), notebook_index); + gtk_notebook_remove_page (GTK_NOTEBOOK (self->notebook), notebook_index); /* We should hide the tabs if there is only one tab left */ - if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (tw->notebook)) == 1) - gtk_notebook_set_show_tabs (GTK_NOTEBOOK (tw->notebook), FALSE); - -#if 0 - // FIXME FIXME FIXME: need to actually do the stuff below - /* With no pages left, it's time to leave the program */ - if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (tw->notebook)) < 1) - gtk_main_quit (); -#endif + if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (self->notebook)) == 1) + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->notebook), FALSE); /* Remove the term from our lists, then free it */ - g_ptr_array_remove_fast (tw->terms, tt); + g_ptr_array_remove_fast (self->terms, tt); g_object_unref (G_OBJECT(tt)); + /* With no pages left, it's time to remove this window */ + if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (self->notebook)) < 1) + { + debug_printf ("no terminals left, closing window %d\n", self->number); + tilda_controller_delete_window (TILDA_CONTROLLER(self->controller), self->number); + } + /* Leave the loop, we're done */ break; } @@ -113,6 +174,9 @@ tilda_window_remove_term (TildaWindow *tw, gint terminal_number) static void tilda_window_setup_real_transparency (TildaWindow *self) { + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + GdkScreen *screen; GdkColormap *colormap; @@ -131,30 +195,85 @@ tilda_window_setup_real_transparency (TildaWindow *self) self->have_real_transparency = FALSE; } +/* Center the given TildaWindow in the horizontal axis */ +static void +tilda_window_center_horizontally (TildaWindow *self) +{ + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + + const gint screen_center = gdk_screen_width() / 2; + const gint tilda_center = self->width / 2; + const gint center_coord = screen_center - tilda_center; + + g_object_set (G_OBJECT(self), "x-position", center_coord, NULL); +} + +/* Center the given TildaWindow in the vertical axis */ +static void +tilda_window_center_vertically (TildaWindow *self) +{ + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + + const gint screen_center = gdk_screen_height() / 2; + const gint tilda_center = self->height / 2; + const gint center_coord = screen_center - tilda_center; + + g_object_set (G_OBJECT(self), "y-position", center_coord, NULL); +} + static void tilda_window_keybinding_cb (const gchar *keystr, gpointer data) { + debug_enter (); + debug_assert (TILDA_IS_WINDOW(data)); + TildaWindow *self = TILDA_WINDOW(data); - g_print ("tilda_window_keybinding_cb() called! -- window %d\n", self->number); + TildaTerminal *tt; - // FIXME: this doesn't handle animation! + /* This call sets the X11 window property _NET_WM_USER_TIME, which GTK+ normally + * sets for us. However, because this callback is activated via a global keybinding, + * we see the event before GDK / GTK+ does. Therefore, to get the focus, we must + * set the property ourselves. */ + gdk_x11_window_set_user_time (GTK_WIDGET(self->window)->window, + tomboy_keybinder_get_current_event_time()); switch (self->state) { - case WINDOW_UP: - /* Pull Down */ - tomboy_window_present_hardcore (GTK_WINDOW(self->window)); + case WINDOW_UP: /* Pull the window up */ + + /* Bugfix: having this here keeps the tilda window from being + * hidden if you turn off "stick", pull it down on workspace 1, + * switch to workspace 2, then pull it up and back down. Without + * this, something in metacity (at least) hides the window. Stupid. */ + gtk_window_deiconify (GTK_WINDOW(self->window)); + + /* Re-set the window properties that do not linger after hiding the + * window. I know this looks stupid, but it keeps all of the state- + * changing code in the place it belongs: the property-setting code. */ + g_object_set (G_OBJECT(self), + "keep-above", self->keep_above, + "stick", self->stick, + NULL); + gtk_widget_show (GTK_WIDGET(self->window)); + + /* Focusing the term here works perfectly, near as I can tell */ + tt = tilda_window_find_current_terminal (self); + gtk_widget_grab_focus (GTK_WIDGET(tt->vte_term)); + self->state = WINDOW_DOWN; break; - case WINDOW_DOWN: - /* Pull Up */ + case WINDOW_DOWN: /* Pull the window up */ + gtk_widget_hide (GTK_WIDGET(self->window)); + self->state = WINDOW_UP; break; default: - g_printerr ("FIXME: the window is in a bad state!\n"); + debug_printf ("ERROR: Window is in a bad state!\n"); /* Pretend we're down, for good measure.... */ self->state = WINDOW_DOWN; @@ -170,6 +289,9 @@ tilda_window_keybinding_cb (const gchar *keystr, gpointer data) static gboolean tilda_window_try_to_bind_key (TildaWindow *self, const gchar *new_key) { + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + gboolean ret = FALSE; /* Make sure the new key is not null in any way */ @@ -178,7 +300,7 @@ tilda_window_try_to_bind_key (TildaWindow *self, const gchar *new_key) /* Unbind if we were set */ if (self->key) - tomboy_keybinder_unbind (self->key, tilda_window_keybinding_cb, self); + tomboy_keybinder_unbind (self->key, tilda_window_keybinding_cb); ret = tomboy_keybinder_bind (new_key, tilda_window_keybinding_cb, self); @@ -190,7 +312,7 @@ tilda_window_try_to_bind_key (TildaWindow *self, const gchar *new_key) return TRUE; } - g_printerr ("Keybinding unsuccessful. Reverting to original key\n"); + g_printerr (_("Bind key '%s' failed. Reverting to original keybinding\n"), self->key); /* Not successful, so rebind the old key, and return FALSE */ if (self->key != NULL && strcmp("",self->key) != 0) @@ -199,22 +321,25 @@ tilda_window_try_to_bind_key (TildaWindow *self, const gchar *new_key) /* Check that it went ok */ if (!ret) - g_printerr ("Unable to bind original key as well! Oh shit...\n"); + g_printerr (_("Unable to re-bind original key '%s'. Oh shit...\n"), self->key); } else - g_printerr ("No original key to revert to!\n"); + g_printerr (_("No original key to revert to!\n")); return FALSE; } static void -tilda_window_dbus_register_object (TildaWindow *tw) +tilda_window_dbus_register_object (TildaWindow *self) { + debug_enter (); + debug_assert (TILDA_IS_WINDOW(self)); + gchar *object_path; // Register this object with DBus - object_path = g_strdup_printf ("/net/sourceforge/Tilda/Window%d", tw->number); - dbus_g_connection_register_g_object (dbus_connection, object_path, G_OBJECT(tw)); + object_path = g_strdup_printf ("/net/sourceforge/Tilda/Window%d", self->number); + dbus_g_connection_register_g_object (dbus_connection, object_path, G_OBJECT(self)); g_free (object_path); } @@ -226,13 +351,12 @@ static GObjectClass *parent_class = NULL; enum tilda_window_properties { TILDA_WINDOW_NUMBER = 1, + TILDA_WINDOW_CONTROLLER, TILDA_WINDOW_KEY, - TILDA_WINDOW_MIN_HEIGHT, - TILDA_WINDOW_MIN_WIDTH, - TILDA_WINDOW_MAX_HEIGHT, - TILDA_WINDOW_MAX_WIDTH, + TILDA_WINDOW_HEIGHT, + TILDA_WINDOW_WIDTH, TILDA_WINDOW_X_POSITION, TILDA_WINDOW_Y_POSITION, @@ -241,8 +365,8 @@ enum tilda_window_properties { TILDA_WINDOW_ANIMATION_DELAY, TILDA_WINDOW_KEEP_ABOVE, - TILDA_WINDOW_SHOW_IN_TASKBAR, - TILDA_WINDOW_PINNED, + TILDA_WINDOW_SKIP_TASKBAR_HINT, + TILDA_WINDOW_STICK, TILDA_WINDOW_HIDDEN_AT_START, TILDA_WINDOW_CENTERED_HORIZONTALLY, TILDA_WINDOW_CENTERED_VERTICALLY, @@ -254,6 +378,8 @@ static void tilda_window_instance_init (GTypeInstance *instance, gpointer g_class) { + debug_enter (); + TildaWindow *self = (TildaWindow *) instance; self->dispose_has_run = FALSE; @@ -264,6 +390,7 @@ tilda_window_instance_init (GTypeInstance *instance, /* Somewhat of a "poison" value, incase we don't set this */ self->number = 0xdeadbeef; + self->controller = NULL; self->state = WINDOW_UP; } @@ -280,94 +407,104 @@ tilda_window_set_property (GObject *object, case TILDA_WINDOW_NUMBER: self->number = g_value_get_int (value); - g_print ("window number: %d\n", self->number); + debug_printf ("window number: %d\n", self->number); break; - case TILDA_WINDOW_KEY: - tilda_window_try_to_bind_key (self, g_value_get_string (value)); - g_print ("window key: %s\n", self->key); - break; - - case TILDA_WINDOW_MIN_HEIGHT: - self->min_height = g_value_get_int (value); - g_print ("window min height: %d\n", self->min_height); + case TILDA_WINDOW_CONTROLLER: + self->controller = g_value_get_pointer (value); + debug_printf ("window controller: 0x%x\n", self->controller); break; - case TILDA_WINDOW_MIN_WIDTH: - self->min_width = g_value_get_int (value); - g_print ("window min width: %d\n", self->min_width); + case TILDA_WINDOW_KEY: + tilda_window_try_to_bind_key (self, g_value_get_string (value)); + debug_printf ("window key %s\n", self->key); break; - case TILDA_WINDOW_MAX_HEIGHT: - self->max_height = g_value_get_int (value); - g_print ("window max height: %d\n", self->max_height); + case TILDA_WINDOW_HEIGHT: + self->height = g_value_get_int (value); + gtk_widget_set_size_request (self->window, self->width, self->height); + gtk_window_resize (GTK_WINDOW(self->window), self->width, self->height); + debug_printf ("window height: %d\n", self->height); break; - case TILDA_WINDOW_MAX_WIDTH: - self->max_width = g_value_get_int (value); - g_print ("window max width: %d\n", self->max_width); + case TILDA_WINDOW_WIDTH: + self->width = g_value_get_int (value); + gtk_widget_set_size_request (self->window, self->width, self->height); + gtk_window_resize (GTK_WINDOW(self->window), self->width, self->height); + debug_printf ("window width: %d\n", self->width); break; case TILDA_WINDOW_X_POSITION: self->x_position = g_value_get_int (value); gtk_window_move (GTK_WINDOW(self->window), self->x_position, self->y_position); - g_print ("window x position: %d\n", self->x_position); + debug_printf ("window x position: %d\n", self->x_position); break; case TILDA_WINDOW_Y_POSITION: self->y_position = g_value_get_int (value); gtk_window_move (GTK_WINDOW(self->window), self->x_position, self->y_position); - g_print ("window y position: %d\n", self->y_position); + debug_printf ("window y position: %d\n", self->y_position); break; case TILDA_WINDOW_TAB_POSITION: self->tab_position = g_value_get_int (value); - g_print ("window tab position: %d\n", self->tab_position); + gtk_notebook_set_tab_pos (GTK_NOTEBOOK(self->notebook), self->tab_position); + debug_printf ("window tab position: %d\n", self->tab_position); break; case TILDA_WINDOW_ANIMATION_ORIENTATION: self->animation_orientation = g_value_get_int (value); - g_print ("window animation orientation: %d\n", self->animation_orientation); + debug_printf ("window animation orientation: %d\n", self->animation_orientation); break; case TILDA_WINDOW_ANIMATION_DELAY: self->animation_delay = g_value_get_int (value); - g_print ("window animation delay: %d\n", self->animation_delay); + debug_printf ("window animation delay: %d\n", self->animation_delay); break; case TILDA_WINDOW_KEEP_ABOVE: self->keep_above = g_value_get_boolean (value); - g_print ("window keep above: %d\n", self->keep_above); + gtk_window_set_keep_above (GTK_WINDOW(self->window), self->keep_above); + debug_printf ("window keep above: %d\n", self->keep_above); break; - case TILDA_WINDOW_SHOW_IN_TASKBAR: - self->show_in_taskbar = g_value_get_boolean (value); - g_print ("window show in taskbar: %d\n", self->show_in_taskbar); + case TILDA_WINDOW_SKIP_TASKBAR_HINT: + self->skip_taskbar_hint = g_value_get_boolean (value); + gtk_window_set_skip_taskbar_hint (GTK_WINDOW(self->window), self->skip_taskbar_hint); + debug_printf ("window skip taskbar hint: %d\n", self->skip_taskbar_hint); break; - case TILDA_WINDOW_PINNED: - self->pinned = g_value_get_boolean (value); - g_print ("window pinned: %d\n", self->pinned); + case TILDA_WINDOW_STICK: + self->stick = g_value_get_boolean (value); + + /* This is moderately ugly, but GTK+ does it this way... */ + self->stick ? gtk_window_stick (GTK_WINDOW(self->window)) + : gtk_window_unstick (GTK_WINDOW(self->window)); + debug_printf ("window stick: %d\n", self->stick); break; case TILDA_WINDOW_HIDDEN_AT_START: self->hidden_at_start = g_value_get_boolean (value); - g_print ("window hidden at start: %d\n", self->hidden_at_start); + debug_printf ("window hidden at start: %d\n", self->hidden_at_start); break; case TILDA_WINDOW_CENTERED_HORIZONTALLY: self->centered_horizontally = g_value_get_boolean (value); - g_print ("window centered horizontally: %d\n", self->centered_horizontally); + if (self->centered_horizontally) + tilda_window_center_horizontally (self); + debug_printf ("window centered horizontally: %d\n", self->centered_horizontally); break; case TILDA_WINDOW_CENTERED_VERTICALLY: self->centered_vertically = g_value_get_boolean (value); - g_print ("window centered vertically: %d\n", self->centered_vertically); + if (self->centered_vertically) + tilda_window_center_vertically (self); + debug_printf ("window centered vertically: %d\n", self->centered_vertically); break; case TILDA_WINDOW_HAVE_REAL_TRANSPARENCY: self->have_real_transparency = g_value_get_boolean (value); - g_print ("window have real transp: %d\n", self->have_real_transparency); + debug_printf ("window have real transp: %d\n", self->have_real_transparency); break; default: @@ -391,24 +528,20 @@ tilda_window_get_property (GObject *object, g_value_set_int (value, self->number); break; - case TILDA_WINDOW_KEY: - g_value_set_string (value, self->key); - break; - - case TILDA_WINDOW_MIN_HEIGHT: - g_value_set_int (value, self->min_height); + case TILDA_WINDOW_CONTROLLER: + g_value_set_pointer (value, self->controller); break; - case TILDA_WINDOW_MIN_WIDTH: - g_value_set_int (value, self->min_width); + case TILDA_WINDOW_KEY: + g_value_set_string (value, self->key); break; - case TILDA_WINDOW_MAX_HEIGHT: - g_value_set_int (value, self->max_height); + case TILDA_WINDOW_HEIGHT: + g_value_set_int (value, self->height); break; - case TILDA_WINDOW_MAX_WIDTH: - g_value_set_int (value, self->max_width); + case TILDA_WINDOW_WIDTH: + g_value_set_int (value, self->width); break; case TILDA_WINDOW_X_POSITION: @@ -435,12 +568,12 @@ tilda_window_get_property (GObject *object, g_value_set_boolean (value, self->keep_above); break; - case TILDA_WINDOW_SHOW_IN_TASKBAR: - g_value_set_boolean (value, self->show_in_taskbar); + case TILDA_WINDOW_SKIP_TASKBAR_HINT: + g_value_set_boolean (value, self->skip_taskbar_hint); break; - case TILDA_WINDOW_PINNED: - g_value_set_boolean (value, self->pinned); + case TILDA_WINDOW_STICK: + g_value_set_boolean (value, self->stick); break; case TILDA_WINDOW_HIDDEN_AT_START: @@ -471,6 +604,8 @@ tilda_window_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { + debug_enter (); + GObject *obj; TildaWindow *self; @@ -483,8 +618,7 @@ tilda_window_constructor (GType type, /* Do other stuff here. The object is ready to go now, and all * ctor properties have been set. - * - * TODO: This is the place to do DBus-init */ + */ self = TILDA_WINDOW(obj); /* Register this object with DBus */ @@ -494,29 +628,42 @@ tilda_window_constructor (GType type, tilda_window_setup_real_transparency (self); gtk_container_add (GTK_CONTAINER(self->window), self->notebook); + g_object_set (G_OBJECT(self->notebook), "can-focus", FALSE, NULL); gtk_widget_show (self->notebook); // FIXME: Remove these, and replace with reads from the config system - g_object_set (G_OBJECT(self), "key", "F2", NULL); + gchar *mykey = g_strdup_printf ("F%d", self->number+3); // TERRIBLE HACK + g_object_set (G_OBJECT(self), "key", mykey, NULL); + g_free (mykey); g_object_set (G_OBJECT(self), "x-position", 0, "y-position", 0, NULL); + g_object_set (G_OBJECT(self), "height", 400, "width", 1680, NULL); + g_object_set (G_OBJECT(self), "keep-above", TRUE, "stick", TRUE, NULL); + g_object_set (G_OBJECT(self), "hidden-at-start", FALSE, NULL); - tilda_window_add_term (self); - tilda_window_add_term (self); - gtk_widget_show_all (self->window); - self->state = WINDOW_DOWN; + gtk_window_set_decorated (GTK_WINDOW(self->window), FALSE); - return obj; -} + // FIXME: It should be configurable how many terms we add at startup + tilda_window_add_terminal (self); + tilda_window_add_terminal (self); -static void -my_unref (gpointer data, gpointer user_data) -{ - g_object_unref (G_OBJECT(data)); + /* Show us if we're ready. If not, just remain hidden. All sub-widgets must + * be gtk_widget_show()n by this point. */ + if (!self->hidden_at_start) + { + gtk_widget_show (self->window); + self->state = WINDOW_DOWN; + } + else + self->state = WINDOW_UP; + + return obj; } static void tilda_window_dispose (GObject *obj) { + debug_enter (); + TildaWindow *self = (TildaWindow *) obj; /* We don't want to run dispose twice, so just return immediately */ @@ -532,9 +679,13 @@ tilda_window_dispose (GObject *obj) * NOTE: See the following for how to deal with GtkObject-derived things: * http://library.gnome.org/devel/gtk/unstable/GtkObject.html */ - g_ptr_array_foreach (self->terms, my_unref, NULL); + g_ptr_array_foreach (self->terms, g_object_unref, NULL); gtk_widget_destroy (self->window); + /* Unbind if we were set */ + if (self->key) + tomboy_keybinder_unbind (self->key, tilda_window_keybinding_cb); + /* Chain up to the parent class */ G_OBJECT_CLASS (parent_class)->dispose (obj); } @@ -542,6 +693,8 @@ tilda_window_dispose (GObject *obj) static void tilda_window_finalize (GObject *obj) { + debug_enter (); + TildaWindow *self = (TildaWindow *) obj; /* @@ -560,6 +713,8 @@ static void tilda_window_class_init (gpointer g_class, gpointer g_class_data) { + debug_enter (); + GObjectClass *gobject_class = G_OBJECT_CLASS (g_class); TildaWindowClass *klass = TILDA_WINDOW_CLASS (g_class); GParamSpec *pspec; @@ -575,8 +730,8 @@ tilda_window_class_init (gpointer g_class, /* Install all of the properties */ pspec = g_param_spec_int ("number", - "Window number", - "Set window's number", + _("Window number"), + NULL, 0, // min value INT_MAX, // max value 0, // def value @@ -586,8 +741,17 @@ tilda_window_class_init (gpointer g_class, TILDA_WINDOW_NUMBER, pspec); + pspec = g_param_spec_pointer ("controller", + _("Pointer to window's controlling TildaController"), + NULL, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE); + + g_object_class_install_property (gobject_class, + TILDA_WINDOW_CONTROLLER, + pspec); + pspec = g_param_spec_string ("key", - "Window's drop-down keybinding", + _("Window's drop-down keybinding"), NULL, NULL, G_PARAM_READWRITE); @@ -596,8 +760,8 @@ tilda_window_class_init (gpointer g_class, TILDA_WINDOW_KEY, pspec); - pspec = g_param_spec_int ("min-height", - "Window's minimum height", + pspec = g_param_spec_int ("height", + _("Window's height"), NULL, 0, INT_MAX, @@ -605,11 +769,11 @@ tilda_window_class_init (gpointer g_class, G_PARAM_READWRITE); g_object_class_install_property (gobject_class, - TILDA_WINDOW_MIN_HEIGHT, + TILDA_WINDOW_HEIGHT, pspec); - pspec = g_param_spec_int ("min-width", - "Window's minimum width", + pspec = g_param_spec_int ("width", + _("Window's width"), NULL, 0, INT_MAX, @@ -617,35 +781,11 @@ tilda_window_class_init (gpointer g_class, G_PARAM_READWRITE); g_object_class_install_property (gobject_class, - TILDA_WINDOW_MIN_WIDTH, - pspec); - - pspec = g_param_spec_int ("max-height", - "Window's maximum height", - NULL, - 0, - INT_MAX, - 0, - G_PARAM_READWRITE); - - g_object_class_install_property (gobject_class, - TILDA_WINDOW_MAX_HEIGHT, - pspec); - - pspec = g_param_spec_int ("max-width", - "Window's maximum width", - NULL, - 0, - INT_MAX, - 0, - G_PARAM_READWRITE); - - g_object_class_install_property (gobject_class, - TILDA_WINDOW_MAX_WIDTH, + TILDA_WINDOW_WIDTH, pspec); pspec = g_param_spec_int ("x-position", - "Window's x position", + _("Window's x position"), NULL, 0, INT_MAX, @@ -657,7 +797,7 @@ tilda_window_class_init (gpointer g_class, pspec); pspec = g_param_spec_int ("y-position", - "Window's y position", + _("Window's y position"), NULL, 0, INT_MAX, @@ -669,7 +809,7 @@ tilda_window_class_init (gpointer g_class, pspec); pspec = g_param_spec_int ("tab-position", - "Window's tab position", + _("Position of window's tab bar"), NULL, 0, INT_MAX, @@ -681,7 +821,7 @@ tilda_window_class_init (gpointer g_class, pspec); pspec = g_param_spec_int ("animation-orientation", - "Window's animation orientation", + _("Window's animation orientation"), NULL, 0, INT_MAX, @@ -693,7 +833,7 @@ tilda_window_class_init (gpointer g_class, pspec); pspec = g_param_spec_int ("animation-delay", - "Amount of time in milliseconds between animation intervals", + _("Amount of time in milliseconds between animation intervals"), NULL, 0, INT_MAX, @@ -705,7 +845,7 @@ tilda_window_class_init (gpointer g_class, pspec); pspec = g_param_spec_boolean ("keep-above", - "Keep this window above all others", + _("Keep this window above all others"), NULL, FALSE, G_PARAM_READWRITE); @@ -714,28 +854,28 @@ tilda_window_class_init (gpointer g_class, TILDA_WINDOW_KEEP_ABOVE, pspec); - pspec = g_param_spec_boolean ("show-in-taskbar", - "Show this window in the taskbar", + pspec = g_param_spec_boolean ("skip-taskbar-hint", + _("Hide this window in the taskbar if TRUE"), NULL, FALSE, G_PARAM_READWRITE); g_object_class_install_property (gobject_class, - TILDA_WINDOW_SHOW_IN_TASKBAR, + TILDA_WINDOW_SKIP_TASKBAR_HINT, pspec); - pspec = g_param_spec_boolean ("pinned", - "Display this window on all workspaces", + pspec = g_param_spec_boolean ("stick", + _("Display this window on all workspaces"), NULL, FALSE, G_PARAM_READWRITE); g_object_class_install_property (gobject_class, - TILDA_WINDOW_PINNED, + TILDA_WINDOW_STICK, pspec); pspec = g_param_spec_boolean ("hidden-at-start", - "Hide the window when it is first created", + _("Hide the window when it is first created"), NULL, FALSE, G_PARAM_READWRITE); @@ -745,7 +885,7 @@ tilda_window_class_init (gpointer g_class, pspec); pspec = g_param_spec_boolean ("centered-horizontally", - "Center the window horizontally", + _("Center the window horizontally"), NULL, FALSE, G_PARAM_READWRITE); @@ -755,7 +895,7 @@ tilda_window_class_init (gpointer g_class, pspec); pspec = g_param_spec_boolean ("centered-vertically", - "Center the window vertically", + _("Center the window vertically"), NULL, FALSE, G_PARAM_READWRITE); @@ -771,8 +911,6 @@ tilda_window_class_init (gpointer g_class, TILDA_WINDOW_HAVE_REAL_TRANSPARENCY, pspec); - /* TODO: more properties */ - /* Hook the TildaWindow type into DBus */ dbus_g_object_type_install_info (tilda_window_get_type(), &dbus_glib_tilda_window_object_info); } @@ -805,34 +943,4 @@ tilda_window_get_type (void) return type; } -#if 0 - -int main (int argc, char *argv[]) -{ - GObject *tw; - gint test_number = INT_MIN; - - /* Initialize the GObject type system */ - g_type_init (); - gtk_init (&argc, &argv); - - tw = g_object_new (TILDA_TYPE_WINDOW, "number", 10, NULL); - g_object_get (G_OBJECT (tw), "number", &test_number, NULL); - g_assert (test_number == 10); - - g_object_unref (G_OBJECT (tw)); - - tw = g_object_new (TILDA_TYPE_WINDOW, "number", 22, NULL); - g_object_get (G_OBJECT (tw), "number", &test_number, NULL); - g_assert (test_number == 22); - - gtk_main (); - - g_object_unref (G_OBJECT (tw)); - - return 0; -} - -#endif - /* vim: set ts=4 sts=4 sw=4 noet tw=112: */