#include "ubl-utils.h"

// dictionary functions

/**[EN]
 * yon_dictionary_create_empty():
 * Creates and returns empty dictionary
 */
dictionary *yon_dictionary_create_empty()
{
    dictionary *dict = malloc(sizeof(dictionary));
    dict->data = NULL;
    dict->key = NULL;
    dict->next = NULL;
    dict->prev = NULL;
    dict->first = dict;
    dict->data_type = DICTIONARY_OTHER_TYPE;
    return dict;
}

void yon_dictionary_switch_to_last(dictionary **dict)
{
    if ((*dict)->next != NULL)
        for ((*dict) = (*dict)->first; (*dict)->next != NULL; (*dict) = (*dict)->next)
        {
        }
}

dictionary *yon_dictionary_create_conneced(dictionary *targetdict)
{
    targetdict = yon_dictionary_get_last(targetdict);
    targetdict->next = yon_dictionary_create_empty();
    targetdict->next->prev = targetdict;
    targetdict->next->first = targetdict->first;
    targetdict->next->data_type = DICTIONARY_OTHER_TYPE;
    return targetdict->next;
}

dictionary *yon_dictionary_get_last(dictionary *dict)
{
    dictionary *dct = NULL;
    for (dct = dict->first; dct->next != NULL; dct = dct->next)
    {
    }
    return dct;
}

dictionary *yon_dictionary_switch_places(dictionary *dict, int aim)
{
    if (aim < 0)
    {
        if (dict->prev)
        {
            if (dict->prev->prev)
            {
                dictionary *next = dict->next, *prev = dict->prev, *preprev = prev->prev;
                if (next)
                {
                    preprev->next = dict;
                    dict->prev = preprev;
                    dict->next = prev;
                    prev->prev = dict;
                    prev->next = next;
                    next->prev = prev;
                }
                else
                {
                    preprev->next = dict;
                    dict->prev = preprev;
                    dict->next = prev;
                    prev->prev = dict;
                    prev->next = NULL;
                }
                return prev;
            }
            else
            {
                dictionary *next = dict->next, *prev = dict->prev;
                if (next)
                {
                    yon_dictionary_make_first(dict);
                    dict->prev = NULL;
                    dict->next = prev;
                    prev->prev = dict;
                    prev->next = next;
                    next->prev = prev;
                }
                else
                {
                    dict->prev = NULL;
                    dict->next = prev;
                    prev->prev = dict;
                    prev->next = NULL;
                }
                return prev;
            }
        }
    }
    else if (aim > 0)
    {
        if (dict->next)
        {
            if (dict->next->next)
            {
                dictionary *next = dict->next, *prev = dict->prev, *afnext = next->next;
                if (prev)
                {
                    prev->next = next;
                    next->prev = prev;
                    next->next = dict;
                    dict->prev = next;
                    dict->next = afnext;
                    afnext->prev = dict;
                }
                else
                {
                    yon_dictionary_make_first(next);
                    next->prev = NULL;
                    next->next = dict;
                    dict->prev = next;
                    dict->next = afnext;
                    afnext->prev = dict;
                }
                return next;
            }
            else
            {
                dictionary *next = dict->next, *prev = dict->prev;
                if (prev)
                {
                    prev->next = next;
                    next->prev = prev;
                    next->next = dict;
                    dict->prev = next;
                    dict->next = NULL;
                }
                else
                {
                    next->prev = NULL;
                    next->next = dict;
                    dict->prev = next;
                    dict->next = NULL;
                }
            }
        }
    }
}

void yon_dictionary_make_first(dictionary *dict)
{
    for (dictionary *dct = dict->first; dct != NULL; dct = dct->next)
    {
        dct->first = dict;
    }
}

void yon_dictionary_make_nth(dictionary *dict, int nth)
{
    dictionary *dct = dict->first;
    for (int i = 0; i < nth; i++)
    {
        if (dct == NULL)
            return;
        else
            dct = dct->next;
    }
    yon_dictionary_rip(dict);
    dictionary *prev = dct->prev;
    prev->next = dict;
    dict->prev = prev;
    dict->next = dct;
    dct->prev = dict;
}

dictionary *yon_dictionary_create_with_data(char *key, void *data)
{
    dictionary *dct = yon_dictionary_create_empty();
    dct->key = yon_char_new(key);
    dct->data = data;
    dct->data_type = DICTIONARY_OTHER_TYPE;
    return dct;
}

/** void *yon_dictionary_free_all(dictionary *dictionary,void *data_manipulation)
 * [EN]
 * Frees whole [dictionary] and activates [data_manipulation] function if not NULL with [dictionary]->data argument for each dictionary.
 * [RU]
 * Освобождает память для всех элементов словаря [dictionary] и активирует функцию [data_manipulation], если она была передана, с аргументом [dictionary]->data на каждый элемент словаря.
*/
void *yon_dictionary_free_all(dictionary *dictionary_to_free,void (*data_manipulation)(void*)){
    dictionary *dict=NULL;
    for_dictionaries(dict,dictionary_to_free){
        if(data_manipulation)
            data_manipulation(dict->data);
        if(dict->prev)
            free(dict->prev);
    }
    free(dict);
    return NULL;
}

dictionary *yon_dictionary_create_with_data_connected(dictionary *dict, char *key, void *data)
{
    dictionary *dct = yon_dictionary_create_conneced(dict);
    dct->key = yon_char_new(key);
    dct->data = data;
    dct->data_type = DICTIONARY_OTHER_TYPE;
    return dct;
}

dictionary *yon_dictionary_connect(dictionary *old, dictionary *toconnect)
{
    dictionary *dict = yon_dictionary_get_last(old);
    dict->next = toconnect;
    toconnect->prev = dict;
    toconnect->first = dict->first;
    return toconnect;
}

dictionary *yon_dictionary_find(dictionary **dict, char *key)
{
    dictionary *dct = *dict;
    for (dictionary *pointer = dct->first; pointer != NULL; pointer = pointer->next)
    {
        if (strcmp(pointer->key, key) == 0)
        {
            *dict = pointer;
            return pointer;
        }
    }
    return NULL;
}

dictionary *yon_dictionary_rip(dictionary *dict)
{
    if (!dict->next&&!dict->prev) return NULL;
    else if (!dict->next)
    {
        dictionary *prev = dict->prev;
        if (prev)
        {
            prev->next = NULL;
            return prev;
        }
        else
            return dict;
    }
    else if (!dict->prev)
    {
        dictionary *next = dict->next;
        if (next)
        {
            yon_dictionary_make_first(next);
            next->prev = NULL;
            return next;
        }
        else
            return dict;
    }
    else
    {
        dictionary *next = dict->next, *prev = dict->prev;
        next->prev = prev;
        prev->next = next;
        return next;
    }
}

dictionary *yon_dictionary_get_nth(dictionary *dict, int place)
{
    if (dict){
        dict = dict->first;
        int i = 0;
        for (i = 0; i < place; i++)
            if (dict->next)
                dict = dict->next;
            else
                break;
        if (i == place)
            return dict;
        else
            return NULL;
    } else return NULL;
}

// char functions

/**[EN]
 * 
 * creates new char string by combining two char strings.
 */
char *yon_char_get_augumented(char *source, char *append)
{
    if (source && append)
    {
        int size = strlen(source) + strlen(append) + 1;
        char *final = malloc(size);
        memset(final, 0, size);
        if (strstr(source, "%%"))
            sprintf(final, source, append);
        else
            sprintf(final, "%s%s", source, append);
        return final;
    }
    else
        return NULL;
}

/**[EN]
 * 
 * creates new char string by copying another char.
 */
char *yon_char_new(char *chr)
{
    if (chr){
        char *newchar = malloc(strlen(chr) + 1);
        memset(newchar, 0, strlen(chr) + 1);
        memcpy(newchar, chr, strlen(chr));
        return newchar;
    } else
        return NULL;
}

// char *yon_char_unite(char *source, ...)

char *yon_char_unite(char *source, ...){
    va_list arglist;
    char *new_char=NULL;
    char *unite_char=NULL;
    new_char=yon_char_new(source);
    va_start(arglist,source);
    unite_char = va_arg(arglist,char*);
    while(unite_char){
        new_char = yon_char_get_augumented(new_char,unite_char);
        unite_char = va_arg(arglist,char*);
    }
    va_end(arglist);
    return new_char;
}

/**[EN]
 * 
 * cuts source string by size length from startpos position.
 */
char *yon_cut(char *source, int size, int startpos)
{
    char *cut = NULL;
    cut = malloc(size + 1);
    memset(cut, 0, size + 1);
    memcpy(cut, source + startpos, size);
    return cut;
}
/**[EN]
 * 
 * divides source string in dividepos position,
 * returning left part of divided string and
 * inserting right part to source string.
 */
char *yon_char_divide(char *source, int dividepos)
{
    char *cut = malloc(dividepos + 1);
    memset(cut, 0, dividepos + 1);
    memcpy(cut, source, dividepos);
    char *left = malloc(strlen(source) - strlen(cut));
    memset(left, 0, strlen(source) - strlen(cut));
    memcpy(left, source + dividepos + 1, (strlen(source) - dividepos));
    memset(source, 0, strlen(source));
    memcpy(source, left, strlen(left));
    return cut;
}

int yon_char_find_count(char *source, char *find){
    char *working_string=yon_char_new(source);
    int i=0;
    int size=0;
    int pos=0;
    config_str rtn = yon_char_parse(working_string,&size,"\n");
    for (int j=0;j<size;j++){
        if(strstr(rtn[j],find))
            i++;
    }
    printf("%d\n",i);
    return i;
}

/**[EN]
 * char *yon_char_divide_search(char *source, char *dividepos, int delete_divider)
 * searches string [dividepos] in [source] string and divides it,
 * returning left part of divided string and
 * inserting right part to [source] string.
 * if [delete_divider] is 0, left part will contain [delete_divider] substring, else
 * if [delete_divider] is 1 it will stay in right part, else
 * if [delete_divider] is -1 it will be deleted from string.
 * 
 * [RU]
 * char *yon_char_divide_search(char *source, char *dividepos, int delete_divider)
 * Ищет строку [dividepos] в строке [source] и делит её в этом месте,
 * возвращая левую часть разделённой строки и устанавливает в [source] правую часть.
 * Если [delete_divider] равен 0, [dividepos] останется в левой строке, иначе
 * если [delete_divider] равен 1, [dividepos] останется в правой строке, иначе
 * если [delete_divider] равен -1, [dividepos] удаляется из строки.
 */
char *yon_char_divide_search(char *source, char *dividepos, int delete_divider)
{
    if (source&&dividepos){
        char *cut = strstr(source, dividepos);
        if (cut)
        {
            int leng = strlen(source) - strlen(cut);
            cut = yon_char_divide(source, leng);
            return cut;
        }
        else
            return source;
    }
}

/**[EN]
 * char *yon_char_from_int(int int_to_convert)
 * converts int to char*.
 * 
 * [RU]
 * char *yon_char_from_int(int int_to_convert)
 * Конвертирует int в char*
 */
char *yon_char_from_int(int int_to_convert)
{
    int i = 1;
    float convert_check = (float)int_to_convert;
    for (i = 1; convert_check > 10; i++)
    {
        convert_check = convert_check / 10;
    }
    char *ch = malloc(i * sizeof(char) + 1);
    sprintf(ch, "%d", int_to_convert);
    return ch;
}

char *yon_char_replace(char *source, char *find, char*replace){ 
    char *final=NULL;
    char *temp=NULL;
    if(!strstr(replace,find)){
        while ((final=strstr(source,find))){
            temp=malloc(strlen(source)-strlen(final));
            memset(temp,0,strlen(source)-strlen(final)+strlen(replace));
            memcpy(temp,source,strlen(source)-strlen(final));
            temp=yon_char_get_augumented(temp,replace);
            source=yon_char_get_augumented(temp,final+1);
        }
        return source;
    }
}

/**[EN]
 * char **yon_char_parse(char *parameters, int *size, char *divider)
 * Parses string [parameters], divided by [divider],
 * then returns parsed string array and sets [size] to
 * size of returned array
*/
char **yon_char_parse(char *parameters, int *size, char *divider){
    char **string=NULL;
    int i=1;
    string=malloc(sizeof(char*));
    char *paramline=yon_char_new(parameters);
    char *param;
    while ((param=yon_char_divide_search(paramline,divider,1))){
        string=realloc(string,sizeof(char*)*i);
        string[i-1]=yon_char_new(param);
        i++;
        if (strcmp(param,paramline)==0) break;
    }
    string=realloc(string,sizeof(char*)*i);
        string[i-1]=yon_char_new(paramline);
        i++;
    // printf("%d\n",i);
    *size=i-1;
    return string;

}

char **yon_char_parsed_shrink(char **char_string, int *size, int item_to_delete){
    char **new_char_parsed=NULL;
    new_char_parsed=malloc(sizeof(char*)*(*size)-2);
    int sz=0;
    for (int i=0;i<*size-2;i++){
        if (i!=item_to_delete){
            new_char_parsed[i]=yon_char_new(char_string[i]);
            sz++;
        }
        
    }
    *size=sz;
    return new_char_parsed;
}

/**[EN]
 * 
 * Checks if [parameters] string array of length [size]
 * has [param] element;
*/
int yon_char_parsed_check_exist(char **parameters, int size, char *param){
    
    for (int i=0;i<size;i++){
        if (parameters[i]){
        if (strstr(parameters[i],param))
            return i;
        } else return -1;
    }

    return -1;
}
int yon_char_parsed_includes_char_parsed (config_str source, config_str to_check, int source_size, int check_size){
    int overall_found=0;
    for (int i=0;i<source_size;i++){
        int found=0;
        for (int j=0;j<check_size;j++){
            if (strcmp(source[i],to_check[j])==0&&found==0) { found=1; overall_found++; }
        }
    }
    if (overall_found==check_size)
        return 1;
    else return 0;
}

config_str yon_char_parsed_new (config_str old, int *old_size, ...){
    va_list arglist;
    int new_size=0;
    config_str new_parsed=NULL;
    if (old){
        new_size=*old_size;
        new_parsed=old;
    }else {
        new_parsed=new(char*);
    }

    va_start(arglist,old_size);
    char *newparse = va_arg(arglist,char*);
    while (newparse){
        new_size++;
        new_parsed=realloc(new_parsed,new_size*sizeof(char*));
        new_parsed[new_size-1]=yon_char_new(newparse);
        newparse=va_arg(arglist,char*);
    }
    va_end(arglist);
    *old_size=new_size;
    return new_parsed;
}


// parsing functions

apps *yon_apps_scan_and_parse_desktops(int *sizef)
{
    int size = 0;
    struct apps *applist;
    {
        DIR *directory = opendir(DesktopPath);
        struct dirent *de;
        while ((de = readdir(directory)))
        {
            FILE *file;
            char *path = yon_char_get_augumented(DesktopPath, de->d_name);
            file = fopen(path, "r");
            if (strlen(de->d_name) > 9)
            {
                char *extension = strstr(path, ".");
                if (extension != NULL)
                {
                    if (strcmp(extension, ".desktop") == 0)
                    {
                        apps tempapp;
                        GKeyFile *gfile = g_key_file_new();
                        GError *err = NULL;
                        g_key_file_load_from_file(gfile, path, G_KEY_FILE_KEEP_TRANSLATIONS, NULL);
                        char *Type = g_key_file_get_string(gfile, "Desktop Entry", "Type", &err);
                        if (err)
                        {
                            printf("%s\n", err->message);
                        }
                        if (strcmp(Type, "Application") == 0)
                            tempapp.Type = 1;
                        else if (strcmp(Type, "pyApplication") == 0)
                            tempapp.Type = 2;
                        else
                            continue;
                        tempapp.Name = g_key_file_get_locale_string(gfile, "Desktop Entry", "Name", setlocale(LC_ALL, NULL), NULL);
                        if (tempapp.Name == NULL)
                            continue;
                        tempapp.Categories = g_key_file_get_string(gfile, "Desktop Entry", "Categories", NULL);
                        if (tempapp.Categories == NULL)
                            continue;
                        tempapp.Exec = g_key_file_get_string(gfile, "Desktop Entry", "Exec", NULL);
                        if (tempapp.Exec == NULL)
                            continue;
                        tempapp.Icon = g_key_file_get_string(gfile, "Desktop Entry", "Icon", NULL);
                        if (tempapp.Icon == NULL)
                            continue;
                        tempapp.Pluggable = g_key_file_get_boolean(gfile, "Desktop Entry", "Pluggable", NULL);
                        if (!tempapp.Pluggable)
                            tempapp.Pluggable = g_key_file_get_boolean(gfile, "Desktop Entry", "X-XfcePluggable", NULL);
                        if (tempapp.Pluggable)
                            tempapp.DualPluggable = g_key_file_get_boolean(gfile, "Desktop Entry", "X-UBLPluggable", NULL);
                        if (g_key_file_get_boolean(gfile, "Desktop Entry", "X-UBL-SettingsManager-Hidden", NULL) == 0)
                            if (size == 0)
                            {
                                applist = (apps *)malloc(size + 1 * sizeof(apps));
                                applist[0].Name = yon_char_new(tempapp.Name);
                                applist[0].Categories = yon_char_new(tempapp.Categories);
                                applist[0].Exec = yon_char_new(tempapp.Exec);
                                applist[0].Icon = yon_char_new(tempapp.Icon);
                                applist[0].Type = tempapp.Type;
                                applist[0].Pluggable = tempapp.Pluggable;
                                applist[0].DualPluggable = tempapp.DualPluggable;
                                size++;
                            }
                            else
                            {
                                applist = (apps *)realloc(applist, (size + 1) * sizeof(apps));
                                applist[size].Name = yon_char_new(tempapp.Name);
                                applist[size].Categories = yon_char_new(tempapp.Categories);
                                applist[size].Exec = yon_char_new(tempapp.Exec);
                                applist[size].Icon = yon_char_new(tempapp.Icon);
                                applist[size].Pluggable = tempapp.Pluggable;
                                applist[size].DualPluggable = tempapp.DualPluggable;
                                applist[size].Type = tempapp.Type;
                                size++;
                            }
                    }
                }
            }
        }
    }
    *sizef = size;
    return applist;
};

void yon_apps_sort(apps *applist, int size)
{
    apps tmp;
    if (size > 2)
    {
        for (int i = 1; i < size; i++)
        {
            for (int j = 1; j < size; j++)
            {
                if (strcmp(applist[j].Name, applist[j - 1].Name) < 0)
                {
                    tmp = applist[j];
                    applist[j] = applist[j - 1];
                    applist[j - 1] = tmp;
                };
            }
        };
    }
};

apps *yon_apps_get_by_name(apps *applist, char *name, int size)
{
    for (int i = 0; i < size; i++)
    {
        if (strcmp(applist[i].Name, name) == 0)
            return &applist[i];
    }
    return NULL;
};

config_str yon_config_load(char *command, int *str_len)
{
    FILE *output = popen(command, "r");
    char **output_strings = NULL;
    output_strings = malloc(sizeof(char));
    int i = 0;
    char str[1000];
    memset(str, 0, 1000);
    while (fgets(str, 1000, output))
    {
        if (strcmp(str, "") != 0)
        {
            output_strings = realloc(output_strings, sizeof(char *) * (i + 1));
            // printf("%s\n", str);
            output_strings[i] = NULL;
            output_strings[i] = yon_char_new(str);
            memset(str, 0, 1000);
            i++;
        }
    }
    if (i>0){
    *str_len = i;
    return output_strings;
    } else{
        *str_len=-1;
        return NULL;
    }
}

/**[EN]
 * int yon_config_save(char *command)
 * Saves config with [command]
 * [RU]
*/
int yon_config_save(char *command)
{
    FILE *output = popen(command, "r");
    return 1;
}

/**[EN]
 * char *yon_config_get_parameter(config parameters, int size, char *param)
 * Gets parameter from parameter list;
 * 
 * [RU] 
*/
char *yon_config_get_parameter(config_str parameters, int size, char *param)
{
    if (param[0]==' ')
        yon_char_divide_search(param," ",-1);
    param=yon_char_divide_search(yon_char_new(param)," ",-1);
    
    char *str = NULL;
    for (int j = 0; j < size; j++)
    {
        char *name = yon_char_divide_search(yon_char_new(parameters[j]), "=", 1);
        if (name)
        {
            if (strcmp(name, param) == 0)
            {
                str = yon_char_divide_search(yon_char_new(parameters[j]), "\n", 1);
                if (strcmp(str, "") != 0 && strcmp(str, "(null)") != 0)
                    return str;
                else
                    return NULL;
            }
        }
    }
    return NULL;
}

/**[EN]
 * Parses, modifies and connects string to use it as one of arguments,
 * sended to ubconfig.
 * 
 * [RU]
 */
char *yon_config_make_save_parameter_with_multiple_arguments(char *parameter_string, char *config_parameter, char *divider){
    char *final="";
    int done=0;
    char *cur=yon_char_new(parameter_string);
    yon_char_divide_search(cur,"=",1);
    char *cur_param=NULL;
    while (cur_param=yon_char_divide_search(cur,",",1)){
        if (done==0){
        final=yon_char_get_augumented(final,yon_char_get_augumented(yon_char_get_augumented(config_parameter,"="), yon_char_get_augumented(cur_param,", ")));
        done=1;
        } else {
        final=yon_char_get_augumented(final,yon_char_get_augumented(yon_char_get_augumented(config_parameter,"+="), yon_char_get_augumented(cur_param,", ")));    
        }
    } 
    if (cur&&strcmp(cur,"")!=0)
        if (done==0)
        final=yon_char_get_augumented(final,yon_char_get_augumented(yon_char_get_augumented(config_parameter,"="), yon_char_get_augumented(cur,", ")));
        else
        final=yon_char_get_augumented(final,yon_char_get_augumented(yon_char_get_augumented(config_parameter,"+="), yon_char_get_augumented(cur,", ")));
    return final;
}

// terminal-using functions

int yon_launch_app(char *name)
{
    char *path = name;
    thread_output *thread = malloc(sizeof(thread_output));
    thread->command = path;
    thread->exitcode = malloc(sizeof(int));
    pthread_t thread_id;
    pthread_create(&thread_id, NULL, (void *)yon_launch, thread);
    return *thread->exitcode;
};

int yon_launch_app_with_arguments(char *name, char *args)
{
    char *path = yon_char_get_augumented("/usr/bin/", name);
    path = yon_char_get_augumented(path, " ");
    path = yon_char_get_augumented(path, args);
    pthread_t thread_id;
    thread_output *thread = malloc(sizeof(thread_output));
    thread->command = path;
    thread->exitcode = malloc(sizeof(int));
    pthread_create(&thread_id, NULL, (void *)yon_launch, thread);
    return *thread->exitcode;
};

int yon_launch(thread_output *thread)
{
    int a = 0;
    a = system(thread->command);
    *thread->exitcode = a;
    return *thread->exitcode;
}

// Gtk functions


#ifdef __GTK_H__


static render_data render;

#ifdef VTE_TERMINAL

/**
 * void yon_terminal_integrated_launch(GtkWidget *place_to_show, void *endwork_function, void* endwork_function_argument)
 * [EN]
 * launches terminal with specific [command],
 * terminal is shown in [place_to_show] container,
 * after terminal done its work [endwork_function] is called with [endwork_function_argument] argument.
 * [RU]
 * Запускает терминал с командой [command],
 * терминал добавляется в контейнер [place_to_show] виджета,
 * после завершения работы терминала вызывается функция [endwork_function] с аргументом [endwork_function_argument].
*/
void yon_terminal_integrated_launch(GtkWidget *place_to_show, char* command, void *endwork_function, void* endwork_function_argument){
    GtkWidget *terminal = vte_terminal_new();
    vte_terminal_set_size(VTE_TERMINAL(terminal),10,15);
    VtePty *pty = vte_pty_new_sync(VTE_PTY_DEFAULT,NULL,NULL);
    vte_terminal_set_pty(VTE_TERMINAL(terminal),pty);
    char *install_command=yon_char_unite("tput cup 0 0 && tput ed; ",command,"  ; sleep 5;exit 0","\n",NULL); 
    g_signal_connect(G_OBJECT(terminal), "child-exited", G_CALLBACK(on_terminal_done), widgets);
     vte_terminal_spawn_async(VTE_TERMINAL(terminal),
        VTE_PTY_DEFAULT,
        NULL,   
        install_command,   
        NULL,  
        0,      
        NULL, NULL,
        NULL,   
        -1, 
        NULL, 
        NULL,    
        NULL); 
    vte_pty_spawn_async(pty,
        NULL,        
        install_command,      
        NULL,         
        0,            
        NULL, NULL,   
        NULL,         
        -1,           
        NULL,         
        NULL,           
        NULL);        
        vte_terminal_set_scrollback_lines(VTE_TERMINAL(terminal), 100);
        vte_terminal_set_scroll_on_output(VTE_TERMINAL(terminal), TRUE);
        vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(terminal), TRUE);
        gtk_widget_show_all(widgets->TerminalRevealer);
    }

#endif

int yon_gtk_combo_box_fill(GtkWidget *combo, config_str parameters,int size){
    if (combo&&parameters){
        for (int i=0;i<size;i++){
            gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo),parameters[i]);
        }
        return 1;
    } else
    return 0;
}

int yon_gtk_combo_box_text_find(GtkWidget *combo_box, char *text_to_find){
    if (combo_box&&text_to_find){
        int active=gtk_combo_box_get_active(GTK_COMBO_BOX(combo_box));
        char *str="-1";
        for (int i=0;strcmp(str,"")!=0;i++){
            gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box),i);
            str=gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo_box));
            if (!str) return -1;
            if (strstr(str,text_to_find)) return i;
        }
    } return -1;
}

int yon_dictionary_gtk_pack_start_multiple_widgets(dictionary *dict, GtkWidget *destination, gboolean expand, gboolean fill, int padding)
{
    if (dict){
        for (dictionary *dct = dict->first; dct != NULL; dct = dct->next)
        {
            gtk_box_pack_start(GTK_BOX(destination), (GtkWidget *)dct->data, expand, fill, padding);
        }
    return 1;
    }else return 0;
}

int yon_dictionary_gtk_pack_end_multiple_widgets(dictionary *dict, GtkWidget *destination, gboolean expand, gboolean fill, int padding)
{
    for (dictionary *dct = dict->first; dct != NULL; dct = dct->next)
    {
        gtk_box_pack_end(GTK_BOX(destination), (GtkWidget *)dct->data, expand, fill, padding);
    }
    return 1;
}

void _yon_ubl_header_setup(GtkWidget *Overlay, GtkWidget *Head, GtkWidget *Image, char *image_path)
{
    gtk_overlay_add_overlay(GTK_OVERLAY(Overlay), Head);
    gtk_image_set_from_file(GTK_IMAGE(Image), image_path);
}

int yon_ubl_status_box_setup(GtkWidget *icon, GtkWidget *box, GtkWidget *label)
{
    if(icon&&box&&label){
        render.icon=icon;
        render.box=box;
        render.label=label;
        return 1;
    } else return 0;
} 

/**
 * 
*/
void _yon_ubl_status_box_render(char *text, BACKGROUND_IMAGE_TYPE type)
{
    render_data data = render;
    GtkIconTheme *ictheme = gtk_icon_theme_get_default();
    GError *err = NULL;
    if (err)
    {
        printf("%s\n", err->message);
        g_error_free(err);
    }
    if (type == BACKGROUND_IMAGE_SUCCESS_TYPE||! type)
    {
        gtk_style_context_remove_class(gtk_widget_get_style_context(data.box), "boxInfoMessError");
        gtk_style_context_add_class(gtk_widget_get_style_context(data.box), "boxInfoMessOK");
        gtk_image_set_from_pixbuf(GTK_IMAGE(data.icon), gtk_icon_theme_load_icon_for_scale(ictheme, "com.ublinux.ubl-settings-video.checked", 25, 1, GTK_ICON_LOOKUP_FORCE_SIZE, &err));
    }
    else if (type == BACKGROUND_IMAGE_FAIL_TYPE)
    {
        gtk_style_context_remove_class(gtk_widget_get_style_context(data.box), "boxInfoMessOK");
        gtk_style_context_add_class(gtk_widget_get_style_context(data.box), "boxInfoMessError");
        gtk_image_set_from_pixbuf(GTK_IMAGE(data.icon), gtk_icon_theme_load_icon_for_scale(ictheme, "com.ublinux.ubl-settings-video.warning", 25, 1, GTK_ICON_LOOKUP_FORCE_SIZE, &err));
    }
    if (text)
        gtk_label_set_text(GTK_LABEL(data.label), text);
}


void yon_ubl_status_box_render(char *text, BACKGROUND_IMAGE_TYPE type){
    _yon_ubl_status_box_render(text,type);
}

/**yon_ubl_setup_sockets(GtkWidget *main_window, GtkWidget *left_window, GtkWidget *right_window, int socket_main_id, int socket_left_id, int socket_right_id)
 * [EN]
 * Set up plugs for using with GtkSockets insine ubl-settings-manager.
 * [main_window] is container widget, which holds main application functionality.
 * [left_window] is container widget, which holds widgets, have to be shown at left part of ubl-settings-manager header.
 * [right_window] is container widget, which holds widgets, have to be shown at right part of ubl-settings-manager header.
 * [socket_main_id] is id of socket for [main_window].
 * [socket_left_id] is id of socket for [left_window].
 * [socket_right_id] is id of socket for [right_window].
 * [RU]
 * Настраивает плаги для работы с сокетами в утилите ubl-settings-manager.
 * [main_window] - контейнер основного интерфейса приложения.
 * [left_window] - контейнер для виджетов которые должны отображаться в левой части шапки ubl-settings-manager.
 * [right_window] - контейнер для виджетов которые должны отображаться в правой части шапки ubl-settings-manager.
 * [socket_main_id] - id сокета для [main_window].
 * [socket_left_id] - id сокета для [left_window].
 * [socket_right_id] - id сокета для [right_window].
*/
void yon_ubl_setup_sockets(GtkWidget *main_window, GtkWidget *left_window, GtkWidget *right_window, int socket_main_id, int socket_left_id, int socket_right_id){
    if (main_window&&socket_main_id>-1){
        gtk_widget_hide(gtk_widget_get_toplevel(main_window));
        GtkWidget *plug_main=gtk_plug_new(socket_main_id);
        GtkWidget *plug_left=NULL;
        GtkWidget *plug_right=NULL;
        GtkWidget *box=NULL;
        g_signal_connect(G_OBJECT(plug_main), "destroy", G_CALLBACK(gtk_main_quit),NULL);
        if (socket_left_id>-1&&left_window){
            plug_left=gtk_plug_new(socket_left_id);
            g_object_ref(left_window);
            gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(left_window)),left_window);
            gtk_container_add(GTK_CONTAINER(plug_left),left_window);
        gtk_style_context_add_class(gtk_widget_get_style_context(plug_left),"primary-toolbar");
        gtk_style_context_add_class(gtk_widget_get_style_context(left_window),"button");
        gtk_style_context_add_class(gtk_widget_get_style_context(left_window),"opacited");
        gtk_style_context_add_class(gtk_widget_get_style_context(left_window),"color");
        gtk_style_context_add_class(gtk_widget_get_style_context(plug_left),"noborder");
            gtk_widget_show(plug_left);
        }
        else if (left_window){
            if (box==NULL){
                box=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
                gtk_box_pack_start(GTK_BOX(main_window),box,0,0,5);
                gtk_box_reorder_child(GTK_BOX(main_window),box,0);
                gtk_widget_show(box);
            }
            gtk_style_context_add_class(gtk_widget_get_style_context(left_window),"inherited");
            gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(left_window)),left_window);
            gtk_box_pack_end(GTK_BOX(box),left_window,0,0,5);
        }
        if (socket_right_id>-1&&right_window){
            plug_right=gtk_plug_new(socket_right_id);
            g_object_ref(right_window);
            gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(right_window)),right_window);
            gtk_container_add(GTK_CONTAINER(plug_right),right_window);
        gtk_style_context_add_class(gtk_widget_get_style_context(plug_right),"primary-toolbar");
        gtk_style_context_add_class(gtk_widget_get_style_context(right_window),"button");
        gtk_style_context_add_class(gtk_widget_get_style_context(right_window),"opacited");
        gtk_style_context_add_class(gtk_widget_get_style_context(right_window),"color");
        gtk_style_context_add_class(gtk_widget_get_style_context(plug_right),"noborder");
            gtk_widget_show(plug_right);
        }
        else if (right_window){
            if (box==NULL){
                box=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
                gtk_box_pack_start(GTK_BOX(main_window),box,0,0,5);
                gtk_box_reorder_child(GTK_BOX(main_window),box,0);
                gtk_widget_show(box);
            }
            gtk_style_context_add_class(gtk_widget_get_style_context(right_window),"inherited");
            gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(right_window)),right_window);
            gtk_box_pack_start(GTK_BOX(box),right_window,0,0,5);
        }
        g_object_ref(main_window);
        gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(main_window)),main_window);
        gtk_container_add(GTK_CONTAINER(plug_main),main_window);
        gtk_widget_show(plug_main);
    }
}

#ifdef WEBKIT_FOUND

/**yon_ubl_browser_window_open(char *link, char *browser_window_name)
 * [EN]
 * Launches integrated browser window, named [browser_window_name] at header with [link].
 * [RU]
 * Открывает встроенный браузер с именем [browser_window_name] и показываемой страницей по ссылке [link]
*/
void yon_ubl_browser_window_open(char *link, char *browser_window_name){
    GtkWidget *browser=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    GtkWidget *web_place=gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
    GtkWidget *header=gtk_header_bar_new();
    GtkWidget *header_label=gtk_label_new(browser_window_name);
    GtkWidget *WebView=webkit_web_view_new();
    gtk_container_add(GTK_CONTAINER(browser),web_place);
    gtk_window_set_titlebar(GTK_WINDOW(browser),header);
    gtk_window_set_title(GTK_WINDOW(browser),browser_window_name);
    gtk_widget_set_size_request(browser,800,600);
    gtk_header_bar_set_custom_title(GTK_HEADER_BAR(header),header_label);
    gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(header),1);
    webkit_web_view_load_uri(WEBKIT_WEB_VIEW(WebView),link);
    gtk_box_pack_start(GTK_BOX(web_place),WebView,1,1,0);
    gtk_widget_show_all(browser);
}
#else

/**yon_ubl_browser_window_open(char *link, char *browser_window_name)
 * [EN]
 * Launches browser with [link].
 * [browser_window_name] is't used. It's needed for compatibility with webkit version of that function.
 * [RU]
 * Открывает браузер со страницей по ссылке [link]
 * [browser_window_name] не используется. Нужна для совместимости с webkit версией этой функции.
*/
void yon_ubl_browser_window_open(char *link,  char *browser_window_name){
        char *user=getenv("SUDO_USER");
        if (!user)
            user=getlogin();
        char *command=yon_char_unite("sudo -u ",user," xdg-open ", link,NULL);
        yon_launch_app(command);
}
#endif

#endif