Remove unused branches.
authorHong Jen Yee (PCMan) <pcman.tw@gmail.com>
Thu, 27 Nov 2008 06:13:48 +0000 (06:13 +0000)
committerHong Jen Yee (PCMan) <pcman.tw@gmail.com>
Thu, 27 Nov 2008 06:13:48 +0000 (06:13 +0000)
Add lxpanel-menu-cache branch.

git-svn-id: https://lxde.svn.sourceforge.net/svnroot/lxde/branches/lxpanel-menu-cache@924 3baf7735-d320-0410-8b56-b11ef3703fae

configure.ac
src/panel.c
src/panel.h
src/plugins/menu.c
src/plugins/pager.c
src/plugins/taskbar.c

index 0b8df0e..7d41371 100644 (file)
@@ -16,7 +16,8 @@ AC_PROG_INTLTOOL(, [no-xml])
 
 # Checks for libraries.
 pkg_modules="gtk+-2.0 >= 2.6.0 \
-             gthread-2.0"
+             gthread-2.0 \
+             libmenu-cache"
 #             libstartup-notification-1.0"
 PKG_CHECK_MODULES(PACKAGE, [$pkg_modules])
 AC_SUBST(PACKAGE_CFLAGS)
index 3db6416..f3d106c 100644 (file)
@@ -47,6 +47,8 @@ gchar *cprofile = "default";
 static int config = 0;
 FbEv *fbev = NULL;
 
+static MenuCache* menu_cache = NULL;
+
 int log_level;
 
 GSList* all_panels = NULL;  /* a single-linked list storing all panels */
@@ -798,6 +800,12 @@ extern GtkMenu* lxpanel_get_panel_menu( Panel* panel, Plugin* plugin, gboolean u
     return ret;
 }
 
+extern MenuCache* lxpanel_get_menu_cache()
+{
+       if( G_UNLIKELY( ! menu_cache ) )
+               menu_cache = menu_cache_new( "/home/pcman/.cache/menus/zh_TW/applications.menu.cache", NULL, NULL );
+       return menu_cache ? menu_cache_ref( menu_cache ) : NULL;
+}
 
 
 /****************************************************
@@ -1470,5 +1478,8 @@ restart:
 
     g_object_unref(fbev);
 
+       if( menu_cache )
+               menu_cache_unref( menu_cache );
+
     return 0;
 }
index 1d4025b..04eecb2 100644 (file)
@@ -23,6 +23,8 @@
 #include <gtk/gtk.h>
 #include <gdk/gdk.h>
 
+#include <menu-cache.h>
+
 #include "config.h"
 
 #include "bg.h"
@@ -194,4 +196,6 @@ void panel_update_background( Panel* p );
 extern const char* lxpanel_get_file_manager();
 extern const char* lxpanel_get_terminal();
 
+extern MenuCache* lxpanel_get_menu_cache();
+
 #endif
index 2cade71..e518a6e 100644 (file)
@@ -23,6 +23,8 @@
 #include <glib.h>
 #include <glib/gi18n.h>
 
+#include <menu-cache.h>
+
 #include "panel.h"
 #include "misc.h"
 #include "plugin.h"
@@ -52,10 +54,15 @@ typedef struct {
     char* config_data;
     int sysmenu_pos;
     char *config_start, *config_end;
+
+    MenuCache* menu_cache;
 } menup;
 
 static guint idle_loader = 0;
 
+GQuark SYS_MENU_ITEM_ID = 0;
+
+
 static void
 menu_destructor(Plugin *p)
 {
@@ -76,6 +83,10 @@ menu_destructor(Plugin *p)
     /* The widget is destroyed in plugin_stop().
     gtk_widget_destroy(m->box);
     */
+
+       if( m->menu_cache )
+               menu_cache_unref( m->menu_cache );
+
     g_free(m->fname);
     g_free(m->caption);
     g_free(m);
@@ -139,28 +150,177 @@ menu_pos(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, GtkWidget *widget)
     RET();
 }
 
+static void on_menu_item( GtkMenuItem* mi, MenuCacheItem* item )
+{
+       g_debug( "Exec = %s", menu_cache_app_get_exec(MENU_CACHE_APP(item)) );
+       g_debug( "Terminal = %d", menu_cache_app_get_use_terminal(MENU_CACHE_APP(item)) );
+}
+
+static GtkWidget* create_item( MenuCacheItem* item )
+{
+       GtkWidget* mi;
+       if( menu_cache_item_get_type(item) == MENU_CACHE_TYPE_SEP )
+               mi = gtk_separator_menu_item_new();
+       else
+       {
+               GtkWidget* img;
+               mi = gtk_image_menu_item_new_with_label( menu_cache_item_get_name(item) );
+               gtk_widget_set_tooltip_text( mi, menu_cache_item_get_comment(item) );
+               /*
+               if( g_file_test( menu_cache_item_get_icon(item), G_FILE_TEST_IS_REGULAR ) )
+               {
+                       img = gtk_image_new_from_file(menu_cache_item_get_icon(item));
+               }
+               else
+               */
+                       img = gtk_image_new_from_icon_name(menu_cache_item_get_icon(item), GTK_ICON_SIZE_MENU );
+               gtk_image_menu_item_set_image( mi, img );
+               if( menu_cache_item_get_type(item) == MENU_CACHE_TYPE_APP )
+               {
+                       g_object_set_data_full( mi, "mcitem", menu_cache_item_ref(item), menu_cache_item_unref );
+                       g_signal_connect( mi, "activate", on_menu_item, item );
+               }
+       }
+       gtk_widget_show( mi );
+       
+       g_object_set_qdata_full( mi, SYS_MENU_ITEM_ID, menu_cache_item_ref, menu_cache_item_unref );
+       
+       return mi;
+}
+
+static void load_menu(MenuCacheDir* dir, GtkWidget* menu, int pos )
+{
+       GSList* l;
+       GtkWidget* mi;
+
+       for( l = menu_cache_dir_get_children(dir); l; l = l->next )
+       {
+               MenuCacheItem* item = MENU_CACHE_ITEM(l->data);
+               mi = create_item(item);
+               gtk_widget_show( mi );
+
+               gtk_menu_shell_insert( (GtkMenuShell*)menu, mi, pos );
+
+               if( menu_cache_item_get_type(item) == MENU_CACHE_TYPE_DIR )
+               {
+                       GtkWidget* sub = gtk_menu_new();
+                       gtk_menu_item_set_submenu( mi, menu );
+                       load_menu( item, sub, -1 );     /* always pass -1 for position */
+               }
+       }
+       return menu;
+}
+
+
+static gboolean sys_menu_item_has_data( GtkMenuItem* item )
+{
+   return (g_object_get_qdata( G_OBJECT(item), PTK_APP_MENU_ITEM_ID ) != NULL);
+}
+
+/*
+ * Insert application menus into specified menu
+ * menu: The parent menu to which the items should be inserted
+ * pisition: Position to insert items.
+             Passing -1 in this parameter means append all items
+             at the end of menu.
+ */
+static void sys_menu_insert_items( menup* m, GtkMenu* menu, int position )
+{
+       MenuCacheDir* dir;
+       
+       if( G_UNLIKELY( SYS_MENU_ITEM_ID == 0 ) )
+               SYS_MENU_ITEM_ID = g_quark_from_static_string( "SysMenuItem" );
+
+       dir = menu_cache_get_root_dir( m->menu_cache );
+       load_menu( dir, menu, position );
+
+#if 0
+   GList* sub_menus[ G_N_ELEMENTS(known_cats) ] = {0};
+   int i;
+   GList *sub_items, *l;
+   guint change_handler;
+   GKeyFile* kf;
+
+   app_dirs_foreach( (GFunc) load_dir, sub_menus );
+
+   kf = g_key_file_new();
+
+   for( i = 0; i < G_N_ELEMENTS(known_cats); ++i )
+   {
+      GtkMenu* sub_menu;
+      GtkWidget* menu_item;
+      PtkAppMenuItem* data;
+      CatInfo l_cinfo;
+      char* title;
+
+      if( ! (sub_items = sub_menus[i]) )
+         continue;
+      sub_menu = GTK_MENU(gtk_menu_new());
+
+      for( l = sub_items; l; l = l->next )
+         gtk_menu_shell_append( GTK_MENU_SHELL(sub_menu), GTK_WIDGET(l->data) );
+      g_list_free( sub_items );
+      l_cinfo=known_cats[i];
+      title = load_cat_title( kf, &l_cinfo );
+      menu_item = gtk_image_menu_item_new_with_label( title ? title : _(known_cats[i].title) );
+      g_free( title );
+
+      data = g_slice_new0( PtkAppMenuItem );
+      data->icon = g_strdup(known_cats[i].icon);
+      g_object_set_qdata_full( G_OBJECT(menu_item), PTK_APP_MENU_ITEM_ID, data, (GDestroyNotify) sys_menu_item_free );
+      g_signal_connect( menu_item, "expose-event", G_CALLBACK(on_menu_item_expose), data );
+      g_signal_connect( menu_item, "size-request", G_CALLBACK(on_menu_item_size_request), data );
+      on_menu_item_expose( menu_item, NULL, data );
+      gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu_item), GTK_WIDGET(sub_menu) );
+
+      if( position == -1 )
+         gtk_menu_shell_append( GTK_MENU_SHELL(menu), menu_item );
+      else
+      {
+         gtk_menu_shell_insert( GTK_MENU_SHELL(menu), menu_item, position );
+         ++position;
+      }
+   }
+
+   g_key_file_free( kf );
+
+   gtk_widget_show_all(GTK_WIDGET(menu));
+   change_handler = g_signal_connect_swapped( gtk_icon_theme_get_default(), "changed", G_CALLBACK(unload_old_icons), menu );
+   g_object_weak_ref( G_OBJECT(menu), on_app_menu_destroy, GINT_TO_POINTER(change_handler) );
+#endif
+
+}
+
+
 static void
-reload_system_menu( GtkMenu* menu )
+reload_system_menu( menup* m, GtkMenu* menu )
 {
     GList *children, *child;
     GtkMenuItem* item;
     GtkWidget* sub_menu;
     gint idx;
+
+       return;
+
     children = gtk_container_get_children( GTK_CONTAINER(menu) );
-    for( child = children, idx = 0; child; child = child->next, ++idx ) {
+    for( child = children, idx = 0; child; child = child->next, ++idx )
+       {
         item = GTK_MENU_ITEM( child->data );
-        if( ptk_app_menu_item_has_data( item ) ) {
-            do {
+        if( sys_menu_item_has_data( item ) )
+               {
+            do
+                       {
                 item = GTK_MENU_ITEM( child->data );
                 child = child->next;
                 gtk_widget_destroy( GTK_WIDGET(item) );
-            }while( child && ptk_app_menu_item_has_data( child->data ) );
-            ptk_app_menu_insert_items( menu, idx );
+            }while( child && sys_menu_item_has_data( child->data ) );
+            sys_menu_insert_items( m, menu, idx );
             if( ! child )
                 break;
         }
-        else if( ( sub_menu = gtk_menu_item_get_submenu( item ) ) ) {
-            reload_system_menu( GTK_MENU(sub_menu) );
+        else if( ( sub_menu = gtk_menu_item_get_submenu( item ) ) )
+               {
+            reload_system_menu( m, GTK_MENU(sub_menu) );
         }
     }
     g_list_free( children );
@@ -169,15 +329,18 @@ reload_system_menu( GtkMenu* menu )
 static void show_menu( GtkWidget* widget, Plugin* p, int btn, guint32 time )
 {
     menup* m = (menup*)p->priv;
+
     /* reload system menu items if needed */
-    if( m->has_system_menu && ptk_app_menu_need_reload() ) {
+    if( m->has_system_menu && ! menu_cache_is_updated(m->menu_cache) )
+       {
         GSList* l;
         /* FIXME: Reload all system menus here.
                   This is dirty, but I don't know any better way. */
-        for( l = p->panel->system_menus; l; l = l->next ) {
+        for( l = p->panel->system_menus; l; l = l->next )
+               {
             Plugin* _p = (Plugin*)l->data;
             menup* _m = (menup*)_p->priv;
-            reload_system_menu( GTK_MENU(_m->menu) );
+            reload_system_menu( _m, GTK_MENU(_m->menu) );
         }
     }
     gtk_menu_popup(GTK_MENU(m->menu),
@@ -364,20 +527,6 @@ read_separator(Plugin *p, char **fp)
     RET(gtk_separator_menu_item_new());
 }
 
-static gboolean on_idle( Panel* p )
-{
-    GSList* l;
-    /* Reload all system menus here.
-        This is dirty, but I don't know any better way. */
-    for( l = p->system_menus; l; l = l->next ) {
-        Plugin* _p = (Plugin*)l->data;
-        menup* _m = (menup*)_p->priv;
-        reload_system_menu( GTK_MENU(_m->menu) );
-    }
-    idle_loader = 0;
-    return FALSE;   /* remove the handler */
-}
-
 static void
 read_system_menu(GtkMenu* menu, Plugin *p, char** fp)
 {
@@ -395,23 +544,11 @@ read_system_menu(GtkMenu* menu, Plugin *p, char** fp)
         }
    }
 
-   /* ptk_app_menu_insert_items( menu, -1 ); */
-   /* Don't load the real system menu here to speed up startup.
-    * Let's add a fake item to cheat PtkAppMenu as a place holder,
-    * and we utilize reload_system_menu() to load the real menu later. */
-    fake = gtk_separator_menu_item_new();
-    PTK_APP_MENU_ITEM_ID = g_quark_from_static_string( "PtkAppMenuItem" );
-    g_object_set_qdata( G_OBJECT(fake), 
-            PTK_APP_MENU_ITEM_ID, GUINT_TO_POINTER(TRUE) );
-   gtk_menu_shell_append( (GtkMenuShell*)menu, fake);
-
+   sys_menu_insert_items( m, menu, -1 );
    m->has_system_menu = TRUE;
 
    p->panel->system_menus = g_slist_append( p->panel->system_menus, p );
 
-    if( idle_loader == 0 )  /* delay the loading, and do it in idle handler */
-        idle_loader = g_idle_add( (GSourceFunc)on_idle, p->panel );
-
    RET();
 }
 
@@ -576,6 +713,9 @@ menu_constructor(Plugin *p, char **fp)
     g_return_val_if_fail(m != NULL, 0);
     m->fname = NULL;
     m->caption = NULL;
+
+    m->menu_cache = menu_cache_lookup("applications.menu");
+
     p->priv = m;
 
     //gtk_rc_parse_string(menu_rc);
index f49b86c..58534ac 100644 (file)
@@ -27,7 +27,6 @@
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
-#include <X11/xpm.h>
 
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <glib/gi18n.h>
index 10835f4..f9fee3f 100644 (file)
@@ -23,7 +23,6 @@
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
-//#include <X11/xpm.h>
 
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gdk-pixbuf-xlib/gdk-pixbuf-xlib.h>