libublsettingsui-gtk3/source/libublsettingsui-gtk3-app-chooser.c

#include "libublsettingsui-gtk3.h"

struct return_struct {
    config_str chosen_apps;
    int size;
};

struct application {
    char *name;
    char *path;
    char *description;
    char *tags;
    char *execute;
    char *icon;
    config_str other;
    int other_size;

};

config_str yon_apps_get_from_file(char *file,int *final_size){
    (*final_size)=0;
    config_str final = NULL;
    int size;
    config_str parsed = yon_dir_get_contents(file,&size);
    for (int i=0;i<size;i++){
        if (strstr(parsed[i],".desktop")){
            char *path = yon_char_unite(file,"/",parsed[i],NULL);
            yon_char_parsed_add_or_create_if_exists(final,final_size,path);
        }
    }
    yon_char_parsed_free(parsed,size);
    return final;
}

int yon_app_chooser_apps_get(yon_app_chooser_window *window){
    window->apps = NULL;
    window->apps_size=0;
    int merged_size;
    config_str merged = NULL;

    // int temp_size;
    // config_str temp = yon_apps_get_from_file("/usr/shared/applications",&temp_size);

    // int local_size;
    // config_str local = yon_apps_get_from_file("/usr/local/shared/applications",&temp_size);
    
    window->apps = yon_apps_get_from_file("/usr/share/applications",&window->apps_size);
    return window->apps_size; 
}

void yon_block_visibility_if_unallowed(GtkWidget *self, GParamSpec* pspec,yon_app_chooser_window *window){
    if (gtk_widget_get_visible(window->MainWindow)){
        if (!window->visible_allowed)
            gtk_widget_set_visible(window->MainWindow,0);
        else g_signal_handlers_block_by_func(G_OBJECT(window->MainWindow),yon_block_visibility_if_unallowed,window);
    }
}

int yon_app_chooser_convert_apps(yon_app_chooser_window *window){
    GKeyFile *file = g_key_file_new();
    window->apps_convert = NULL;
    for (int i=0;i<window->apps_size;i++){
        if (g_key_file_load_from_file(file,window->apps[i],G_KEY_FILE_KEEP_TRANSLATIONS,NULL)){
            char *exec_temp = yon_char_new(window->apps[i]);
            free(yon_char_divide(exec_temp,yon_char_find_last(exec_temp,'/')));
            struct application *app = new(struct application);
            memset(app,0,sizeof(struct application));
            app->name = g_key_file_get_locale_string(file,"Desktop Entry","Name",setlocale(LC_ALL,NULL),NULL);
            app->description = g_key_file_get_locale_string(file,"[Desktop Entry","Comment",setlocale(LC_ALL,NULL),NULL);
            app->tags = g_key_file_get_string(file,"Desktop Entry","Categories",NULL);
            app->execute = yon_char_divide(exec_temp,yon_char_find_last(exec_temp,'.'));
            app->icon = g_key_file_get_string(file,"Desktop Entry","Icon",NULL);
            app->path = yon_char_new(window->apps[i]);
            yon_dictionary_add_or_create_if_exists_with_data(window->apps_convert,app->name,app);
            free(exec_temp);
        }
    }
    if (window->apps_convert) return 1; else return 0;
}

// int yon_tree_store_setup_apps(yon_app_chooser_window *window){
//     GtkTreeIter iter,itar;
//     GtkTreeModel *model = GTK_TREE_MODEL(window->treestore);
//     for_iter (model,&iter){
//         char *tags;
//         gtk_tree_model_get(model,&iter,3,&tags,-1);
//         int required_size;
//         config_str required_tags = yon_char_parse(tags,&required_size,";");

//         dictionary *dict;
//         for_dictionaries(dict,window->apps_convert){
//             int parsed_size;
//             struct application *cur_app = (struct application*)dict->data;
//             config_str parsed_tags = yon_char_parse(cur_app->tags,&parsed_size,";");
//             if (yon_char_parsed_includes_char_parsed(required_tags,parsed_tags,required_size,parsed_size)){
//                 gtk_tree_store_append(window->treestore,&itar,&iter);
//                 gtk_tree_store_set(window->treestore,&itar,0,0,1,cur_app->name,2,cur_app->description,3,cur_app->tags,4,0,5,cur_app->icon,6,cur_app->execute,-1);
//             }
//         }
//     }
// }

int yon_tree_store_setup_apps(yon_app_chooser_window *window){
    GtkTreeIter iter;
    dictionary *dict;
    for_dictionaries(dict,window->apps_convert){
        int parsed_size;
        struct application *cur_app = (struct application*)dict->data;
            gtk_tree_store_append(window->treestore,&iter,NULL);
            gtk_tree_store_set(window->treestore,&iter,0,0,1,cur_app->name,2,cur_app->description,3,cur_app->tags,4,0,5,cur_app->icon,6,cur_app->execute,-1);
     
    }
}

config_str yon_app_chooser_window_run(yon_app_chooser_window *window, int *size){
    gtk_widget_show(window->MainWindow);
    gtk_main();
    config_str final = window->final->chosen_apps;
    (*size)=window->final->size;
    free(window);
    return final;
}

void on_app_selection_toggled(GtkWidget *, char *path, yon_app_chooser_window *window){
    GtkTreeIter iter;
    int status;
    gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->treestore),&iter,path);
    gtk_tree_model_get(GTK_TREE_MODEL(window->treestore),&iter,0,&status,-1);
    gtk_tree_store_set(window->treestore,&iter,0,!status,-1);
}

void on_app_chooser_window_closed(GtkWidget *, yon_app_chooser_window *window){
    gtk_main_quit();
}

void on_app_chooser_accept(GtkWidget *, yon_app_chooser_window *window){
    GtkTreeIter iter;
    GtkTreeModel *model = GTK_TREE_MODEL(window->treestore);
    if (window->multiple){
        for_iter(model,&iter){
            int status;
            char *name;
            gtk_tree_model_get(GTK_TREE_MODEL(window->treestore),&iter,0,&status,6,&name,-1);
            if (status){
                yon_char_parsed_add_or_create_if_exists(window->final->chosen_apps,&window->final->size,name);
            }
        }
    } else {
        if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->MainTree)),&model,&iter)){
            char *name;
            gtk_tree_model_get(GTK_TREE_MODEL(window->treestore),&iter,1,&name,-1);
            yon_char_parsed_add_or_create_if_exists(window->final->chosen_apps,&window->final->size,name);
        }
    }
    gtk_widget_destroy(window->MainWindow);
}

int yon_app_chooser_window_select(yon_app_chooser_window *window,config_str selection,int size){
    GtkTreeIter iter;
    for(int i=0;i<size;i++){
        for_iter(GTK_TREE_MODEL(window->treestore),&iter){
            char *target;
            gtk_tree_model_get(GTK_TREE_MODEL(window->treestore),&iter,6,&target,-1);
            if (!yon_char_is_empty(target)&&!yon_char_is_empty(selection[i])&&!strcmp(target,selection[i])){
                gtk_tree_store_set(window->treestore,&iter,0,1,-1);
            }
        }
    }
}

yon_app_chooser_window *yon_app_chooser_window_new(int multiple_choise){
    yon_app_chooser_window *window = new(yon_app_chooser_window);
    GtkBuilder *builder = gtk_builder_new_from_resource(ui_glade_path_app_chooser);
    window->MainWindow = yon_gtk_builder_get_widget(builder,"MainWindow");
    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
    window->HeadLabel = yon_gtk_builder_get_widget(builder,"HeadLabel");
    window->WindowImage = yon_gtk_builder_get_widget(builder,"WindowImage");

    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->AcceptButton = yon_gtk_builder_get_widget(builder,"AcceptButton");

    window->MainTree = yon_gtk_builder_get_widget(builder,"MainTree");
    window->SelectionCell = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"SelectionCell"));
    window->treestore = GTK_TREE_STORE(gtk_builder_get_object(builder,"treestore1"));

    window->MainIconView = yon_gtk_builder_get_widget(builder,"MainIconView");
    window->liststore = GTK_LIST_STORE(gtk_builder_get_object(builder,"liststore1"));

    window->visible_allowed=0;
    window->final = new(struct return_struct);

    memset(window->final,0,sizeof(struct return_struct));

    g_signal_connect(G_OBJECT(window->MainWindow),"notify::visibile",G_CALLBACK(yon_block_visibility_if_unallowed),window);
    g_signal_connect(G_OBJECT(window->MainWindow),"destroy",G_CALLBACK(on_app_chooser_window_closed),window);
    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_app_chooser_accept),window);
    g_signal_connect(G_OBJECT(window->SelectionCell),"toggled",G_CALLBACK(on_app_selection_toggled),window);
    
    window->multiple = multiple_choise;
    
    if (!window->multiple){
        gtk_cell_renderer_set_visible(GTK_CELL_RENDERER(window->SelectionCell),0);
    }


    if (!yon_app_chooser_apps_get(window)) return NULL;
    if (!yon_app_chooser_convert_apps(window)) return NULL;
    yon_tree_store_setup_apps(window);

    return window;
}