attempt to get signals from tray icon using LibGObject

needs refactoring !

src/chrome/content/overlay.js

@@ -1,11 +1,24 @@
 /* -*- Mode: js2; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 
+// TODO: Components.utils.import("resource://gre/modules/Services.jsm");
 Components.utils.import("resource://moztray/commons.js");
 Components.utils.import("resource://moztray/LibGtkStatusIcon.js");
+Components.utils.import("resource://moztray/LibGObject.js");
 
 const MOZT_ICON_DIR = "chrome/skin/";
 const MOZT_ICON_SUFFIX = "32.png";
 
+
+var mozt_hideWinCb;
+/* NOTE: arguments come obviously from the GCallbackFunction definition:
+ * [gpointer, guint, gpointer]
+ */
+var mozt_hideWinJs = function(aInstance, aTimestamp, aUserData) {
+  try {
+    alert("Hide");
+  } catch(e) {Cu.reportError(ex);}
+};
+
 mozt.Main = {
 
   onLoad: function() {
@@ -29,6 +42,15 @@ mozt.Main = {
     var icon_filename = MOZT_ICON_DIR + mozApp + MOZT_ICON_SUFFIX;
     LibGtkStatusIcon.gtk_status_icon_set_from_file(this.tray_icon,
                                                    icon_filename);
+        // gtk_status_icon_set_tooltip(tray_icon,
+        //                             "Example Tray Icon");
+        // gtk_status_icon_set_visible(tray_icon, TRUE);
+
+    mozt_hideWinCb = LibGObject.GCallbackFunction(mozt_hideWinJs);
+
+    LibGObject.g_signal_connect(this.tray_icon, "activate",
+                                mozt_hideWinCb, null);
+
 
     mozt.Debug.dump('Moztray LOADED !');
     this.initialized = true;

src/modules/LibGObject.js

@@ -0,0 +1,160 @@
+/* -*- Mode: javascript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ *	 Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is messagingmenu-extension
+ *
+ * The Initial Developer of the Original Code is
+ * Mozilla Messaging, Ltd.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *    Mike Conley <mconley@mozillamessaging.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ * 
+ * ***** END LICENSE BLOCK ***** */
+
+var EXPORTED_SYMBOLS = ["LibGObject"];
+
+const LIB_GOBJECT = "libgobject-2.0.so.0";
+
+const Cu = Components.utils;
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+
+Cu.import("resource://gre/modules/ctypes.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyGetter(this, "libgobject", function() {
+  var libgobject = ctypes.open(LIB_GOBJECT);
+  if (!libgobject)
+    throw "libgobject is unavailable";
+
+  return libgobject;
+});
+
+XPCOMUtils.defineLazyGetter(this, "GCallback", function() {
+  return ctypes.voidptr_t;
+});
+
+XPCOMUtils.defineLazyGetter(this, "gpointer", function() {
+  return ctypes.voidptr_t;
+});
+
+XPCOMUtils.defineLazyGetter(this, "gulong", function() {
+  return ctypes.unsigned_long;
+});
+
+XPCOMUtils.defineLazyGetter(this, "guint", function() {
+  return ctypes.unsigned_int;
+});
+
+XPCOMUtils.defineLazyGetter(this, "guint32", function() {
+  return ctypes.unsigned_int;
+});
+
+XPCOMUtils.defineLazyGetter(this, "gint", function() {
+  return ctypes.int;
+});
+
+XPCOMUtils.defineLazyGetter(this, "gchar", function() {
+  return ctypes.unsigned_char;
+});
+
+XPCOMUtils.defineLazyGetter(this, "gboolean", function() {
+  return gint;
+});
+
+XPCOMUtils.defineLazyGetter(this, "GConnectFlags", function() {
+  return guint;
+});
+
+XPCOMUtils.defineLazyGetter(this, "GClosureNotify", function() {
+  return gpointer;
+});
+
+XPCOMUtils.defineLazyGetter(this, "GCallbackFunction", function() {
+  var GCallbackFunction =
+    ctypes.FunctionType(ctypes.default_abi,
+                        ctypes.void_t,
+                        [gpointer,
+                         guint,
+                         gpointer]).ptr;
+  if (!GCallbackFunction)
+    throw "GCallbackFunction is unavailable";
+
+  return GCallbackFunction;
+});
+
+XPCOMUtils.defineLazyGetter(this, "g_signal_connect_data", function() {
+  var g_signal_connect_data =
+    libgobject.declare("g_signal_connect_data",
+                   ctypes.default_abi,
+                   gulong,
+                   gpointer,    // instance
+                   gchar.ptr,   // detailed_signal
+                   GCallback,   // handler
+                   gpointer,    // data 
+                   GClosureNotify, // NULL
+                   GConnectFlags); // 0
+
+  if (!g_signal_connect_data)
+    throw "g_signal_connect_data is unavailable";
+
+  return g_signal_connect_data;
+});
+
+XPCOMUtils.defineLazyGetter(this, "g_object_unref", function() {
+  var g_object_unref =
+    libgobject.declare("g_object_unref",
+                   ctypes.default_abi,
+                   ctypes.void_t,
+                   gpointer);
+
+  if (!g_object_unref)
+    throw "g_object_unref is unavailable";
+
+  return g_object_unref;
+});
+
+var LibGObject = {
+  GCallback: GCallback,
+  GCallbackFunction: GCallbackFunction,
+  gpointer: gpointer,
+  gulong: gulong,
+  guint: guint,
+  guint32: guint32,
+  gint: gint,
+  gchar: gchar,
+  gboolean: gboolean,
+  GConnectFlags: GConnectFlags,
+  GClosureNotify: GClosureNotify,
+  g_object_unref: g_object_unref,
+
+  g_signal_connect: function(instance, detailed_signal, handler, data) {
+      return g_signal_connect_data(instance, detailed_signal,
+                                   handler, data, null, 0);
+  }
+};

testing/Makefile

@@ -1,4 +1,17 @@
 includes := $(shell pkg-config --libs --cflags gtk+-2.0)
 
-all:
-	gcc $(includes) -o gtk_icon_example gkt_icon_example.c
+.PHONY: all
+all: gtk_icon_example trayicon hide
+
+.PHONY: clean
+clean:
+	rm gtk_icon_example trayicon hide
+
+gtk_icon_example: gtk_icon_example.c
+	gcc $(includes) -o gtk_icon_example gtk_icon_example.c
+
+trayicon: trayicon.c
+	gcc $(includes) -o trayicon trayicon.c
+
+hide: hide.c
+	gcc $(includes) -o hide hide.c

testing/gtk_icon_example.c

@@ -1,3 +1,5 @@
+#include <stdio.h>
+
 #include <gtk/gtk.h>
 #include "firefox.xpm"
 
@@ -37,11 +39,51 @@ static GtkStatusIcon *create_tray_icon() {
         return tray_icon;
 }
 
+/*
+- Hide/Show window to avoid minimizing it to the task bar (yes, use gtk_widget_hide() and gtk_widget_show()) when the user clicks on the system tray icon
+- Listen to the "window-state-event" (GObject's signal) to detect when minimizing and, instead of doing that, hide the window (ie, "minimize to the tray").
+*/
+
+/* This callback quits the program */
+gint delete_event( GtkWidget *widget,
+                   GdkEvent *event,
+                   gpointer
+                   data )
+{
+  gtk_main_quit ();
+  return FALSE;
+}
+
+static void winShowHide(GtkMenuItem *item, gpointer window) 
+{
+  /* GdkWindow * tl_window = gdk_window_get_toplevel((GdkWindow*)window); */
+
+  /* GdkWindowState ws = gdk_window_get_state((GdkWindow*)tl_window); */
+  /* printf("GdkWindowState: %d", ws); */
+
+  gdk_window_hide(window->window);
+  /* gtk_widget_show(GTK_WIDGET(window)); */
+  /* gtk_widget_hide(GTK_WIDGET(window)); */
+}
+
 int main(int argc, char **argv) {
         GtkStatusIcon *tray_icon;
 
         gtk_init(&argc, &argv);
         tray_icon = create_tray_icon();
+    
+    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title (GTK_WINDOW (window), "GtkStatusIcon Example");
+    gtk_widget_set_size_request (window, 200, -1);
+
+    /* Set a handler for delete_event that immediately exits GTK. */
+    g_signal_connect (G_OBJECT (window), "delete_event",
+                      G_CALLBACK (delete_event), NULL);
+
+    g_signal_connect(G_OBJECT(tray_icon), "activate", G_CALLBACK(winShowHide), window);
+
+    gtk_widget_show_all (window);
+
         gtk_main();
 
         return 0;

testing/hide.c

@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <gtk/gtk.h>
+
+
+int main(int argc, char **argv)
+{
+    GtkWidget *window;
+    GtkWidget *vbox;
+    GtkWidget *button;
+
+    gtk_init(&argc, &argv);
+
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_container_set_border_width(GTK_CONTAINER(window), 10);
+    g_signal_connect(window, "delete_event", (GCallback)gtk_main_quit, 0);
+
+    vbox = gtk_vbox_new(TRUE, 0);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+
+    button = gtk_button_new_with_label("Hide");
+    gtk_box_pack_start(GTK_BOX(vbox), button, TRUE,TRUE, 0);
+    g_signal_connect_swapped(button, "clicked",
+    (GCallback)gtk_widget_hide, window);
+
+    button = gtk_button_new_from_stock(GTK_STOCK_QUIT);
+    gtk_box_pack_start(GTK_BOX(vbox), button, TRUE,TRUE, 0);
+    g_signal_connect(button, "clicked", (GCallback)gtk_main_quit, 0);
+
+    gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
+
+    // gtk_window_set_default_size(GTK_WINDOW(window),500,500);
+
+    // gtk_window_stick(GTK_WINDOW(window)); /* on all desktops or not */
+
+    gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
+
+    //gtk_window_set_keep_below(GTK_WINDOW(window),TRUE);
+
+    gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
+    gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
+
+    gtk_window_move(GTK_WINDOW(window), 100, 100);
+
+    // gtk_window_set_opacity(GTK_WINDOW(window), 0); /* not working hmmmm*/
+
+    gtk_widget_show_all(window);
+
+    gtk_main();
+
+    return (EXIT_SUCCESS);
+}

testing/trayicon.c

@@ -0,0 +1,109 @@
+// http://www.codeproject.com/KB/cross-platform/GTKTrayIcon.aspx
+#include <gtk/gtk.h>
+
+static void trayView(GtkMenuItem *item, gpointer user_data);
+static void trayExit(GtkMenuItem *item, gpointer user_data);
+static void trayIconActivated(GObject *trayIcon, gpointer data);
+static void trayIconPopup(GtkStatusIcon *status_icon, guint button, guint32 activate_time, gpointer popUpMenu);
+static void destroy (GtkWidget*, gpointer);
+static gboolean delete_event (GtkWidget*, GdkEvent*, gpointer);
+static gboolean window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer user_data);
+
+int main(int argc, char *argv[])
+{
+    gtk_init (&argc, &argv);
+    
+    GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title (GTK_WINDOW (window), "GtkStatusIcon Example");
+    gtk_widget_set_size_request (window, 200, -1);
+    
+    //set try icon file
+    GtkStatusIcon *trayIcon  = gtk_status_icon_new_from_file ("firefox32.png");
+    //set popup menu for tray icon
+    GtkWidget *menu, *menuItemView, *menuItemExit;
+    menu = gtk_menu_new();
+    menuItemView = gtk_menu_item_new_with_label ("View");
+    menuItemExit = gtk_menu_item_new_with_label ("Exit");
+    g_signal_connect (G_OBJECT (menuItemView), "activate", G_CALLBACK (trayView), window);
+    g_signal_connect (G_OBJECT (menuItemExit), "activate", G_CALLBACK (trayExit), NULL);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuItemView);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuItemExit);
+    gtk_widget_show_all (menu);
+    //set tooltip
+    gtk_status_icon_set_tooltip (trayIcon, "MsgWatcherGTK");
+    //connect handlers for mouse events
+    g_signal_connect(GTK_STATUS_ICON (trayIcon), "activate", GTK_SIGNAL_FUNC (trayIconActivated), window);
+    g_signal_connect(GTK_STATUS_ICON (trayIcon), "popup-menu", GTK_SIGNAL_FUNC (trayIconPopup), menu);
+    gtk_status_icon_set_visible(trayIcon, FALSE); //set icon initially invisible
+    
+    
+    GtkWidget *menuBar, *menuItemTopLvl, *mainMenu, *mainMenuItemExit;
+    menuBar = gtk_menu_bar_new ();
+    menuItemTopLvl = gtk_menu_item_new_with_label ("Menu");
+    gtk_menu_shell_append (GTK_MENU_SHELL (menuBar), menuItemTopLvl);
+    
+    mainMenu = gtk_menu_new ();
+    gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItemTopLvl), mainMenu);
+    mainMenuItemExit = gtk_menu_item_new_with_label ("Quit");
+    g_signal_connect (G_OBJECT (mainMenuItemExit), "activate", G_CALLBACK (trayExit), NULL);
+    gtk_menu_shell_append (GTK_MENU_SHELL (mainMenu), mainMenuItemExit);
+    
+    g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL);
+    g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), trayIcon);
+    g_signal_connect (G_OBJECT (window), "window-state-event", G_CALLBACK (window_state_event), trayIcon);
+    gtk_container_add (GTK_CONTAINER (window), menuBar);
+    gtk_widget_show_all (window);
+    gtk_main ();
+    return 0;
+}
+
+static void trayView(GtkMenuItem *item, gpointer window) 
+{
+    gtk_widget_show(GTK_WIDGET(window));
+    gtk_window_deiconify(GTK_WINDOW(window));    
+}
+
+static void trayExit(GtkMenuItem *item, gpointer user_data) 
+{
+    printf("exit");
+    gtk_main_quit();
+}
+
+static void trayIconActivated(GObject *trayIcon, gpointer window)
+{
+    gtk_widget_show(GTK_WIDGET(window));
+    gtk_window_deiconify(GTK_WINDOW(window));
+}
+
+static void trayIconPopup(GtkStatusIcon *status_icon, guint button, guint32 activate_time, gpointer popUpMenu)
+{
+    gtk_menu_popup(GTK_MENU(popUpMenu), NULL, NULL, gtk_status_icon_position_menu, status_icon, button, activate_time);
+}
+
+static void destroy (GtkWidget *window, gpointer data)
+{
+  gtk_main_quit ();
+}
+
+static gboolean delete_event (GtkWidget *window, GdkEvent *event, gpointer data)
+{
+    return FALSE;
+}
+
+static gboolean window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer trayIcon)
+{
+    if(event->changed_mask == GDK_WINDOW_STATE_ICONIFIED &&
+       (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED
+        || event->new_window_state == (GDK_WINDOW_STATE_ICONIFIED | GDK_WINDOW_STATE_MAXIMIZED)))
+    {
+        gtk_widget_hide (GTK_WIDGET(widget));
+        gtk_status_icon_set_visible(GTK_STATUS_ICON(trayIcon), TRUE);
+    }
+    else if(event->changed_mask == GDK_WINDOW_STATE_WITHDRAWN &&
+            (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED
+             || event->new_window_state == (GDK_WINDOW_STATE_ICONIFIED | GDK_WINDOW_STATE_MAXIMIZED)))
+    {
+        gtk_status_icon_set_visible(GTK_STATUS_ICON(trayIcon), FALSE);
+    }
+    return TRUE;
+}