Launcher support for .desktop files (working but experimental)

git-svn-id: http://tint2.googlecode.com/svn/trunk@538 121b4492-b84c-0410-8b4c-0d4edfb3f3cc

src/config.c

@@ -556,13 +556,13 @@ void add_entry (char *key, char *value)
 	else if (strcmp(key, "launcher_icon_size") == 0) {
 		launcher_max_icon_size = atoi(value);
 	}
-	else if (strcmp(key, "launcher_item_icon") == 0) {
-		char *path = strdup(value);
-		panel_config.launcher.list_icon_paths = g_slist_append(panel_config.launcher.list_icon_paths, path);
+	else if (strcmp(key, "launcher_item_app") == 0) {
+		char *app = strdup(value);
+		panel_config.launcher.list_apps = g_slist_append(panel_config.launcher.list_apps, app);
 	}
-	else if (strcmp(key, "launcher_item_cmd") == 0) {
-		char *cmd = strdup(value);
-		panel_config.launcher.list_cmds = g_slist_append(panel_config.launcher.list_cmds, cmd);
+	else if (strcmp(key, "launcher_icon_theme") == 0) {
+		char *app = strdup(value);
+		panel_config.launcher.icon_theme_names = g_slist_append(panel_config.launcher.icon_theme_names, app);
 	}
 
 	/* Tooltip */

src/launcher/launcher.c

@@ -36,6 +36,16 @@ int launcher_enabled;
 int launcher_max_icon_size;
 GSList *icon_themes = 0;
 
+#define ICON_FALLBACK "exec"
+
+char *icon_path(Launcher *launcher, const char *icon_name, int size);
+void launcher_load_themes(Launcher *launcher);
+void free_desktop_entry(DesktopEntry *entry);
+int launcher_read_desktop_file(const char *path, DesktopEntry *entry);
+Imlib_Image scale_icon(Imlib_Image original, int icon_size);
+void free_icon(Imlib_Image icon);
+void free_icon_theme(IconTheme *theme);
+
 void default_launcher()
 {
 	launcher_enabled = 0;
@@ -73,19 +83,25 @@ void init_launcher_panel(void *p)
 		launcher->area.width = panel->area.width - (2 * panel->area.bg->border.width) - (2 * panel->area.paddingy);
 	}
 
-	// Load icons
-	{
-		GSList* path = launcher->list_icon_paths;
-		GSList* cmd = launcher->list_cmds;
-		while (path != NULL && cmd != NULL)
-		{
-			LauncherIcon *launcherIcon = malloc(sizeof(LauncherIcon));
-			launcherIcon->icon = imlib_load_image(path->data);
-			launcherIcon->cmd = strdup(cmd->data);
+	fprintf(stderr, "Loading themes...\n");
+	launcher_load_themes(launcher);
+	fprintf(stderr, "Done\n");
+
+	// Load apps (.desktop style launcher items)
+	GSList* app = launcher->list_apps;
+	while (app != NULL) {
+		DesktopEntry entry;
+		launcher_read_desktop_file(app->data, &entry);
+		if (entry.exec) {
+			LauncherIcon *launcherIcon = calloc(1, sizeof(LauncherIcon));
+			launcherIcon->is_app_desktop = 1;
+			launcherIcon->cmd = strdup(entry.exec);
+			launcherIcon->icon_name = entry.icon ? strdup(entry.icon) : strdup(ICON_FALLBACK);
+			launcherIcon->icon_size = 1;
+			free_desktop_entry(&entry);
 			launcher->list_icons = g_slist_append(launcher->list_icons, launcherIcon);
-			path = g_slist_next(path);
-			cmd = g_slist_next(cmd);
 		}
+		app = g_slist_next(app);
 	}
 }
 
@@ -101,22 +117,34 @@ void cleanup_launcher()
 		GSList *l;
 		for (l = launcher->list_icons; l ; l = l->next) {
 			LauncherIcon *launcherIcon = (LauncherIcon*)l->data;
-			if (launcherIcon && launcherIcon->icon) {
-				imlib_context_set_image (launcherIcon->icon);
-				imlib_free_image();
+			if (launcherIcon) {
+				free_icon(launcherIcon->icon_scaled);
+				free_icon(launcherIcon->icon_original);
+				free(launcherIcon->icon_name);
+				free(launcherIcon->icon_path);
+				free(launcherIcon->cmd);
 			}
-			free(launcherIcon->cmd);
 			free(launcherIcon);
 		}
 		g_slist_free(launcher->list_icons);
-		for (l = launcher->list_icon_paths; l ; l = l->next) {
+
+		for (l = launcher->list_apps; l ; l = l->next) {
 			free(l->data);
 		}
-		g_slist_free(launcher->list_icon_paths);
-		for (l = launcher->list_cmds; l ; l = l->next) {
+		g_slist_free(launcher->list_apps);
+
+		for (l = launcher->icon_themes; l ; l = l->next) {
+			IconTheme *theme = (IconTheme*) l->data;
+			free_icon_theme(theme);
+			free(theme);
+		}
+		g_slist_free(launcher->icon_themes);
+
+		for (l = launcher->icon_theme_names; l ; l = l->next) {
 			free(l->data);
 		}
-		g_slist_free(launcher->list_cmds);
+		g_slist_free(launcher->icon_theme_names);
+		launcher->list_apps = launcher->list_icons = launcher->icon_theme_names = launcher->icon_themes = NULL;
 	}
 	launcher_enabled = 0;
 }
@@ -137,6 +165,48 @@ void resize_launcher(void *obj)
 	if (launcher_max_icon_size > 0 && icon_size > launcher_max_icon_size)
 		icon_size = launcher_max_icon_size;
 
+	// Resize icons if necessary
+	for (l = launcher->list_icons; l ; l = l->next) {
+		LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
+		if (launcherIcon->icon_size != icon_size || !launcherIcon->icon_original) {
+			launcherIcon->icon_size = icon_size;
+			// Get the path for an icon file with the new size
+			char *new_icon_path = icon_path(launcher, launcherIcon->icon_name, launcherIcon->icon_size);
+			if (!new_icon_path) {
+				// Draw a blank icon
+				free_icon(launcherIcon->icon_original);
+				launcherIcon->icon_original = NULL;
+				free_icon(launcherIcon->icon_scaled);
+				launcherIcon->icon_scaled = NULL;
+				new_icon_path = icon_path(launcher, ICON_FALLBACK, launcherIcon->icon_size);
+				if (new_icon_path) {
+					launcherIcon->icon_original = imlib_load_image(new_icon_path);
+					fprintf(stderr, "%s %d: Using icon %s\n", __FILE__, __LINE__, new_icon_path);
+					free(new_icon_path);
+				}
+				launcherIcon->icon_scaled = scale_icon(launcherIcon->icon_original, icon_size);
+				continue;
+			}
+			if (launcherIcon->icon_path && strcmp(new_icon_path, launcherIcon->icon_path) == 0) {
+				// If it's the same file just rescale
+				free_icon(launcherIcon->icon_scaled);
+				launcherIcon->icon_scaled = scale_icon(launcherIcon->icon_original, icon_size);
+				free(new_icon_path);
+				fprintf(stderr, "%s %d: Using icon %s\n", __FILE__, __LINE__, launcherIcon->icon_path);
+			} else {
+				// Free the old files
+				free_icon(launcherIcon->icon_original);
+				free_icon(launcherIcon->icon_scaled);
+				// Load the new file and scale
+				launcherIcon->icon_original = imlib_load_image(new_icon_path);
+				launcherIcon->icon_scaled = scale_icon(launcherIcon->icon_original, launcherIcon->icon_size);
+				free(launcherIcon->icon_path);
+				launcherIcon->icon_path = new_icon_path;
+				fprintf(stderr, "%s %d: Using icon %s\n", __FILE__, __LINE__, launcherIcon->icon_path);
+			}
+		}
+	}
+	
 	count = 0;
 	for (l = launcher->list_icons; l ; l = l->next) {
 		count++;
@@ -187,8 +257,6 @@ void resize_launcher(void *obj)
 		
 		launcherIcon->y = posy;
 		launcherIcon->x = posx;
-		launcherIcon->width = icon_size;
-		launcherIcon->height = icon_size;
 		if (panel_horizontal) {
 			if (i % icons_per_column)
 				posy += icon_size + launcher->area.paddingx;
@@ -222,19 +290,7 @@ void draw_launcher(void *obj, cairo_t *c)
 		LauncherIcon *launcherIcon = (LauncherIcon*)l->data;
 		int pos_x = launcherIcon->x;
 		int pos_y = launcherIcon->y;
-		int width = launcherIcon->width;
-		int height = launcherIcon->height;
-		Imlib_Image icon_scaled;
-		if (launcherIcon->icon) {
-			imlib_context_set_image (launcherIcon->icon);
-			icon_scaled = imlib_create_cropped_scaled_image(0, 0, imlib_image_get_width(), imlib_image_get_height(), width, height);
-		} else {
-			icon_scaled = imlib_create_image(width, height);
-			imlib_context_set_image (icon_scaled);
-			imlib_context_set_color(255, 255, 255, 255);
-			imlib_image_fill_rectangle(0, 0, width, height);
-		}
-
+		Imlib_Image icon_scaled = launcherIcon->icon_scaled;
 		// Render
 		imlib_context_set_image (icon_scaled);
 		if (server.real_transparency) {
@@ -244,6 +300,28 @@ void draw_launcher(void *obj, cairo_t *c)
 			imlib_context_set_drawable(launcher->area.pix);
 			imlib_render_image_on_drawable (pos_x, pos_y);
 		}
+	}
+}
+
+Imlib_Image scale_icon(Imlib_Image original, int icon_size)
+{
+	Imlib_Image icon_scaled;
+	if (original) {
+		imlib_context_set_image (original);
+		icon_scaled = imlib_create_cropped_scaled_image(0, 0, imlib_image_get_width(), imlib_image_get_height(), icon_size, icon_size);
+	} else {
+		icon_scaled = imlib_create_image(icon_size, icon_size);
+		imlib_context_set_image (icon_scaled);
+		imlib_context_set_color(255, 255, 255, 255);
+		imlib_image_fill_rectangle(0, 0, icon_size, icon_size);
+	}
+	return icon_scaled;
+}
+
+void free_icon(Imlib_Image icon)
+{
+	if (icon) {
+		imlib_context_set_image(icon);
 		imlib_free_image();
 	}
 }
@@ -260,6 +338,8 @@ void launcher_action(LauncherIcon *icon)
 /* http://standards.freedesktop.org/desktop-entry-spec/ */
 /* http://standards.freedesktop.org/icon-theme-spec/ */
 
+// Splits line at first '=' and returns 1 if successful, and parts are not empty
+// key and value point to the parts
 int parse_dektop_line(char *line, char **key, char **value)
 {
 	char *p;
@@ -280,6 +360,11 @@ int parse_dektop_line(char *line, char **key, char **value)
 	return 1;
 }
 
+int parse_theme_line(char *line, char **key, char **value)
+{
+	return parse_dektop_line(line, key, value);
+}
+
 void expand_exec(DesktopEntry *entry, const char *path)
 {
 	// Expand % in exec
@@ -332,46 +417,31 @@ void expand_exec(DesktopEntry *entry, const char *path)
 	}
 }
 
+//TODO Use UTF8 when parsing the file
 int launcher_read_desktop_file(const char *path, DesktopEntry *entry)
 {
 	FILE *fp;
 	char line[4096];
-	char *buffer;
 	char *key, *value;
 
 	entry->name = entry->icon = entry->exec = NULL;
 
-	if ((fp = fopen(path, "r")) == NULL) {
+	if ((fp = fopen(path, "rt")) == NULL) {
 		fprintf(stderr, "Could not open file %s\n", path);
 		return 0;
 	}
 
-	buffer = line;
-	while (fgets(buffer, sizeof(line) - (buffer - line), fp) != NULL) {
-		//TODO use UTF8 capable strlen
-		int len = strlen(buffer);
-		int total_len = strlen(line);
-		if (!g_utf8_validate(buffer, total_len, NULL)) {
-			// Not a real newline, read more
-			buffer += len;
-			if (sizeof(line) - (buffer - line) < 2) {
-				fprintf(stderr, "%s %d: line too long (%s)\n", __FILE__, __LINE__, path);
-				break;
-			} else {
-				continue;
-			}
-		}
-		// We have a valid line
-		buffer[len-1] = '\0';
-		buffer = line;
+	while (fgets(line, sizeof(line), fp) != NULL) {
+		int len = strlen(line);
+		if (len == 0)
+			continue;
+		line[len - 1] = '\0';
 		if (parse_dektop_line(line, &key, &value)) {
 			if (strcmp(key, "Name") == 0) {
-				//TODO use UTF-8 capable strdup
 				entry->name = strdup(value);
 			} else if (strcmp(key, "Exec") == 0) {
 				entry->exec = strdup(value);
 			} else if (strcmp(key, "Icon") == 0) {
-				//TODO use UTF-8 capable strdup
 				entry->icon = strdup(value);
 			}
 		}
@@ -385,100 +455,467 @@ int launcher_read_desktop_file(const char *path, DesktopEntry *entry)
 	return 1;
 }
 
+void free_desktop_entry(DesktopEntry *entry)
+{
+	free(entry->name);
+	free(entry->icon);
+	free(entry->exec);
+}
+
 void test_launcher_read_desktop_file()
 {
+	fprintf(stdout, "\033[1;33m");
 	DesktopEntry entry;
 	launcher_read_desktop_file("/usr/share/applications/firefox.desktop", &entry);
 	printf("Name:%s Icon:%s Exec:%s\n", entry.name, entry.icon, entry.exec);
+	fprintf(stdout, "\033[0m");
 }
 
+//TODO Use UTF8 when parsing the file
 IconTheme *load_theme(char *name)
 {
-	//TODO
 	// Look for name/index.theme in $HOME/.icons, /usr/share/icons, /usr/share/pixmaps (stop at the first found)
 	// Parse index.theme -> list of IconThemeDir with attributes
-	// Return IconTheme struct
-	return NULL;
+	// Return IconTheme*
+
+	IconTheme *theme;
+	char *file_name;
+	FILE *f;
+	char line[2048];
+
+	if (name == NULL)
+		return NULL;
+
+	fprintf(stderr, "Loading icon theme %s\n", name);
+
+	file_name = malloc(100 + strlen(name));
+	sprintf(file_name, "~/.icons/%s/index.theme", name);
+	if (!g_file_test(file_name, G_FILE_TEST_EXISTS)) {
+		sprintf(file_name, "/usr/share/icons/%s/index.theme", name);
+		if (!g_file_test(file_name, G_FILE_TEST_EXISTS)) {
+			sprintf(file_name, "/usr/share/pixmaps/%s/index.theme", name);
+			if (!g_file_test(file_name, G_FILE_TEST_EXISTS)) {
+				free(file_name);
+				file_name = NULL;
+			}
+		}
+	}
+	if (!file_name) {
+		fprintf(stderr, "Could not load theme %s\n", name);
+		return NULL;
+	}
+
+	if ((f = fopen(file_name, "rt")) == NULL)
+		return NULL;
+
+	free(file_name);
+
+	theme = calloc(1, sizeof(IconTheme));
+	theme->name = strdup(name);
+	theme->list_inherits = NULL;
+	theme->list_directories = NULL;
+
+	IconThemeDir *current_dir = NULL;
+	int inside_header = 1;
+	while (fgets(line, sizeof(line), f) != NULL) {
+		char *key, *value;
+		
+		int line_len = strlen(line);
+		if (line_len >= 1) {
+			if (line[line_len - 1] == '\n') {
+				line[line_len - 1] = '\0';
+				line_len--;
+			}
+		}
+
+		if (line_len == 0)
+			continue;
+
+		if (inside_header) {
+			if (parse_theme_line(line, &key, &value)) {
+				if (strcmp(key, "Inherits") == 0) {
+					// value is like oxygen,wood,default
+					char *token;
+					token = strtok(value, ",\n");
+					while (token != NULL)
+					{
+						theme->list_inherits = g_slist_append(theme->list_inherits, strdup(token));
+						token = strtok(NULL, ",\n");
+					}
+				} else if (strcmp(key, "Directories") == 0) {
+					// value is like 48x48/apps,48x48/mimetypes,32x32/apps,scalable/apps,scalable/mimetypes
+					char *token;
+					token = strtok(value, ",\n");
+					while (token != NULL)
+					{
+						IconThemeDir *dir = calloc(1, sizeof(IconThemeDir));
+						dir->name = strdup(token);
+						dir->max_size = dir->min_size = dir->size = -1;
+						dir->type = ICON_DIR_TYPE_THRESHOLD;
+						dir->threshold = 2;
+						theme->list_directories = g_slist_append(theme->list_directories, dir);
+						token = strtok(NULL, ",\n");
+					}
+				}
+			}
+		} else if (current_dir != NULL) {
+			if (parse_theme_line(line, &key, &value)) {
+				if (strcmp(key, "Size") == 0) {
+					// value is like 24
+					sscanf(value, "%d", &current_dir->size);
+					if (current_dir->max_size == -1)
+						current_dir->max_size = current_dir->size;
+					if (current_dir->min_size == -1)
+						current_dir->min_size = current_dir->size;
+				} else if (strcmp(key, "MaxSize") == 0) {
+					// value is like 24
+					sscanf(value, "%d", &current_dir->max_size);
+				} else if (strcmp(key, "MinSize") == 0) {
+					// value is like 24
+					sscanf(value, "%d", &current_dir->min_size);
+				} else if (strcmp(key, "Threshold") == 0) {
+					// value is like 2
+					sscanf(value, "%d", &current_dir->threshold);
+				} else if (strcmp(key, "Type") == 0) {
+					// value is Fixed, Scalable or Threshold
+					if (strcmp(value, "Fixed") == 0) {
+						current_dir->type = ICON_DIR_TYPE_FIXED;
+					} else if (strcmp(value, "Scalable") == 0) {
+						current_dir->type = ICON_DIR_TYPE_SCALABLE;
+					} else if (strcmp(value, "Threshold") == 0) {
+						current_dir->type = ICON_DIR_TYPE_THRESHOLD;
+					}
+				} else if (strcmp(key, "Context") == 0) {
+					// usual values: Actions, Applications, Devices, FileSystems, MimeTypes
+					current_dir->context = strdup(value);
+				}
+			}
+		}
+
+		if (line[0] == '[' && line[line_len - 1] == ']' && strcmp(line, "[Icon Theme]") != 0) {
+			inside_header = 0;
+			current_dir = NULL;
+			line[line_len - 1] = '\0';
+			char *dir_name = line + 1;
+			GSList* dir_item = theme->list_directories;
+			while (dir_item != NULL)
+			{
+				IconThemeDir *dir = dir_item->data;
+				if (strcmp(dir->name, dir_name) == 0) {
+					current_dir = dir;
+					break;
+				}
+				dir_item = g_slist_next(dir_item);
+			}
+		}
+	}
+	fclose(f);
+	
+	return theme;
+}
+
+void free_icon_theme(IconTheme *theme)
+{
+	free(theme->name);
+	GSList *l_inherits;
+	for (l_inherits = theme->list_inherits; l_inherits ; l_inherits = l_inherits->next) {
+		free(l_inherits->data);
+	}
+	GSList *l_dir;
+	for (l_dir = theme->list_directories; l_dir ; l_dir = l_dir->next) {
+		IconThemeDir *dir = (IconThemeDir *)l_dir->data;
+		free(dir->name);
+		free(dir->context);
+		free(l_dir->data);
+	}
+}
+
+void test_launcher_read_theme_file()
+{
+	fprintf(stdout, "\033[1;33m");
+	IconTheme *theme = load_theme("oxygen");
+	if (!theme) {
+		printf("Could not load theme\n");
+		return;
+	}
+	printf("Loaded theme: %s\n", theme->name);
+	GSList* item = theme->list_inherits;
+	while (item != NULL)
+	{
+		printf("Inherits:%s\n", (char*)item->data);
+		item = g_slist_next(item);
+	}
+	item = theme->list_directories;
+	while (item != NULL)
+	{
+		IconThemeDir *dir = item->data;
+		printf("Dir:%s Size=%d MinSize=%d MaxSize=%d Threshold=%d Type=%s Context=%s\n",
+			   dir->name, dir->size, dir->min_size, dir->max_size, dir->threshold,
+			   dir->type == ICON_DIR_TYPE_FIXED ? "Fixed" :
+			   dir->type == ICON_DIR_TYPE_SCALABLE ? "Scalable" :
+			   dir->type == ICON_DIR_TYPE_THRESHOLD ? "Threshold" : "?????",
+			   dir->context);
+		item = g_slist_next(item);
+	}
+	fprintf(stdout, "\033[0m");
 }
 
 // Populates the icon_themes list
-void launcher_load_themes()
+void launcher_load_themes(Launcher *launcher)
 {
-	//TODO load the user theme, all the inherited themes recursively (DFS), and the hicolor theme
+	// load the user theme, all the inherited themes recursively (DFS), and the hicolor theme
 	// avoid inheritance loops
+
+	GSList *queue = NULL;
+	GSList *queued = NULL;
+
+	GSList* icon_theme_name_item;
+	for (icon_theme_name_item = launcher->icon_theme_names; icon_theme_name_item; icon_theme_name_item = g_slist_next(icon_theme_name_item)) {
+		int duplicate = 0;
+		GSList* queued_item = queued;
+		while (queued_item != NULL) {
+			if (strcmp(queued_item->data, icon_theme_name_item->data) == 0) {
+				duplicate = 1;
+				break;
+			}
+			queued_item = g_slist_next(queued_item);
+		}
+		if (!duplicate) {
+			queue = g_slist_append(queue, strdup(icon_theme_name_item->data));
+			queued = g_slist_append(queued, strdup(icon_theme_name_item->data));
+		}
+	}
+
+	int hicolor_loaded = 0;
+	while (queue || !hicolor_loaded) {
+		if (!queue) {
+			GSList* queued_item = queued;
+			while (queued_item != NULL) {
+				if (strcmp(queued_item->data, "hicolor") == 0) {
+					hicolor_loaded = 1;
+					break;
+				}
+				queued_item = g_slist_next(queued_item);
+			}
+			if (hicolor_loaded)
+				break;
+			queue = g_slist_append(queue, strdup("hicolor"));
+			queued = g_slist_append(queued, strdup("hicolor"));
+		}
+		
+		char *name = queue->data;
+		queue = g_slist_remove(queue, name);
+
+		IconTheme *theme = load_theme(name);
+		if (theme != NULL) {
+			launcher->icon_themes = g_slist_append(launcher->icon_themes, theme);
+
+			GSList* item = theme->list_inherits;
+			while (item != NULL)
+			{
+				char *parent = item->data;
+				int duplicate = 0;
+				GSList* queued_item = queued;
+				while (queued_item != NULL) {
+					if (strcmp(queued_item->data, parent) == 0) {
+						duplicate = 1;
+						break;
+					}
+					queued_item = g_slist_next(queued_item);
+				}
+				if (!duplicate) {
+					queue = g_slist_append(queue, strdup(parent));
+					queued = g_slist_append(queued, strdup(parent));
+				}
+				item = g_slist_next(item);
+			}
+		}
+	}
+
+	// Free the queue
+	GSList *l;
+	for (l = queue; l ; l = l->next)
+		free(l->data);
+	g_slist_free(queue);
+	for (l = queued; l ; l = l->next)
+		free(l->data);
+	g_slist_free(queued);
+}
+
+int directory_matches_size(IconThemeDir *dir, int size)
+{
+	if (dir->type == ICON_DIR_TYPE_FIXED) {
+		return dir->size == size;
+	} else if (dir->type == ICON_DIR_TYPE_SCALABLE) {
+		return dir->min_size <= size && size <= dir->max_size;
+	} else /*if (dir->type == ICON_DIR_TYPE_THRESHOLD)*/ {
+		return dir->size - dir->threshold <= size && size <= dir->size + dir->threshold;
+	}
+}
+
+int directory_size_distance(IconThemeDir *dir, int size)
+{
+	if (dir->type == ICON_DIR_TYPE_FIXED) {
+		return abs(dir->size - size);
+	} else if (dir->type == ICON_DIR_TYPE_SCALABLE) {
+		if (size < dir->min_size) {
+			return dir->min_size - size;
+		} else if (size > dir->max_size) {
+			return size - dir->max_size;
+		} else {
+			return 0;
+		}
+	} else /*if (dir->type == ICON_DIR_TYPE_THRESHOLD)*/ {
+		if (size < dir->size - dir->threshold) {
+			return dir->min_size - size;
+		} else if (size > dir->size + dir->threshold) {
+			return size - dir->max_size;
+		} else {
+			return 0;
+		}
+	}
 }
 
 // Returns the full path to an icon file (or NULL) given the icon name
-char *icon_path(const char *name)
+char *icon_path(Launcher *launcher, const char *icon_name, int size)
 {
-	//TODO
-	/*
+	if (icon_name == NULL)
+		return NULL;
 	
-// Stage 1: exact size match
-LookupIcon (iconname, size):
-for each subdir in $(theme subdir list) {  // <---- each subdir in each theme
-   for each directory in $(basename list) {
-   for extension in ("png", "svg", "xpm") {
-   if DirectoryMatchesSize(subdir, size) {
-   filename = directory/$(themename)/subdirectory/iconname.extension
-   if exist filename
-	   return filename
-}
-}
-}
-}
+	// If the icon_name is already a path and the file exists, return it
+	if (strstr(icon_name, "/") == icon_name) {
+		if (g_file_test(icon_name, G_FILE_TEST_EXISTS))
+			return strdup(icon_name);
+		else
+			return NULL;
+	}
 
-// Stage 2: best size match
-minimal_size = MAXINT
-for each subdir in $(theme subdir list) {  // <---- each subdir in each theme
-   for each directory in $(basename list) {
-   for extension in ("png", "svg", "xpm") {
-   filename = directory/$(themename)/subdirectory/iconname.extension
-   if exist filename and DirectorySizeDistance(subdir, size) < minimal_size
-	   closest_filename = filename
-	   minimal_size = DirectorySizeDistance(subdir, size)
-}
-}
-}
-if closest_filename set
-	return closest_filename
-
-// Stage 3: look in unthemed icons 
-for each directory in $(basename list) { // <---- $HOME/.icons, /usr/share/icons, /usr/share/pixmaps
-   for extension in ("png", "svg", "xpm") {
-   if exists directory/iconname.extension
-	   return directory/iconname.extension
-	   }
-	   }
-	   
-	   return failed icon lookup
-
-// With the following helper functions:
-
-DirectoryMatchesSize(subdir, iconsize):
-read Type and size data from subdir
-if Type is Fixed
-return Size == iconsize
-if Type is Scaled
-return MinSize <= iconsize <= MaxSize
-if Type is Threshold
-return Size - Threshold <= iconsize <= Size + Threshold
-
-DirectorySizeDistance(subdir, size):
-read Type and size data from subdir
-if Type is Fixed
-return abs(Size - iconsize)
-if Type is Scaled
-if iconsize < MinSize
-return MinSize - iconsize
-if iconsize > MaxSize
-return iconsize - MaxSize
-return 0
-if Type is Threshold
-if iconsize < Size - Threshold
-return MinSize - iconsize
-if iconsize > Size + Threshold
-return iconsize - MaxSize
-return 0
-	*/
+	GSList *basenames = NULL;
+	basenames = g_slist_append(basenames, "~/.icons");
+	basenames = g_slist_append(basenames, "/usr/share/icons");
+	basenames = g_slist_append(basenames, "/usr/share/pixmaps");
+
+	GSList *extensions = NULL;
+	extensions = g_slist_append(extensions, "png");
+	extensions = g_slist_append(extensions, "xpm");
+
+	// Stage 1: exact size match
+	GSList *theme;
+	for (theme = launcher->icon_themes; theme; theme = g_slist_next(theme)) {
+		GSList *dir;
+		for (dir = ((IconTheme*)theme->data)->list_directories; dir; dir = g_slist_next(dir)) {
+			if (directory_matches_size((IconThemeDir*)dir->data, size)) {
+				GSList *base;
+				for (base = basenames; base; base = g_slist_next(base)) {
+					GSList *ext;
+					for (ext = extensions; ext; ext = g_slist_next(ext)) {
+						char *base_name = (char*) base->data;
+						char *theme_name = ((IconTheme*)theme->data)->name;
+						char *dir_name = ((IconThemeDir*)dir->data)->name;
+						char *extension = (char*) ext->data;
+						char *file_name = malloc(strlen(base_name) + strlen(theme_name) +
+							strlen(dir_name) + strlen(icon_name) + strlen(extension) + 100);
+						// filename = directory/$(themename)/subdirectory/iconname.extension
+						sprintf(file_name, "%s/%s/%s/%s.%s", base_name, theme_name, dir_name, icon_name, extension);
+						//printf("checking %s\n", file_name);
+						if (g_file_test(file_name, G_FILE_TEST_EXISTS)) {
+							g_slist_free(basenames);
+							g_slist_free(extensions);
+							return file_name;
+						} else {
+							free(file_name);
+							file_name = NULL;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Stage 2: best size match
+	// Contrary to the freedesktop spec, we are not choosing the closest icon in size, but the next larger icon
+	// otherwise the quality is usually crap (for size 22, if you can choose 16 or 32, you're better with 32)
+	// We do fallback to the closest size if we cannot find a larger or equal icon
+	int minimal_size = INT_MAX;
+	char *best_file_name = NULL;
+	int next_larger_size = -1;
+	char *next_larger = NULL;
+	for (theme = launcher->icon_themes; theme; theme = g_slist_next(theme)) {
+		GSList *dir;
+		for (dir = ((IconTheme*)theme->data)->list_directories; dir; dir = g_slist_next(dir)) {
+			GSList *base;
+			for (base = basenames; base; base = g_slist_next(base)) {
+				GSList *ext;
+				for (ext = extensions; ext; ext = g_slist_next(ext)) {
+					char *base_name = (char*) base->data;
+					char *theme_name = ((IconTheme*)theme->data)->name;
+					char *dir_name = ((IconThemeDir*)dir->data)->name;
+					char *extension = (char*) ext->data;
+					char *file_name = malloc(strlen(base_name) + strlen(theme_name) +
+					strlen(dir_name) + strlen(icon_name) + strlen(extension) + 100);
+					// filename = directory/$(themename)/subdirectory/iconname.extension
+					sprintf(file_name, "%s/%s/%s/%s.%s", base_name, theme_name, dir_name, icon_name, extension);
+					if (g_file_test(file_name, G_FILE_TEST_EXISTS)) {
+						if (directory_size_distance((IconThemeDir*)dir->data, size) < minimal_size) {
+							if (best_file_name) {
+								free(best_file_name);
+								best_file_name = NULL;
+							}
+							best_file_name = strdup(file_name);
+							minimal_size = directory_size_distance((IconThemeDir*)dir->data, size);
+						}
+						if (((IconThemeDir*)dir->data)->size >= size && (next_larger_size == -1 || ((IconThemeDir*)dir->data)->size < next_larger_size)) {
+							if (next_larger) {
+								free(next_larger);
+								next_larger = NULL;
+							}
+							next_larger = strdup(file_name);
+							next_larger_size = ((IconThemeDir*)dir->data)->size;
+						}
+					}
+					free(file_name);
+				}
+			}
+		}
+	}
+	if (next_larger) {
+		g_slist_free(basenames);
+		g_slist_free(extensions);
+		free(best_file_name);
+		return next_larger;
+	}
+	if (best_file_name) {
+		g_slist_free(basenames);
+		g_slist_free(extensions);
+		return best_file_name;
+	}
+
+	// Stage 3: look in unthemed icons
+	{
+		GSList *base;
+		for (base = basenames; base; base = g_slist_next(base)) {
+			GSList *ext;
+			for (ext = extensions; ext; ext = g_slist_next(ext)) {
+				char *base_name = (char*) base->data;
+				char *extension = (char*) ext->data;
+				char *file_name = malloc(strlen(base_name) + strlen(icon_name) +
+					strlen(extension) + 100);
+				// filename = directory/iconname.extension
+				sprintf(file_name, "%s/%s.%s", base_name, icon_name, extension);
+				//printf("checking %s\n", file_name);
+				if (g_file_test(file_name, G_FILE_TEST_EXISTS)) {
+					g_slist_free(basenames);
+					g_slist_free(extensions);
+					return file_name;
+				} else {
+					free(file_name);
+					file_name = NULL;
+				}
+			}
+		}
+	}
+
+	fprintf(stderr, "Could not find icon %s\n", icon_name);
+
+	return NULL;
 }

src/launcher/launcher.h

@@ -13,16 +13,21 @@
 typedef struct Launcher {
 	// always start with area
 	Area area;
-	GSList *list_icon_paths;
-	GSList *list_cmds;
-	GSList *list_icons;
+	GSList *list_apps;			// List of char*, each is a path to a app.desktop file
+	GSList *list_icons; 		// List of LauncherIcon*
+	GSList *icon_theme_names; 	// List of char*, each is a theme name (oxygen, Tango...)
+	GSList *icon_themes;		// List of IconTheme*
 } Launcher;
 
 typedef struct LauncherIcon {
-	Imlib_Image icon;
+	Imlib_Image icon_scaled;
+	Imlib_Image icon_original;
 	char *cmd;
+	char *icon_name;
+	char *icon_path;
+	int icon_size;
+	int is_app_desktop;
 	int x, y;
-	int width, height;
 } LauncherIcon;
 
 typedef struct DesktopEntry {
@@ -41,6 +46,7 @@ typedef struct IconThemeDir {
 	int max_size;
 	int min_size;
 	int threshold;
+	char *context;
 } IconThemeDir;
 
 typedef struct IconTheme {
@@ -52,8 +58,6 @@ typedef struct IconTheme {
 extern int launcher_enabled;
 extern int launcher_max_icon_size;
 
-extern GSList *icon_themes; // each item is an IconTheme*
-
 // default global data
 void default_launcher();
 
@@ -68,5 +72,6 @@ void draw_launcher (void *obj, cairo_t *c);
 void launcher_action(LauncherIcon *icon);
 
 void test_launcher_read_desktop_file();
+void test_launcher_read_theme_file();
 
 #endif

src/panel.c

@@ -688,8 +688,8 @@ LauncherIcon *click_launcher_icon (Panel *panel, int x, int y)
 		LauncherIcon *icon;
 		for (l0 = launcher->list_icons; l0 ; l0 = l0->next) {
 			icon = l0->data;
-			if (x >= (launcher->area.posx + icon->x) && x <= (launcher->area.posx + icon->x + icon->width) &&
-				y >= (launcher->area.posy + icon->y) && y <= (launcher->area.posy + icon->y + icon->height)) {
+			if (x >= (launcher->area.posx + icon->x) && x <= (launcher->area.posx + icon->x + icon->icon_size) &&
+				y >= (launcher->area.posy + icon->y) && y <= (launcher->area.posy + icon->y + icon->icon_size)) {
 				//printf("Hit rect x=%d y=%d xmax=%d ymax=%d\n", launcher->area.posx + icon->x, launcher->area.posy + icon->y, launcher->area.posx + icon->x + icon->width, launcher->area.posy + icon->y + icon->height);
 				return icon;
 			}