Applications
/
ubl-settings-repomanager
10
0
Fork 1
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '62dd9f96ee'
${ noResults }
ubl-settings-repomanager/source/ubl-settings-repomanager.c

1204 lines
64 KiB
Raw Blame History

#include "ubl-settings-repomanager.h"
config main_config;
void on_repo_signed(){
}
void on_repo_removed(GtkWidget *self,storage_config_window *window){
GList *list = gtk_container_get_children(GTK_CONTAINER(gtk_widget_get_parent(self)));
char *repo = (char*)gtk_entry_get_text(GTK_ENTRY(g_list_nth_data(list,0)));
GtkTreeIter iter, itar;
char *storage;
char *id = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
if (!yon_char_is_empty(id)){
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
int valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(window->storages_copy),&itar,&iter);
for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->storages_copy),&itar)){
char *target;
gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,2,&target,-1);
if (!strcmp(target,repo)){
gtk_tree_store_remove(window->storages_copy,&itar);
break;
}
}
}
yon_storage_config_update(window);
}
void on_repo_sign_changed(GtkWidget *self, storage_config_window *window){
GList *list = gtk_container_get_children(GTK_CONTAINER(gtk_widget_get_parent(self)));
const char *sign = gtk_combo_box_get_active_id(GTK_COMBO_BOX(g_list_nth_data(list,2)));
char *target_repo = (char*)gtk_entry_get_text(GTK_ENTRY(g_list_nth_data(list,0)));
const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
if (!yon_char_is_empty(id)){
GtkTreeIter iter,itar;
int size;
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
char *storage_path;
gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&iter,3,&storage_path,-1);
config_str repos = yon_tree_store_get_all_at_level(window->storages_copy,&iter,&size,2,2);
int found = yon_char_parsed_check_exist(repos,size,target_repo);
if (found>-1){
char *child_id = yon_char_unite((char*)id,":",yon_char_from_int(found),NULL);
if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&itar,child_id)){
if (!yon_char_is_empty(sign)){
gtk_tree_store_set(window->storages_copy,&itar,6,1,5,sign,-1);
if (system(yon_debug_output("%s\n",yon_sign_repo(storage_path,target_repo,sign)))){
gtk_combo_box_set_active(GTK_COMBO_BOX((GtkWidget*)g_list_nth_data(list,2)),0);
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),REPO_SIGN_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
}
}else
gtk_tree_store_set(window->storages_copy,&itar,6,-1,5,NULL,-1);
}
}
}
}
void yon_storage_config_update(storage_config_window *window){
GList *children = gtk_container_get_children(GTK_CONTAINER(window->ReposBox));
for (int i=0;i<g_list_length(children);i++){
gtk_widget_destroy((GtkWidget*)g_list_nth_data(children,i));
}
GtkTreeIter iter,itar;
const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
if (id){
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
if (gtk_tree_model_iter_children(GTK_TREE_MODEL(window->storages_copy),&itar,&iter)){
int valid = 1;
for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->storages_copy),&itar)){
char *repo;
gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,2,&repo,-1);
GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_repo_block);
GtkWidget *box = yon_gtk_builder_get_widget(builder,"MainBox");
gtk_box_pack_start(GTK_BOX(window->ReposBox),box,0,0,0);
yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(gtk_builder_get_object(builder,"SignatureCombo")));
gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_builder_get_object(builder,"SignatureCombo")),0);
g_signal_connect(gtk_builder_get_object(builder,"SignatureButton"),"clicked",G_CALLBACK(on_repo_signed),window);
g_signal_connect(gtk_builder_get_object(builder,"RepoRemoveButton"),"clicked",G_CALLBACK(on_repo_removed),window);
gtk_entry_set_text(GTK_ENTRY(gtk_builder_get_object(builder,"RepoNameEntry")),repo);
char *storage = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->StoragePathCombo));
int sign_size;
char *command = yon_repo_get_signature(storage,repo);
yon_debug_output("%s\n",command);
config_str sign = yon_config_load(command,&sign_size);
if (sign_size>0){
yon_char_remove_last_symbol(sign[2],'\n');
char *mail = strstr(sign[2],"\"");
if (!yon_char_is_empty(mail)){
char *email = yon_char_new(mail);
yon_char_remove_brackets(email);
gtk_combo_box_set_active_id(GTK_COMBO_BOX(gtk_builder_get_object(builder,"SignatureCombo")),email);
free(email);
}
yon_char_parsed_free(sign,sign_size);
}
g_signal_connect(gtk_builder_get_object(builder,"SignatureButton"),"clicked",G_CALLBACK(on_repo_sign_changed),window);
}
}
}
}
// filechooser window section
void on_file_chooser_entry_changed(GtkEntry *self, file_chooser_window *window){
const char *text = gtk_entry_get_text(self);
GtkFileFilter *filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(window->FileChooserWidget));
gtk_file_chooser_remove_filter(GTK_FILE_CHOOSER(window->FileChooserWidget),filter);
filter = gtk_file_filter_new();
char *pattern = !yon_char_is_empty(text)?yon_char_unite("*",text,"*.pkg.tar*[^.sig]",NULL) : "*.pkg.tar*[^.sig]";
gtk_file_filter_add_pattern(filter,pattern);
gtk_file_filter_set_name(filter,"*.pkg.tar*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(window->FileChooserWidget),filter);
if (!yon_char_is_empty(text)) free(pattern);
}
void on_file_chooser_file_activate(GtkFileChooser *self, repo_add_window *window){
GtkTreeIter iter;
GSList *list = gtk_file_chooser_get_filenames(self);
if (list){
for (int i=0;i<g_slist_length(list);i++){
char *path = g_slist_nth_data(list,i);
char *filename = yon_char_new(path);
free(yon_char_divide(filename,yon_char_find_last(filename,'/')));
gtk_list_store_append(window->PackagesList,&iter);
gtk_list_store_set(window->PackagesList,&iter,1,filename,2,path,-1);
free(filename);
g_slist_free(list);
}
}
gtk_widget_destroy(gtk_widget_get_toplevel(GTK_WIDGET(self)));
}
file_chooser_window *yon_file_chooser_new(){
file_chooser_window *window = malloc(sizeof(file_chooser_window));
GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_filechooser);
window->Window = yon_gtk_builder_get_widget(builder,"Window");
window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
window->HeadLabel = yon_gtk_builder_get_widget(builder,"webHeaderNameLabel2");
window->ChooseButton = yon_gtk_builder_get_widget(builder,"ChooseButton");
window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
window->NameEntry = yon_gtk_builder_get_widget(builder,"NameEntry");
window->FileChooserWidget = yon_gtk_builder_get_widget(builder,"FileChooserWidget");
g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
g_signal_connect(G_OBJECT(window->NameEntry),"changed",G_CALLBACK(on_file_chooser_entry_changed),window);
return window;
}
// main window
void on_add_clicked(GtkWidget *self, main_window *widgets){
repo_add_window *window = yon_repo_add_window_new();
yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),ADD_PACKAGES_TITLE_LABEL,icon_path,"add-repo-window");
gtk_label_set_text(GTK_LABEL(window->HeadLabel),ADD_PACKAGES_TITLE_LABEL);
GtkTreeIter iter;
for_iter (window->tree_copy,&iter){
char *current;
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
if (!yon_char_is_empty(current)){
char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StorageCombo),path,current);
}
}
yon_sign_list_update();
yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));
gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->PackageSignCombo),0);
dictionary *dict = NULL;
yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
g_signal_connect(G_OBJECT(window->StorageCombo),"changed",G_CALLBACK(on_add_target_repo_selection_changed),window);
g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_add_target_arch_selection_changed),window);
g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_arch_chosen),window);
g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_add_target_package_selection_changed),window);
g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_add_packages_accept),dict);
g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_add_package),window);
g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_remove_package),window);
g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_repo_sign_load),window);
yon_add_window_set_selected(widgets,window);
GtkTreeModel *model;
GList *list = NULL;
char *full_path;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),NULL,&iter)){
gtk_tree_model_get(GTK_TREE_MODEL(widgets->RepoList),&iter,3,&full_path,-1);
if (list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoPackagesTree)),&model)){
for (int i=0; i<g_list_length(list);i++){
GtkTreeIter itar;
char *path;
gtk_tree_model_get_iter(model, &iter,g_list_nth_data(list,i));
gtk_tree_model_get(model,&iter,1,&path,-1);
gtk_list_store_append(window->PackagesList,&itar);
char *temp = yon_char_unite(full_path,"/",path,NULL);
free(full_path);
full_path = temp;
gtk_list_store_set(window->PackagesList,&itar,1,path,2,full_path,-1);
}
}
}
gtk_widget_show(window->MainWindow);
}
void on_folder_changed(GtkFileChooser *self, file_chooser_window *dialog){
const char *current = gtk_file_chooser_get_current_folder(self);
if (!strstr(current,dialog->root_path)){
gtk_file_chooser_set_current_folder(self,dialog->root_path);
}
}
void on_move_add_accept(GtkWidget *self, dictionary *dict){
repo_add_window *window = yon_dictionary_get_data(dict->first,repo_add_window*);
file_chooser_window *dialog = yon_dictionary_get_data(dict->first->next,file_chooser_window*);
GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog->FileChooserWidget));
for (int i=0;i<g_slist_length(list);i++){
char *path = (char*)g_slist_nth_data(list,i);
if (yon_file_is_directory(path)){
int size;
config_str files = yon_file_ls(path,&size);
for (int k=0;k<size;k++){
if (strstr(files[k],".pkg.tar")&&!strstr(files[k],".sig")){
GtkTreeIter iter;
int temp_size;
config_str name = yon_config_load(yon_get_package_name_from_filename(files[k]),&temp_size);
yon_char_remove_last_symbol(name[0],'\n');
gtk_list_store_append(window->PackagesList,&iter);
gtk_list_store_set(window->PackagesList,&iter,1,name[0],2,files[k],-1);
}
}
} else {
GtkTreeIter iter;
int temp_size;
config_str name = yon_config_load(yon_get_package_name_from_filename(path),&temp_size);
if (temp_size<=0){
yon_ubl_status_box_spawn(GTK_CONTAINER(dialog->StatusBox),PACKAGE_NAME_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
return;
}
yon_char_remove_last_symbol(name[0],'\n');
if (!yon_gtk_tree_model_check_exist(GTK_TREE_MODEL(window->PackagesList),&iter,name[0],1)){
gtk_list_store_append(window->PackagesList,&iter);
gtk_list_store_set(window->PackagesList,&iter,1,name[0],2,path,-1);
} else {
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),ALREADY_EXIST_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
}
gtk_widget_destroy(dialog->Window);
free(dialog);
GtkTreeIter iter;
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->tree_copy),&iter)){
gtk_widget_set_sensitive(window->MoveSourceStorageEntry,0);
gtk_widget_set_sensitive(window->MoveSourceRepoEntry,0);
gtk_widget_set_sensitive(window->MoveSourceArchEntry,0);
gtk_widget_set_sensitive(window->MoveTargetRepoEntry,0);
gtk_widget_set_sensitive(window->MoveTargetArchEntry,0);
if (window->StorageCombo&&window->RepositoryCombo&&window->ArchitectureCombo){
gtk_widget_set_sensitive(window->StorageCombo,0);
gtk_widget_set_sensitive(window->RepositoryCombo,0);
gtk_widget_set_sensitive(window->ArchitectureCombo,0);
}
}
}
void on_move_add_package(GtkWidget *self, repo_add_window *window){
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->MoveTargetArchEntry))>-1&&gtk_combo_box_get_active(GTK_COMBO_BOX(window->MoveSourceStorageEntry))>-1){
file_chooser_window *dialog = yon_file_chooser_new();
yon_gtk_window_setup(GTK_WINDOW(dialog->Window),GTK_WINDOW(window->MainWindow),CHOSE_PACKAGES_TITLE_LABEL,icon_path,"ChooseMoveFileChooserWindow");
gtk_label_set_text(GTK_LABEL(dialog->HeadLabel),CHOSE_PACKAGES_TITLE_LABEL);
GtkFileFilter *filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter,"*.pkg.tar*[^.sig]");
gtk_file_filter_set_name(filter,"*.pkg.tar.*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog->FileChooserWidget),filter);
GtkTreeIter iter,itar;
yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveSourceArchEntry),GTK_TREE_MODEL(window->tree_copy),&iter);
char *target;
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&target,3,&dialog->root_path,-1);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog->FileChooserWidget),target);
dictionary *dict = NULL;
yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
yon_dictionary_add_or_create_if_exists_with_data(dict,"dialog",dialog);
g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"current-folder-changed",G_CALLBACK(on_folder_changed),dialog);
g_signal_connect(G_OBJECT(dialog->ChooseButton),"clicked",G_CALLBACK(on_move_add_accept),dict);
g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"file-activated",G_CALLBACK(on_file_chooser_file_activate),window);
gtk_widget_show(dialog->Window);
}
}
void on_move_remove_package(GtkWidget *self, repo_add_window *window){
GtkTreeIter iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->PackagesTree)),&model,&iter)){
gtk_list_store_remove(window->PackagesList,&iter);
}
if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->PackagesList),&iter)){
gtk_widget_set_sensitive(window->MoveSourceStorageEntry,1);
gtk_widget_set_sensitive(window->MoveSourceRepoEntry,1);
gtk_widget_set_sensitive(window->MoveSourceArchEntry,1);
gtk_widget_set_sensitive(window->MoveTargetRepoEntry,1);
if (window->StorageCombo&&window->RepositoryCombo&&window->ArchitectureCombo){
gtk_widget_set_sensitive(window->StorageCombo,1);
gtk_widget_set_sensitive(window->RepositoryCombo,1);
gtk_widget_set_sensitive(window->ArchitectureCombo,1);
}
}
}
void on_move_accept(GtkWidget *self, dictionary *dict){
main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
repo_add_window *window = yon_dictionary_get_data(dict->first->next,repo_add_window*);
int size = 0;
config_str packages = NULL;
GtkTreeIter iter,itar;
for_iter(GTK_TREE_MODEL(window->PackagesList),&iter){
char *target=NULL;
gtk_tree_model_get(GTK_TREE_MODEL(window->PackagesList),&iter,2,&target,-1);
if (!yon_char_is_empty(target)){
free(yon_char_divide(target,yon_char_find_last(target,'/')));
yon_char_parsed_add_or_create_if_exists(packages,&size,target);
free(target);
}
}
if (size){
char *arch = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->MoveSourceArchEntry));
yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveSourceRepoEntry),GTK_TREE_MODEL(window->tree_copy),&iter);
yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveTargetRepoEntry),GTK_TREE_MODEL(window->tree_copy),&itar);
char *source_path, *source_repo, *target_path, *target_repo;
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&source_repo,-1);
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,3,&target_repo,-1);
source_path = yon_char_divide(source_repo,yon_char_find_last(source_repo,'/'));
target_path = yon_char_divide(target_repo,yon_char_find_last(target_repo,'/'));
char *command = yon_move_packages_command(source_path,arch,source_repo, target_repo, yon_char_parsed_to_string(packages,size," "));
yon_debug_output("%s\n",command);
if (!system(command)){
yon_ubl_status_box_render(PACKAGES_MOVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),NULL);
gtk_tree_store_clear(widgets->RepoList);
yon_gtk_tree_store_copy_full(window->tree_copy,widgets->RepoList);
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),GTK_TREE_MODEL(widgets->RepoList));
const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->ArchitectureCombo));
if (!yon_char_is_empty(id)){
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(widgets->RepoList),&iter,id);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widgets->ReposTree),gtk_tree_path_new_from_string(id));
gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&iter);
on_main_tree_selection_changed(NULL,widgets);
}
yon_config_load_update(widgets);
on_subwindow_close(window->MainWindow);
}
} else {
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
repo_add_window *on_move_clicked(GtkWidget *self, main_window *widgets){
repo_add_window *window = yon_repo_add_window_new();
yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),MOVE_PACKAGES_TITLE_LABEL,icon_path,"move-repo-window");
gtk_label_set_text(GTK_LABEL(window->HeadLabel),MOVE_PACKAGES_TITLE_LABEL);
gtk_button_set_label(GTK_BUTTON(window->AddButton),MOVE_LABEL);
gtk_label_set_text(GTK_LABEL(window->PackagesToAddLabel),MOVE_PACKAGES_LABEL);
gtk_widget_show(window->MoveSourceFrame);
gtk_widget_show(window->MoveTargetFrame);
gtk_widget_hide(gtk_widget_get_parent(window->PackageSignCombo));
GtkTreeIter iter;
for_iter (window->tree_copy,&iter){
char *current;
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
if (!yon_char_is_empty(current)){
char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->MoveSourceStorageEntry),path,current);
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->MoveTargetStorageEntry),path,current);
}
}
yon_sign_list_update();
yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));
gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->PackageSignCombo),0);
gtk_widget_destroy(gtk_widget_get_parent(window->StorageCombo));
dictionary *dict = NULL;
yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
g_signal_connect(G_OBJECT(window->MoveSourceStorageEntry),"changed",G_CALLBACK(on_move_storage_changed),window);
g_signal_connect(G_OBJECT(window->MoveSourceRepoEntry),"changed",G_CALLBACK(on_move_repo_changed),window);
g_signal_connect(G_OBJECT(window->MoveSourceArchEntry),"changed",G_CALLBACK(on_move_arch_changed),window);
g_signal_connect(G_OBJECT(window->MoveTargetRepoEntry),"changed",G_CALLBACK(on_move_repo_changed),window);
g_signal_connect(G_OBJECT(window->MoveTargetArchEntry),"changed",G_CALLBACK(on_move_arch_changed),window);
g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_move_add_package),window);
g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_move_remove_package),window);
g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_move_accept),dict);
g_signal_connect(G_OBJECT(window->MoveSourceRepoEntry),"changed",G_CALLBACK(on_repo_sign_load),window);
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),NULL,&iter)){
char *target = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(widgets->RepoList),&iter);
int mod = yon_char_count(target,":")+1;
char *arc=NULL;
char *repo=NULL;
char *stor=NULL;
if (mod ==3){
arc = yon_char_new(target);
char *temp = yon_char_new(target);
repo = yon_char_divide(temp,yon_char_find_last(temp,':'));
free(temp);
temp = yon_char_new(repo);
stor = yon_char_divide(temp,yon_char_find_last(temp,':'));
free(temp);
} else if (mod>=2){
repo = yon_char_new(target);
char *temp = yon_char_new(target);
stor = yon_char_divide(temp,yon_char_find_last(temp,':'));
free(temp);
} else if (mod>=1){
stor = yon_char_new(target);
}
if (stor)
gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->MoveSourceStorageEntry),stor);
if (repo)
gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->MoveSourceRepoEntry),repo);
if (arc)
gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->MoveSourceArchEntry),arc);
}
gtk_widget_show(window->MainWindow);
return window;
}
void on_remove_add_package(GtkWidget *self, repo_add_window *window){
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ArchitectureCombo))>-1){
file_chooser_window *dialog = yon_file_chooser_new();
yon_gtk_window_setup(GTK_WINDOW(dialog->Window),GTK_WINDOW(window->MainWindow),CHOSE_PACKAGES_TITLE_LABEL,icon_path,"ChooseMoveFileChooserWindow");
gtk_label_set_text(GTK_LABEL(dialog->HeadLabel),CHOSE_PACKAGES_TITLE_LABEL);
GtkFileFilter *filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter,"*.pkg.tar*[^.sig]");
gtk_file_filter_set_name(filter,"*.pkg.tar.*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog->FileChooserWidget),filter);
GtkTreeIter iter,itar;
yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->ArchitectureCombo),GTK_TREE_MODEL(window->tree_copy),&iter);
char *target;
int temp_size=0;
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&target,-1);
yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->ArchitectureCombo),GTK_TREE_MODEL(window->tree_copy),&itar);
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,3,&dialog->root_path,-1);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog->FileChooserWidget),target);
dictionary *dict = NULL;
yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
yon_dictionary_add_or_create_if_exists_with_data(dict,"dialog",dialog);
g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"current-folder-changed",G_CALLBACK(on_folder_changed),dialog);
g_signal_connect(G_OBJECT(dialog->ChooseButton),"clicked",G_CALLBACK(on_move_add_accept),dict);
g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"file-activated",G_CALLBACK(on_file_chooser_file_activate),window);
gtk_widget_show(dialog->Window);
}
}
void on_remove_arch_selection_changed(GtkWidget *self, repo_add_window *window){
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ArchitectureCombo))==-1){
gtk_widget_set_sensitive(window->AddPackageButton,0);
} else {
gtk_widget_set_sensitive(window->AddPackageButton,1);
}
}
void on_remove_accept(GtkWidget *self, dictionary *dict){
main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
repo_add_window *window = yon_dictionary_get_data(dict->first->next,repo_add_window*);
GtkTreeModel *model;
GtkTreeIter iter;
const char *storage_id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StorageCombo));
char *storage_path;
char *repo = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->RepositoryCombo));
char *arch = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->ArchitectureCombo));
if (!yon_char_is_empty(storage_id)){
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&iter,storage_id);
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&storage_path,-1);
int size=0;
config_str packages=NULL;
for_iter(GTK_TREE_MODEL(window->PackagesList),&iter){
char *target;
gtk_tree_model_get(GTK_TREE_MODEL(window->PackagesList),&iter,1,&target,-1);
yon_char_parsed_add_or_create_if_exists(packages,&size,target);
}
if (size){
char *sign = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->RepoSignCombo));
char *command;
if (yon_char_is_empty(sign)){
command = yon_delete_packages_command(storage_path,arch,repo,yon_char_parsed_to_string(packages,size," "));
} else {
command = yon_delete_packages_sign_command(storage_path,arch,repo,sign,yon_char_parsed_to_string(packages,size," "));
}
yon_debug_output("%s\n",command);
if (!system(command)){
yon_ubl_status_box_render(PACKAGES_REMOVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),NULL);
gtk_tree_store_clear(widgets->RepoList);
yon_gtk_tree_store_copy_full(window->tree_copy,widgets->RepoList);
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),GTK_TREE_MODEL(widgets->RepoList));
const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->ArchitectureCombo));
if (!yon_char_is_empty(id)){
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(widgets->RepoList),&iter,id);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widgets->ReposTree),gtk_tree_path_new_from_string(id));
gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&iter);
on_main_tree_selection_changed(NULL,widgets);
}
}
yon_config_load_update(widgets);
} else {
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
return;
}
}else {
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
return;
}
gtk_widget_destroy(window->MainWindow);
}
repo_add_window *on_remove_clicked(GtkWidget *self, main_window *widgets){
repo_add_window *window = yon_repo_add_window_new();
yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),REMOVE_PACKAGES_TITLE_LABEL,icon_path,"add-repo-window");
gtk_label_set_text(GTK_LABEL(window->HeadLabel),REMOVE_PACKAGES_TITLE_LABEL);
GtkTreeIter iter;
for_iter (window->tree_copy,&iter){
char *current;
gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
if (!yon_char_is_empty(current)){
char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StorageCombo),path,current);
}
}
gtk_label_set_text(GTK_LABEL(window->PackagesToAddLabel),REMOVE_PACKAGES_LABEL);
yon_sign_list_update();
yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));
gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);
gtk_widget_hide(gtk_widget_get_parent(window->PackageSignCombo));
gtk_button_set_label(GTK_BUTTON(window->AddButton),REMOVE_LABEL);
dictionary *dict = NULL;
yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_arch_chosen),window);
g_signal_connect(G_OBJECT(window->StorageCombo),"changed",G_CALLBACK(on_add_target_repo_selection_changed),window);
g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_add_target_arch_selection_changed),window);
g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_remove_arch_selection_changed),window);
g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_remove_accept),dict);
g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_remove_add_package),window);
g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_move_remove_package),window);
g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_repo_sign_load),window);
yon_add_window_set_selected(widgets,window);
gtk_widget_show(window->MainWindow);
return window;
}
/* setup functions */
void config_init(){
main_config.tree_store=NULL;
main_config.always_open_documentation=0;
main_config.socket_id=-1;
main_config.save_socket_id=-1;
main_config.load_socket_id=-1;
main_config.lock_help=0;
main_config.lock_help=0;
main_config.lock_load_global=0;
main_config.lock_save_global=0;
main_config.lock_save_local=0;
main_config.signs=NULL;
main_config.signs_size=0;
yon_sign_list_update();
main_config.last_selection = NULL;
}
void yon_config_load_update(main_window *widgets){
gtk_tree_store_clear(widgets->RepoList);
gsize size=0;
config_str storages = yon_window_config_get_section("storage_info",&size);
GtkTreeIter iter,itar,childiter;
for (int i=0;i<size;i++){
char *name = yon_char_new(storages[i]);
free(yon_char_divide(name,yon_char_find_last(name,'/')));
gtk_tree_store_append(widgets->RepoList,&iter,NULL);
gtk_tree_store_set(widgets->RepoList,&iter,0,folder_no_edits,2,name,3,storages[i],-1);
free(name);
yon_window_config_get_parameter("storage_info",storages[i],&name,YON_TYPE_STRING);
if (!yon_char_is_empty(name)){
int parsed_size;
config_str name_parsed = yon_char_parse(name,&parsed_size,",");
for (int j=0;j<parsed_size;j++){
char *nm = yon_char_new(name_parsed[j]);
free(yon_char_divide(nm,yon_char_find_last(nm,'/')));
gtk_tree_store_append(widgets->RepoList,&itar,&iter);
gtk_tree_store_set(widgets->RepoList,&itar,2,nm,3,name_parsed[j],-1);
int size;
config_str dirs = yon_file_list_dirs(name_parsed[j],&size);
for (int k=0;k<size;k++){
if (strcmp(dirs[k],"pool")&&strcmp(dirs[k],nm)){
char *arch_path = yon_char_unite(name_parsed[j],"/",dirs[k],NULL);
int arch_status = system(yon_debug_output("%s\n",yon_repo_get_signature_status_arch(storages[i],nm,dirs[k])));
arch_status = WEXITSTATUS(arch_status);
int packages_status = system(yon_debug_output("%s\n",yon_repo_get_signature_status_packages(storages[i],nm,dirs[k])));
char *sign_status_image = "";
if (!arch_status&&!packages_status){
sign_status_image = key_icon_name;
} else if (!arch_status&&packages_status==2)
sign_status_image = warning_icon_name;
else if (arch_status==2&&packages_status==2)
sign_status_image = "";
else
sign_status_image = warning_icon_name;
gtk_tree_store_append(widgets->RepoList,&childiter,&itar);
gtk_tree_store_set(widgets->RepoList,&childiter,0,sign_status_image,2,dirs[k],3,arch_path,-1);
}
}
free(nm);
}
yon_char_parsed_free(name_parsed,parsed_size);
}
}
if (size)
yon_char_parsed_free(storages,size);
}
config_str yon_tree_store_storage_get_archs(GtkTreeStore *target, GtkTreeIter *storage, int *size){
config_str final = NULL;
GtkTreeIter iter,itar;
int repos_valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(target),&iter,storage);
for (;repos_valid;repos_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(target),&iter)){
int archs_valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(target),&itar,&iter);
for (;archs_valid;archs_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(target),&itar)){
char *current;
gtk_tree_model_get(GTK_TREE_MODEL(target),&itar,2,&current,-1);
if (yon_char_parsed_check_exist(final,*size,current)==-1)
yon_char_parsed_add_or_create_if_exists(final,size,current);
}
}
return final;
}
config_str yon_tree_store_repo_get_archs(GtkTreeStore *target, GtkTreeIter *repo, int *size){
config_str final = NULL;
GtkTreeIter iter;
int repos_valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(target),&iter,repo);
for (;repos_valid;repos_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(target),&iter)){
char *current;
gtk_tree_model_get(GTK_TREE_MODEL(target),&iter,2,&current,-1);
if (yon_char_parsed_check_exist(final,*size,current)==-1)
yon_char_parsed_add_or_create_if_exists(final,size,current);
}
return final;
}
char *yon_signature_get(GtkTreeView *target, GtkTreeIter *iter){
GtkTreeIter itar;
GtkTreeModel *model = gtk_tree_view_get_model(target);
char *full_path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(model),iter);
int size;
config_str parsed = yon_char_parse(full_path,&size,":");
if (size==2){
char *storage_path = parsed[0];
char *repo_path = yon_char_unite(parsed[0],":",parsed[1],NULL);
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(model),&itar,storage_path);
char *path;
gtk_tree_model_get(GTK_TREE_MODEL(model),&itar,3,&path,-1);
char *repo;
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(model),&itar,repo_path);
gtk_tree_model_get(GTK_TREE_MODEL(model),&itar,2,&repo,-1);
int status_size;
config_str status = yon_config_load(yon_repo_get_signature(path,repo),&status_size);
char *final_string = NULL;
if (status_size>4){
final_string = yon_char_unite(status[0],status[1],status[2],status[3],NULL);
}
free(full_path);
free(path);
free(repo);
yon_char_parsed_free(parsed,size);
yon_char_parsed_free(status,status_size);
return final_string;
}
return NULL;
}
void on_main_tree_selection_changed(GtkWidget *self, main_window *widgets){
gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),"");
gtk_list_store_clear(widgets->RepoFileList);
gtk_list_store_clear(widgets->RepoPackagesList);
GtkTreeIter iter,itar;
GtkTreeModel *model=NULL;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter)){
GtkTreePath *path = gtk_tree_model_get_path(model,&iter);
int depth = gtk_tree_path_get_depth(path);
char *target, *name;
gtk_tree_model_get(model, &iter,2,&name,3,&target,-1);
switch (depth){
case 1:{
int size, arch_size;
config_str repos = yon_tree_store_get_all_at_level(widgets->RepoList,&iter,&size,2,2);
config_str archs = yon_tree_store_storage_get_archs(widgets->RepoList,&iter,&arch_size);
if (size>0&&arch_size>0){
char *repo_string = yon_char_parsed_to_string(repos,size,", ");
char *archs_string = yon_char_parsed_to_string(archs,arch_size,", ");
char *info = get_storage_info_label(target,repo_string,archs_string);
gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),info);
int lvlsize;
config_str level = yon_tree_store_get_all_at_level(widgets->RepoList,&iter,&lvlsize,2,2);
for (int i=0;i<lvlsize;i++){
gtk_list_store_append(widgets->RepoFileList,&itar);
gtk_list_store_set(widgets->RepoFileList,&itar,1,level[i],-1);
}
if (!yon_char_is_empty(repo_string))free(repo_string);
if (!yon_char_is_empty(archs_string)) free(archs_string);
if (!yon_char_is_empty(info))free(info);
yon_char_parsed_free(repos,size);
yon_char_parsed_free(archs,arch_size);
}
}
break;
case 2:{
int size, arch_size;
config_str archs = yon_tree_store_repo_get_archs(widgets->RepoList,&iter,&arch_size);
char *archs_string = yon_char_parsed_to_string(archs,arch_size,", ");
char *sign = yon_signature_get(GTK_TREE_VIEW(widgets->ReposTree),&iter);
char *info = get_repo_info_label(name,archs_string,sign);
gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),info);
int lvlsize;
config_str level = yon_tree_store_get_all_at_level(widgets->RepoList,&iter,&lvlsize,2,3);
for (int i=0;i<lvlsize;i++){
gtk_list_store_append(widgets->RepoFileList,&itar);
gtk_list_store_set(widgets->RepoFileList,&itar,1,level[i],-1);
}
if (!yon_char_is_empty(archs_string)) free(archs_string);
if (!yon_char_is_empty(info))free(info);
yon_char_parsed_free(archs,arch_size);
}
break;
case 3:{
GtkTreeIter itor;
gtk_tree_model_iter_parent(GTK_TREE_MODEL(widgets->RepoList),&itor,&iter);
char *trg;
gtk_tree_model_get(GTK_TREE_MODEL(widgets->RepoList),&itor,2,&trg,-1);
char *info = get_arch_info_label(trg,name);
gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),info);
char *packages;
int size;
char *arch = yon_char_new(target);
char *repo = yon_char_divide(arch,yon_char_find_last(arch,'/'));
char *storage = yon_char_divide(repo,yon_char_find_last(repo,'/'));
char *command = yon_get_packages_command(storage,repo,arch);
yon_debug_output("%s\n",command);
config_str parsed = yon_config_load(command,&size);
for (int i=0;i<size;i++){
int line_size;
yon_char_remove_last_symbol(parsed[i],'\n');
config_str line = yon_char_parse(parsed[i],&line_size," ");
if (line[0][0]!='-'&&line[0][1]!='\0'){
int load_size;
char *name = yon_char_unite(target,"/",line[1],NULL);
config_str load = yon_config_load(yon_get_package_name_from_filename(name),&load_size);
if (load_size>0){
yon_char_remove_last_symbol(load[0],'\n');
int package_status = system(yon_debug_output("%s\n",yon_repo_get_signature_status(storage,repo,arch,load[0])));
char *sign_status_icon = "";
if (!package_status)
sign_status_icon = package_signature_icon_name;
else
sign_status_icon = package_signature_error_icon_name;
gtk_list_store_append(widgets->RepoFileList,&itar);
gtk_list_store_set(widgets->RepoFileList,&itar,0,sign_status_icon,1,line[0],2,line[1],-1);
yon_char_parsed_free(load,load_size);
}
} else {
gtk_list_store_append(widgets->RepoPackagesList,&itar);
gtk_list_store_set(widgets->RepoPackagesList,&itar,0,package_signature_error_icon_name,1,line[1],-1);
}
}
if (!yon_char_is_empty(info))free(info);
}
break;
}
if (main_config.last_selection){
if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(widgets->RepoFileList),&itar,main_config.last_selection))
gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&itar);
}
}
}
void on_package_selection_changed(GtkWidget *self, main_window *widgets){
gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),"");
GtkTreeIter iter,itar;
GtkTreeModel *model, *model2;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model,&iter)){
if (main_config.last_selection) free(main_config.last_selection);
main_config.last_selection = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(widgets->RepoFileList),&iter);
gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model2,&itar);
switch (gtk_tree_store_iter_depth(widgets->RepoList,&itar)){
case 0:
break;
case 1:
break;
case 2:
char *path, *filename;
gtk_tree_model_get(model,&iter,2,&filename,-1);
gtk_tree_model_get(model2,&itar,3,&path,-1);
int size;
char *command = get_package_info_command(yon_char_unite(path,"/",filename,NULL));
yon_debug_output("%s\n",command);
config_str parsed = yon_config_load(command,&size);
char *full = yon_char_parsed_to_string(parsed,size,"");
gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),full);
yon_char_parsed_free(parsed,size);
free(full);
break;
}
}
}
void yon_combo_box_text_set_signs(GtkComboBoxText *target){
g_return_if_fail(GTK_IS_COMBO_BOX_TEXT(target));
gtk_combo_box_text_remove_all(target);
gtk_combo_box_text_append_text(target,DO_NOT_SIGN_LABEL);
for (int i=0;i<main_config.signs_size;i++){
char *temp = yon_char_new(main_config.signs[i]);
if (strstr(temp,"<"))
free(yon_char_divide_search(temp,"<",-1));
if (strstr(temp,">"))
yon_char_remove_last_symbol(temp,'>');
gtk_combo_box_text_append(target,temp,main_config.signs[i]);
free(temp);
}
}
void yon_sign_list_update(){
if (main_config.signs&&main_config.signs_size) yon_char_parsed_free(main_config.signs,main_config.signs_size);
main_config.signs = yon_config_load(get_gpg_keys_command,&main_config.signs_size);
for (int i=0;i<main_config.signs_size;i++){
yon_char_remove_last_symbol(main_config.signs[i],'\n');
}
}
void on_ubl_settings_update_launch(){
yon_launch_app_with_arguments(ubl_settings_update_command,NULL);
}
void on_calendar_open(GtkWidget *self,key_creation_window *window){
yon_calendar_popover_open(GTK_ENTRY(window->ExpireEntry),self);
}
void on_key_generate_accept(GtkWidget *self, key_creation_window* window){
const char *name = gtk_entry_get_text(GTK_ENTRY(window->NameEntry));
const char *type = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->EncryptionCombo));
const char *email = gtk_entry_get_text(GTK_ENTRY(window->EmailEntry));
char *strength = yon_char_from_long(gtk_spin_button_get_value(GTK_SPIN_BUTTON(window->KeyStrengthSpin)));
const char *comment = gtk_entry_get_text(GTK_ENTRY(window->CommentsEntry));
if (!yon_char_is_empty(name)&&strlen(name)<5){
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NAME_SHORT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
yon_ubl_status_highlight_incorrect(window->NameEntry);
return;
}
GtkWidget *highlight_target=NULL;
if (yon_char_is_empty(name)){
highlight_target=window->NameEntry;
} else if (yon_char_is_empty(type)){
highlight_target=window->EncryptionCombo;
} else if (yon_char_is_empty(email)){
highlight_target=window->EmailEntry;
} else if (yon_char_is_empty(strength)){
highlight_target=window->KeyStrengthSpin;
}
if (highlight_target){
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
yon_ubl_status_highlight_incorrect(highlight_target);
return;
}
char *expire = NULL;
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ExpireCombo))==1){
expire = yon_char_from_int(yon_calendar_get_last_date());
}
const char *password = gtk_entry_get_text(GTK_ENTRY(window->PasswordEntry));
const char *password_confirm = gtk_entry_get_text(GTK_ENTRY(window->PasswordConfirmationEntry));
int ex_status=0;
if (yon_char_is_empty(password)&&yon_char_is_empty(password_confirm)){
yon_debug_output("%s\n",yon_generate_key_no_password_command(type,name,email,strength,comment,expire,password));
ex_status = system(yon_debug_output("%s\n",yon_generate_key_no_password_command(type,name,email,strength,comment,expire,password)));
} else if (!strcmp(password,password_confirm)){
yon_debug_output("%s\n",yon_generate_key_command(type,name,email,strength,comment,expire,password));
ex_status = system(yon_debug_output("%s\n",yon_generate_key_command(type,name,email,strength,comment,expire,password)));
} else {
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),PASSWORD_INCORRECT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
yon_ubl_status_highlight_incorrect(window->PasswordConfirmationEntry);
yon_ubl_status_highlight_incorrect(window->PasswordEntry);
return;
}
if (!ex_status)
yon_ubl_status_box_render(KEY_CREATION_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
else
yon_ubl_status_box_render(KEY_CREATION_FAILURE_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
gtk_widget_destroy(window->Window);
yon_sign_list_update();
}
key_creation_window *yon_key_creation_window_new(){
key_creation_window *window = malloc(sizeof(key_creation_window));
GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_key);
window->Window = 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->NameEntry = yon_gtk_builder_get_widget(builder,"NameEntry");
window->EmailEntry = yon_gtk_builder_get_widget(builder,"EmailEntry");
window->CommentsEntry = yon_gtk_builder_get_widget(builder,"CommentsEntry");
window->EncryptionCombo = yon_gtk_builder_get_widget(builder,"EncryptionCombo");
window->KeyStrengthSpin = yon_gtk_builder_get_widget(builder,"KeyStrengthSpin");
window->ExpireCombo = yon_gtk_builder_get_widget(builder,"ExpireCombo");
window->ExpireEntry = yon_gtk_builder_get_widget(builder,"ExpireEntry");
window->ExpireButton = yon_gtk_builder_get_widget(builder,"ExpireButton");
window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
window->AddButton = yon_gtk_builder_get_widget(builder,"AddButton");
window->PasswordEntry = yon_gtk_builder_get_widget(builder,"PasswordEntry");
window->PasswordConfirmationEntry = yon_gtk_builder_get_widget(builder,"PasswordConfirmationEntry");
yon_gtk_entry_set_password_visibility_icon(GTK_ENTRY(window->PasswordConfirmationEntry));
yon_gtk_entry_set_password_visibility_icon(GTK_ENTRY(window->PasswordEntry));
g_signal_connect(G_OBJECT(window->ExpireCombo),"changed",G_CALLBACK(yon_gtk_widget_set_sensitive_from_combo_box),window->ExpireButton);
g_signal_connect(G_OBJECT(window->ExpireCombo),"changed",G_CALLBACK(yon_gtk_widget_set_sensitive_from_combo_box),window->ExpireEntry);
g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
g_signal_connect(G_OBJECT(window->ExpireButton),"clicked",G_CALLBACK(on_calendar_open),window);
g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_key_generate_accept),window);
int size;
config_str encription_keys = yon_file_open(key_encription_path,&size);
window->expire_time=0;
for (int i=1;i<size;i++){
yon_char_remove_last_symbol(encription_keys[i],'\n');
int parsed_size;
config_str parsed = yon_char_parse(encription_keys[i],&parsed_size,";");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->EncryptionCombo),parsed[2],parsed[0]);
yon_char_parsed_free(parsed,parsed_size);
}
gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->EncryptionCombo),"RSA");
return window;
}
void on_key_clicked(GtkWidget *self, main_window *widgets){
key_creation_window *window = yon_key_creation_window_new();
yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window),KEY_CREATION_TITLE_LABEL,icon_path,"key-create-window");
gtk_label_set_text(GTK_LABEL(window->HeadLabel),KEY_CREATION_TITLE_LABEL);
gtk_widget_show(window->Window);
}
void on_tree_view_activate(GtkWidget *self, GtkTreePath* path, GtkTreeViewColumn* column, main_window *widgets){
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widgets->ReposTree),path);
}
void on_repo_item_activate(GtkWidget *self, GtkTreePath *path, GtkTreeViewColumn *column, main_window *widgets){
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *tree_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree));
gtk_tree_selection_get_selected(tree_selection,&model,&iter);
if (gtk_tree_store_iter_depth(GTK_TREE_STORE(widgets->RepoList),&iter)<2){
char *path_id = gtk_tree_model_get_string_from_iter(model,&iter);
char *target_id = gtk_tree_path_to_string(path);
char *selection = yon_char_unite(path_id,":",target_id,NULL);
GtkTreePath *new_selection = gtk_tree_path_new_from_string(selection);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widgets->ReposTree),new_selection);
gtk_tree_selection_select_path(tree_selection,new_selection);
// on_package_selection_changed(NULL,widgets);
g_signal_emit_by_name(G_OBJECT(widgets->ReposTree),"cursor-changed",widgets,G_TYPE_NONE,NULL);
}
}
void on_update_clicked(GtkWidget *self, main_window *widgets){
yon_config_load_update(widgets);
}
void on_sign_window_accept(GtkWidget *self, dictionary *dict){
main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
sign_window *window = yon_dictionary_get_data(dict->first->next,sign_window*);
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter)){
char *arch;
char *repo;
char *storage;
char *signature = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->SignCombo));
gtk_tree_model_get(GTK_TREE_MODEL(widgets->RepoList),&iter,3,&arch,-1);
char *full_path = yon_char_new(arch);
repo = yon_char_divide(arch,yon_char_find_last(arch,'/'));
storage = yon_char_divide(repo,yon_char_find_last(repo,'/'));
storage = yon_char_append(storage,"/");
GList *list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),NULL);
char *targets = "";
for (int i=0;i<g_list_length(list);i++){
char *pack;
gtk_tree_model_get_iter(GTK_TREE_MODEL(widgets->RepoFileList),&iter,(GtkTreePath*)g_list_nth_data(list,i));
gtk_tree_model_get(GTK_TREE_MODEL(widgets->RepoFileList),&iter,2,&pack,-1);
char *temp = yon_char_unite(targets, " ", full_path,"/",pack,NULL);
if (!yon_char_is_empty(targets)) free(targets);
targets=temp;
}
if (!system(yon_debug_output("%s\n",yon_sign_package(storage,repo,arch,targets,signature)))){
yon_ubl_status_box_render(SIGN_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
}
on_subwindow_close(window->Window);
}
}
sign_window *yon_sign_window_new(){
sign_window *window = malloc(sizeof(sign_window));
GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_sign);
window->Window = 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->SignCombo = yon_gtk_builder_get_widget(builder,"SignCombo");
window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
window->SignButton = yon_gtk_builder_get_widget(builder,"SignButton");
g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
return window;
}
void on_packages_sign(GtkWidget *self, main_window *widgets){
sign_window *window = yon_sign_window_new();
yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window),SIGNATURE_TITLE_LABEL,icon_path,"sign-window");
yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->SignCombo));
dictionary *dict = NULL;
yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
g_signal_connect(G_OBJECT(window->SignButton),"clicked",G_CALLBACK(on_sign_window_accept),dict);
gtk_widget_show(window->Window);
}
int yon_tree_is_selected(void *widget){
main_window *widgets = (main_window*)widget;
GtkTreeModel *model;
GtkTreeIter iter, itar;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model,&iter)){
gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),NULL,&itar);
if (gtk_tree_store_iter_depth(widgets->RepoList,&itar)==2){
return 1;
}
}
return 0;
}
void on_rmb_move(GtkWidget *self, main_window *widgets){
repo_add_window *window = on_move_clicked(NULL,widgets);
GtkTreeModel *model;
GtkTreeIter iter;
char *path;
gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter);
gtk_tree_model_get(model,&iter,3,&path,-1);
GList *list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model);
for (int i=0;i<g_list_length(list);i++){
GtkTreeIter itar;
char *filename, *name;
gtk_tree_model_get_iter(model,&iter,g_list_nth_data(list,i));
gtk_tree_model_get(model,&iter,1,&name,2,&filename,-1);
char *full_path = yon_char_unite(path,"/",filename,NULL);
gtk_list_store_append(window->PackagesList,&itar);
gtk_list_store_set(window->PackagesList,&itar,1,name,2,full_path,-1);
free(full_path);
free(filename);
free(name);
}
}
void on_rmb_remove(GtkWidget *self, main_window *widgets){
repo_add_window *window = on_remove_clicked(NULL,widgets);
GtkTreeModel *model;
GtkTreeIter iter;
char *path;
gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter);
gtk_tree_model_get(model,&iter,3,&path,-1);
GList *list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model);
for (int i=0;i<g_list_length(list);i++){
GtkTreeIter itar;
char *filename, *name;
gtk_tree_model_get_iter(model,&iter,g_list_nth_data(list,i));
gtk_tree_model_get(model,&iter,1,&name,2,&filename,-1);
char *full_path = yon_char_unite(path,"/",filename,NULL);
gtk_list_store_append(window->PackagesList,&itar);
gtk_list_store_set(window->PackagesList,&itar,1,name,2,full_path,-1);
free(full_path);
free(filename);
free(name);
}
}
main_window *yon_main_window_complete(main_window *widgets){
widgets = yon_remalloc(widgets,sizeof(main_window));
GtkBuilder *builder = gtk_builder_new_from_resource(glade_path);
gtk_box_pack_start(GTK_BOX(widgets->InterfaceBox),yon_gtk_builder_get_widget(builder,"BoxMain"),1,1,0);
// Custom widgets configuration
{
widgets->UpdateButton = yon_gtk_builder_get_widget(builder,"UpdateButton");
widgets->DBConfigurationButton = yon_gtk_builder_get_widget(builder,"DBConfigurationButton");
widgets->AddButton = yon_gtk_builder_get_widget(builder,"AddButton");
widgets->MoveButton = yon_gtk_builder_get_widget(builder,"MoveButton");
widgets->RemoveButton = yon_gtk_builder_get_widget(builder,"RemoveButton");
widgets->CloudButton = yon_gtk_builder_get_widget(builder,"CloudButton");
widgets->ReposTree = yon_gtk_builder_get_widget(builder,"ReposTree");
widgets->SearchEntry = yon_gtk_builder_get_widget(builder,"SearchEntry");
widgets->RepoFileTree = yon_gtk_builder_get_widget(builder,"RepoFileTree");
widgets->RepoPackagesTree = yon_gtk_builder_get_widget(builder,"RepoPackagesTree");
widgets->InformationLabel = yon_gtk_builder_get_widget(builder,"InformationLabel");
widgets->RepoList = GTK_TREE_STORE(gtk_builder_get_object(builder,"RepoStore"));
widgets->RepoFileList = GTK_LIST_STORE(gtk_builder_get_object(builder,"RepoFileList"));
widgets->RepoPackagesList = GTK_LIST_STORE(gtk_builder_get_object(builder,"RepoPackageList"));
{
widgets->KeyMenuItem = gtk_menu_item_new();
gtk_menu_shell_prepend(GTK_MENU_SHELL(gtk_widget_get_parent(widgets->AboutMenuItem)),widgets->KeyMenuItem);
GtkWidget *icon = gtk_image_new_from_icon_name(key_icon_name,GTK_ICON_SIZE_BUTTON);
GtkWidget *label = gtk_label_new(KEY_LABEL);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
gtk_box_pack_start(GTK_BOX(box),icon,0,0,5);
gtk_box_pack_start(GTK_BOX(box),label,0,0,5);
gtk_container_add(GTK_CONTAINER(widgets->KeyMenuItem),box);
gtk_widget_show_all(widgets->KeyMenuItem);
gtk_style_context_add_class(gtk_widget_get_style_context(widgets->KeyMenuItem),"menuitemtop");
gtk_style_context_remove_class(gtk_widget_get_style_context(widgets->DocumentationMenuItem),"menuitemtop");
gtk_style_context_add_class(gtk_widget_get_style_context(widgets->DocumentationMenuItem),"menuitemmiddle");
g_signal_connect(G_OBJECT(widgets->KeyMenuItem),"activate",G_CALLBACK(on_key_clicked),widgets);
}
main_config.tree_store = widgets->RepoList;
rmb_menu_window *rmb = yon_rmb_menu_setup(widgets->RepoFileTree, yon_tree_is_selected,widgets,
SIGN_LABEL,lib_key_icon_name,G_CALLBACK(on_packages_sign),widgets,
MOVE_PACKAGES_TITLE_LABEL,move_icon,G_CALLBACK(on_rmb_move),widgets,
REMOVE_PACKAGES_TITLE_LABEL,remove_icon,G_CALLBACK(on_rmb_remove),widgets,
NULL);
g_signal_connect(G_OBJECT(widgets->DBConfigurationButton),"clicked",G_CALLBACK(on_storage_configure_clicked),widgets);
g_signal_connect(G_OBJECT(widgets->AddButton),"clicked",G_CALLBACK(on_add_clicked),widgets);
g_signal_connect(G_OBJECT(widgets->MoveButton),"clicked",G_CALLBACK(on_move_clicked),widgets);
g_signal_connect(G_OBJECT(widgets->RemoveButton),"clicked",G_CALLBACK(on_remove_clicked),widgets);
g_signal_connect(G_OBJECT(widgets->ReposTree),"cursor-changed",G_CALLBACK(on_main_tree_selection_changed),widgets);
g_signal_connect(G_OBJECT(widgets->CloudButton),"clicked",G_CALLBACK(on_ubl_settings_update_launch),widgets);
g_signal_connect(G_OBJECT(widgets->RepoFileTree),"cursor-changed",G_CALLBACK(on_package_selection_changed),widgets);
g_signal_connect(G_OBJECT(widgets->ReposTree),"row-activated",G_CALLBACK(on_tree_view_activate),widgets);
g_signal_connect(G_OBJECT(widgets->RepoFileTree),"row-activated",G_CALLBACK(on_repo_item_activate),widgets);
g_signal_connect(G_OBJECT(widgets->UpdateButton),"clicked",G_CALLBACK(on_update_clicked),widgets);
yon_calendar_set_date_orientation(1);
gtk_window_set_title(GTK_WINDOW(widgets->Window),TITLE_LABEL);
gtk_tree_view_set_search_entry(GTK_TREE_VIEW(widgets->RepoFileTree),GTK_ENTRY(widgets->SearchEntry));
/* Widget registration for config monitoring | Регистрация виджетов для мониторинга конфига */
/* Localisation | Локализация */
// gtk_widget_show(widgets->Window);
return widgets;
}
}
int main(int argc, char *argv[]){
setlocale(LC_ALL, "");
textdomain (LocaleName);
config_init();
yon_ubl_connect_config((_template_config*)&main_config);
yon_ubl_window_init(TITLE_LABEL,TITLE_INFO_LABEL,LocaleName,CssPath,LocaleName,version_application,WIKI_LINK);
config_str unfound = NULL;
int size=0;
yon_ubl_setup_arguments(argc,argv,&unfound,&size,NULL);
gtk_init(&argc,&argv);
template_main_window *widgets = yon_ubl_window_setup();
gtk_widget_hide(gtk_menu_get_attach_widget(GTK_MENU(gtk_widget_get_parent(widgets->SaveMenuItem))));
gtk_widget_hide(gtk_menu_get_attach_widget(GTK_MENU(gtk_widget_get_parent(widgets->LoadGlobalMenuItem))));
widgets = (template_main_window*)yon_main_window_complete((main_window*)widgets);
char *path = yon_char_unite(yon_ubl_user_get_home_directory(),"/.config/",LocaleName,"/",LocaleName,".conf",NULL);
yon_window_config_load(path);
yon_config_load_update((main_window*)widgets);
yon_ubl_status_box_render(DATA_LOADED_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
gtk_main();
return 0;
}
Reference in new issue View Git Blame Copy Permalink