nilix/tint2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Launcher support for .desktop files (working but experimental)

Browse source 
git-svn-id: http://tint2.googlecode.com/svn/trunk@538 121b4492-b84c-0410-8b4c-0d4edfb3f3cc
This commit is contained in:
o9000 2010-08-14 20:52:17 +00:00 committed by mrovi@interfete-web-club.com
parent ba24db4c6c
commit d4102b440d
4 changed files with 583 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/config.c
View file

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

689
src/launcher/launcher.c
View file

@ -36,6 +36,16 @@ int launcher_enabled;
int launcher_max_icon_size; int launcher_max_icon_size;
GSList *icon_themes = 0; 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() void default_launcher()
{ {
launcher_enabled = 0; 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); launcher->area.width = panel->area.width - (2 * panel->area.bg->border.width) - (2 * panel->area.paddingy);
} }
// Load icons fprintf(stderr, "Loading themes...\n");
{ launcher_load_themes(launcher);
GSList* path = launcher->list_icon_paths; fprintf(stderr, "Done\n");
GSList* cmd = launcher->list_cmds;
while (path != NULL && cmd != NULL) // Load apps (.desktop style launcher items)
{ GSList* app = launcher->list_apps;
LauncherIcon *launcherIcon = malloc(sizeof(LauncherIcon)); while (app != NULL) {
launcherIcon->icon = imlib_load_image(path->data); DesktopEntry entry;
launcherIcon->cmd = strdup(cmd->data); 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); 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; GSList *l;
for (l = launcher->list_icons; l ; l = l->next) { for (l = launcher->list_icons; l ; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon*)l->data; LauncherIcon *launcherIcon = (LauncherIcon*)l->data;
if (launcherIcon && launcherIcon->icon) { if (launcherIcon) {
imlib_context_set_image (launcherIcon->icon); free_icon(launcherIcon->icon_scaled);
imlib_free_image(); free_icon(launcherIcon->icon_original);
free(launcherIcon->icon_name);
free(launcherIcon->icon_path);
free(launcherIcon->cmd);
} }
free(launcherIcon->cmd);
free(launcherIcon); free(launcherIcon);
} }
g_slist_free(launcher->list_icons); 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); free(l->data);
} }
g_slist_free(launcher->list_icon_paths); g_slist_free(launcher->list_apps);
for (l = launcher->list_cmds; l ; l = l->next) {
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); 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; launcher_enabled = 0;
} }
@ -136,6 +164,48 @@ void resize_launcher(void *obj)
icon_size = icon_size - (2 * launcher->area.bg->border.width) - (2 * launcher->area.paddingy); icon_size = icon_size - (2 * launcher->area.bg->border.width) - (2 * launcher->area.paddingy);
if (launcher_max_icon_size > 0 && icon_size > launcher_max_icon_size) if (launcher_max_icon_size > 0 && icon_size > launcher_max_icon_size)
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; count = 0;
for (l = launcher->list_icons; l ; l = l->next) { for (l = launcher->list_icons; l ; l = l->next) {
@ -187,8 +257,6 @@ void resize_launcher(void *obj)
launcherIcon->y = posy; launcherIcon->y = posy;
launcherIcon->x = posx; launcherIcon->x = posx;
launcherIcon->width = icon_size;
launcherIcon->height = icon_size;
if (panel_horizontal) { if (panel_horizontal) {
if (i % icons_per_column) if (i % icons_per_column)
posy += icon_size + launcher->area.paddingx; posy += icon_size + launcher->area.paddingx;
@ -222,19 +290,7 @@ void draw_launcher(void *obj, cairo_t *c)
LauncherIcon *launcherIcon = (LauncherIcon*)l->data; LauncherIcon *launcherIcon = (LauncherIcon*)l->data;
int pos_x = launcherIcon->x; int pos_x = launcherIcon->x;
int pos_y = launcherIcon->y; int pos_y = launcherIcon->y;
int width = launcherIcon->width; Imlib_Image icon_scaled = launcherIcon->icon_scaled;
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);
}
// Render // Render
imlib_context_set_image (icon_scaled); imlib_context_set_image (icon_scaled);
if (server.real_transparency) { if (server.real_transparency) {
@ -244,6 +300,28 @@ void draw_launcher(void *obj, cairo_t *c)
imlib_context_set_drawable(launcher->area.pix); imlib_context_set_drawable(launcher->area.pix);
imlib_render_image_on_drawable (pos_x, pos_y); 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(); imlib_free_image();
} }
} }
@ -260,6 +338,8 @@ void launcher_action(LauncherIcon *icon)
/* http://standards.freedesktop.org/desktop-entry-spec/ */ /* http://standards.freedesktop.org/desktop-entry-spec/ */
/* http://standards.freedesktop.org/icon-theme-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) int parse_dektop_line(char *line, char **key, char **value)
{ {
char *p; char *p;
@ -280,6 +360,11 @@ int parse_dektop_line(char *line, char **key, char **value)
return 1; 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) void expand_exec(DesktopEntry *entry, const char *path)
{ {
// Expand % in exec // 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) int launcher_read_desktop_file(const char *path, DesktopEntry *entry)
{ {
FILE *fp; FILE *fp;
char line[4096]; char line[4096];
char *buffer;
char *key, *value; char *key, *value;
entry->name = entry->icon = entry->exec = NULL; 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); fprintf(stderr, "Could not open file %s\n", path);
return 0; return 0;
} }
buffer = line; while (fgets(line, sizeof(line), fp) != NULL) {
while (fgets(buffer, sizeof(line) - (buffer - line), fp) != NULL) { int len = strlen(line);
//TODO use UTF8 capable strlen if (len == 0)
int len = strlen(buffer); continue;
int total_len = strlen(line); line[len - 1] = '\0';
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;
if (parse_dektop_line(line, &key, &value)) { if (parse_dektop_line(line, &key, &value)) {
if (strcmp(key, "Name") == 0) { if (strcmp(key, "Name") == 0) {
//TODO use UTF-8 capable strdup
entry->name = strdup(value); entry->name = strdup(value);
} else if (strcmp(key, "Exec") == 0) { } else if (strcmp(key, "Exec") == 0) {
entry->exec = strdup(value); entry->exec = strdup(value);
} else if (strcmp(key, "Icon") == 0) { } else if (strcmp(key, "Icon") == 0) {
//TODO use UTF-8 capable strdup
entry->icon = strdup(value); entry->icon = strdup(value);
} }
} }
@ -385,100 +455,467 @@ int launcher_read_desktop_file(const char *path, DesktopEntry *entry)
return 1; return 1;
} }
void free_desktop_entry(DesktopEntry *entry)
{
free(entry->name);
free(entry->icon);
free(entry->exec);
}
void test_launcher_read_desktop_file() void test_launcher_read_desktop_file()
{ {
fprintf(stdout, "\033[1;33m");
DesktopEntry entry; DesktopEntry entry;
launcher_read_desktop_file("/usr/share/applications/firefox.desktop", &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); 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) 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) // 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 // Parse index.theme -> list of IconThemeDir with attributes
// Return IconTheme struct // Return IconTheme*
return NULL;
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 // 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 // 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 // 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;
// 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 1: exact size match GSList *basenames = NULL;
LookupIcon (iconname, size): basenames = g_slist_append(basenames, "~/.icons");
for each subdir in $(theme subdir list) { // <---- each subdir in each theme basenames = g_slist_append(basenames, "/usr/share/icons");
for each directory in $(basename list) { basenames = g_slist_append(basenames, "/usr/share/pixmaps");
for extension in ("png", "svg", "xpm") {
if DirectoryMatchesSize(subdir, size) {
filename = directory/$(themename)/subdirectory/iconname.extension
if exist filename
return filename
}
}
}
}
// Stage 2: best size match GSList *extensions = NULL;
minimal_size = MAXINT extensions = g_slist_append(extensions, "png");
for each subdir in $(theme subdir list) { // <---- each subdir in each theme extensions = g_slist_append(extensions, "xpm");
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 // Stage 1: exact size match
for each directory in $(basename list) { // <---- $HOME/.icons, /usr/share/icons, /usr/share/pixmaps GSList *theme;
for extension in ("png", "svg", "xpm") { for (theme = launcher->icon_themes; theme; theme = g_slist_next(theme)) {
if exists directory/iconname.extension GSList *dir;
return directory/iconname.extension 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)) {
return failed icon lookup 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;
}
}
}
}
}
}
// With the following helper functions: // 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;
}
DirectoryMatchesSize(subdir, iconsize): // Stage 3: look in unthemed icons
read Type and size data from subdir {
if Type is Fixed GSList *base;
return Size == iconsize for (base = basenames; base; base = g_slist_next(base)) {
if Type is Scaled GSList *ext;
return MinSize <= iconsize <= MaxSize for (ext = extensions; ext; ext = g_slist_next(ext)) {
if Type is Threshold char *base_name = (char*) base->data;
return Size - Threshold <= iconsize <= Size + Threshold 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;
}
}
}
}
DirectorySizeDistance(subdir, size): fprintf(stderr, "Could not find icon %s\n", icon_name);
read Type and size data from subdir
if Type is Fixed return NULL;
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
*/
} }

19
src/launcher/launcher.h
View file

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

4
src/panel.c
View file

@ -688,8 +688,8 @@ LauncherIcon *click_launcher_icon (Panel *panel, int x, int y)
LauncherIcon *icon; LauncherIcon *icon;
for (l0 = launcher->list_icons; l0 ; l0 = l0->next) { for (l0 = launcher->list_icons; l0 ; l0 = l0->next) {
icon = l0->data; icon = l0->data;
if (x >= (launcher->area.posx + icon->x) && x <= (launcher->area.posx + icon->x + icon->width) && 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->height)) { 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); //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; return icon;
} }