Applications
/
libublsettings-gtk3
8
0
Fork 1
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

Fixed packages info output #67

Merged
asmeron merged 5 commits from YanTheKaller/libublsettings-gtk3:master into master 2 months ago
Conversation 0 Commits 5 Files Changed 4
4 changed files with 266 additions and 294 deletions
Show Stats Download Patch File Download Diff File

2
source/libublsettings-gtk3-packages.c
Unescape View File

@ -413,7 +413,7 @@ char *yon_packages_get_info_string(yon_packages_info *info){
"<b>",_("Download Size"),"</b>\t:",yon_char_return_if_exist(info->download_size,""),"\n",
"<b>",_("Installed Size"),"</b>\t:",yon_char_return_if_exist(info->install_size,""),"\n",
"<b>",_("Packager"),"</b>\t\t:",g_markup_escape_text(packager,strlen(packager)),"\n",
"<b>",_("Build Date"),"</b>\t\t:",yon_char_return_if_exist(info->build_date,""),"\n",
"<b>",_("Build Date"),"</b>\t\t:",yon_char_return_if_exist(info->build_date,""),//"\n",
// "<b>",_("Validated By"),"</b>\t:",yon_char_return_if_exist(info->architecture,""),
NULL);
return info_label;

548
source/libublsettings-gtk3-status.c
Unescape View File

@ -1,28 +1,66 @@
#include "libublsettings-gtk3.h"
static render_data render = {};
// static render_data render = {};
struct status_struct {
GtkWidget *box;
GtkWidget *revealer;
GtkWidget *label;
GtkWidget *icon;
guint thread;
GMutex mutex;
int sleep_timer;
int window_height;
};
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);
}
void __yon_ubl_status_box_destroyed(GtkWidget *self,struct status_struct *statusstruct);
void yon_ubl_status_box_despawn(GtkContainer *status_container);
gboolean yon_ubl_status_destroy_status(struct status_struct *statusstruct);
gboolean _yon_ubl_status_box_timed_remove(struct status_struct *statusstruct);
gboolean yon_status_shrink_window(struct status_struct *statusstruct);
void yon_status_struct_destroy(struct status_struct *status);
GMutex status_remove_mutex;
struct status_struct *render = NULL;
struct status_struct *yon_status_struct_new(){
struct status_struct *status = malloc(sizeof(struct status_struct));
memset(status,0,sizeof(struct status_struct));
status->box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
status->revealer = gtk_revealer_new();
status->label = gtk_label_new("");
status->icon = gtk_image_new();
gtk_label_set_line_wrap(GTK_LABEL(status->label),1);
gtk_label_set_line_wrap_mode(GTK_LABEL(status->label),PANGO_WRAP_WORD);
gtk_container_add(GTK_CONTAINER(status->revealer),status->box);
gtk_box_pack_start(GTK_BOX(status->box),status->icon,0,0,5);
gtk_box_pack_start(GTK_BOX(status->box),status->label,0,0,5);
gtk_widget_set_margin_bottom(status->label,9);
gtk_widget_set_margin_top(status->label,9);
gtk_label_set_xalign(GTK_LABEL(status->label),0.0);
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;
}
PangoAttrList *attributes = pango_attr_list_new();
PangoAttribute *boldAttr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
pango_attr_list_insert(attributes, boldAttr);
gtk_label_set_attributes(GTK_LABEL(status->label),attributes);
int yon_status_box_is_set(){
if (render.box){
return 1;
}
return 0;
GdkRGBA textColor;
gdk_rgba_parse(&textColor, "#4d4d4d4d4d4d");
PangoAttribute *colorAttr = pango_attr_foreground_new(
(int)(textColor.red * 65535),
(int)(textColor.green * 65535),
(int)(textColor.blue * 65535)
);
pango_attr_list_insert(attributes, colorAttr);
gtk_revealer_set_transition_duration(GTK_REVEALER(status->revealer),200);
g_signal_connect(G_OBJECT(status->revealer),"destroy", G_CALLBACK(__yon_ubl_status_box_destroyed),status);
g_object_set_data(G_OBJECT(status->revealer),"status_struct",status);
gtk_widget_show_all(status->revealer);
return status;
}
GMutex _render_block_mutex;
@ -42,96 +80,37 @@ void yon_ubl_status_box_block_input(int seconds){
g_thread_new("block_thread",(GThreadFunc)_yon_ubl_status_box_block_input,&seconds);
}
void yon_ubl_status_box_set(BACKGROUND_IMAGE_TYPE type, GtkWidget *box, GtkImage *icon){
void yon_ubl_status_box_set(BACKGROUND_IMAGE_TYPE type, GtkRevealer *root){
struct status_struct *status = g_object_get_data(G_OBJECT(root),"status_struct");
if (!status){
status = g_object_get_data(G_OBJECT(root),"status_def_struct");
}
GtkIconTheme *ictheme = gtk_icon_theme_get_default();
switch (type){
case BACKGROUND_IMAGE_SUCCESS_TYPE:
{
gtk_style_context_remove_class(gtk_widget_get_style_context(box), "boxInfoMessError");
gtk_style_context_add_class(gtk_widget_get_style_context(box), "boxInfoMessOK");
gtk_image_set_from_pixbuf(GTK_IMAGE(icon), gtk_icon_theme_load_icon_for_scale(ictheme, "com.ublinux.libublsettingsui-gtk3.checked", 25, 1, GTK_ICON_LOOKUP_FORCE_SIZE, NULL));
case BACKGROUND_IMAGE_SUCCESS_TYPE:{
gtk_style_context_remove_class(gtk_widget_get_style_context(status->box), "boxInfoMessError");
gtk_style_context_add_class(gtk_widget_get_style_context(status->box), "boxInfoMessOK");
gtk_image_set_from_icon_name(GTK_IMAGE(status->icon),"com.ublinux.libublsettingsui-gtk3.checked",GTK_ICON_SIZE_BUTTON);
gtk_image_set_pixel_size(GTK_IMAGE(status->icon),25);
}
break;
case BACKGROUND_IMAGE_FAIL_TYPE:
{
gtk_style_context_remove_class(gtk_widget_get_style_context(box), "boxInfoMessOK");
gtk_style_context_add_class(gtk_widget_get_style_context(box), "boxInfoMessError");
gtk_image_set_from_pixbuf(GTK_IMAGE(icon), gtk_icon_theme_load_icon_for_scale(ictheme, "com.ublinux.libublsettingsui-gtk3.warning", 25, 1, GTK_ICON_LOOKUP_FORCE_SIZE, NULL));
case BACKGROUND_IMAGE_FAIL_TYPE:{
gtk_style_context_remove_class(gtk_widget_get_style_context(status->box), "boxInfoMessOK");
gtk_style_context_add_class(gtk_widget_get_style_context(status->box), "boxInfoMessError");
gtk_image_set_from_icon_name(GTK_IMAGE(status->icon),"com.ublinux.libublsettingsui-gtk3.warning",GTK_ICON_SIZE_BUTTON);
gtk_image_set_pixel_size(GTK_IMAGE(status->icon),25);
}
break;
case BACKGROUND_IMAGE_INFO_TYPE:
{
gtk_style_context_remove_class(gtk_widget_get_style_context(box), "boxInfoMessError");
gtk_style_context_add_class(gtk_widget_get_style_context(box), "boxInfoMessOK");
gtk_image_set_from_pixbuf(GTK_IMAGE(icon), gtk_icon_theme_load_icon_for_scale(ictheme, "com.ublinux.libublsettingsui-gtk3.important-symbolic", 25, 1, GTK_ICON_LOOKUP_FORCE_SIZE, NULL));
case BACKGROUND_IMAGE_INFO_TYPE:{
gtk_style_context_remove_class(gtk_widget_get_style_context(status->box), "boxInfoMessError");
gtk_style_context_add_class(gtk_widget_get_style_context(status->box), "boxInfoMessOK");
gtk_image_set_from_icon_name(GTK_IMAGE(status->icon),"com.ublinux.libublsettingsui-gtk3.important-symbolic",GTK_ICON_SIZE_BUTTON);
gtk_image_set_pixel_size(GTK_IMAGE(status->icon),25);
}
break;
}
}
void _yon_ubl_status_box_render(char *text, BACKGROUND_IMAGE_TYPE type)
{
render_data data = render;
yon_ubl_status_box_set(type,data.box,GTK_IMAGE(data.icon));
if (text)
gtk_label_set_text(GTK_LABEL(data.label), text);
}
void yon_ubl_status_box_render(char *text, BACKGROUND_IMAGE_TYPE type){
g_mutex_lock(&_render_block_mutex);
int blocked = _render_blocked;
g_mutex_unlock(&_render_block_mutex);
if (blocked) return;
_yon_ubl_status_box_render(text,type);
}
struct __yon_ubl_status_box_render_thread_struct{
char *text;
BACKGROUND_IMAGE_TYPE type;
};
gboolean _yon_ubl_status_box_render_thread(struct __yon_ubl_status_box_render_thread_struct *data){
render_data statusbox = render;
yon_ubl_status_box_set(data->type,statusbox.box,GTK_IMAGE(statusbox.icon));
if (data->text){
gtk_label_set_text(GTK_LABEL(statusbox.label), data->text);
free(data->text);
}
free(data);
return G_SOURCE_REMOVE;
}
void yon_ubl_status_box_render_thread(char *text, BACKGROUND_IMAGE_TYPE type){
g_mutex_lock(&_render_block_mutex);
int blocked = _render_blocked;
g_mutex_unlock(&_render_block_mutex);
if (blocked) return;
struct __yon_ubl_status_box_render_thread_struct *data = malloc(sizeof(struct __yon_ubl_status_box_render_thread_struct));
data->text=yon_char_new(text);
data->type=type;
g_idle_add((GSourceFunc)_yon_ubl_status_box_render_thread,data);
}
gboolean _yon_ubl_status_highlight_incorrect_start(GtkWidget *widget){
gtk_style_context_add_class(gtk_widget_get_style_context(widget),"errorBox");
return G_SOURCE_REMOVE;
}
gboolean _yon_ubl_status_highlight_incorrect_stop(GtkWidget *widget){
gtk_style_context_remove_class(gtk_widget_get_style_context(widget),"errorBox");
return G_SOURCE_REMOVE;
}
gboolean _yon_ubl_status_highlight_incorrect(GtkWidget *widget){
g_idle_add((GSourceFunc)_yon_ubl_status_highlight_incorrect_start,widget);
sleep(5);
g_idle_add((GSourceFunc)_yon_ubl_status_highlight_incorrect_stop,widget);
}
void yon_ubl_status_highlight_incorrect(GtkWidget *widget){
g_thread_new("error_highlight",(GThreadFunc)_yon_ubl_status_highlight_incorrect,widget);
}
gboolean _yon_ubl_status_list_store_highlight_incorrect_start(GtkWidget **widget_pack){
GtkListStore *list = (GtkListStore*)widget_pack[0];
@ -157,9 +136,9 @@ gboolean _yon_ubl_status_list_store_highlight_incorrect_stop(GtkWidget **widget_
}
void _yon_ubl_status_list_store_highlight_incorrect(GtkWidget **widget_pack){
g_idle_add((GSourceFunc)_yon_ubl_status_highlight_incorrect_stop,widget_pack);
g_idle_add((GSourceFunc)_yon_ubl_status_list_store_highlight_incorrect_start,widget_pack);
sleep(5);
g_idle_add((GSourceFunc)_yon_ubl_status_highlight_incorrect_stop,widget_pack);
g_idle_add((GSourceFunc)_yon_ubl_status_list_store_highlight_incorrect_stop,widget_pack);
}
void yon_ubl_status_list_store_highlight_incorrect(GtkListStore *list, GtkTreeIter *iter){
@ -175,224 +154,223 @@ struct temp_statusbox {
int window_height;
};
static char *yon_status_thread_id=NULL;
// Standard status box functions
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);
}
gboolean yon_ubl_status_hide_revealer(struct temp_statusbox *statusstruct){
gtk_revealer_set_reveal_child(GTK_REVEALER(statusstruct->revealer),0);
int yon_ubl_status_box_setup(GtkWidget *icon, GtkWidget *box, GtkWidget *label){
if(icon&&box&&label){
render = malloc(sizeof(struct status_struct));
memset(render,0,sizeof(struct status_struct));
render->box = box;
render->label = label;
render->icon = icon;
g_object_set_data(G_OBJECT(render->box),"status_def_struct",render);
return 1;
} else return 0;
}
int yon_status_box_is_set(){
if (render){
return 1;
}
return 0;
}
gboolean yon_status_shrink_window(struct temp_statusbox *statusstruct){
if (statusstruct->revealer){
GtkWidget *window = gtk_widget_get_toplevel(statusstruct->revealer);
int width, height;
gtk_window_get_size(GTK_WINDOW(window),&width,NULL);
gtk_window_resize(GTK_WINDOW(window),width,statusstruct->window_height);
return G_SOURCE_CONTINUE;
} else return G_SOURCE_REMOVE;
void _yon_ubl_status_box_render(char *text, BACKGROUND_IMAGE_TYPE type){
struct status_struct *data = render;
yon_ubl_status_box_set(type,(GtkRevealer*)data->box);
if (text)
gtk_label_set_text(GTK_LABEL(data->label), text);
}
gboolean yon_ubl_status_destroy_status(struct temp_statusbox *statusstruct){
GtkWidget *window = gtk_widget_get_toplevel(statusstruct->revealer);
GtkWidget *revealer = statusstruct->revealer;
gtk_widget_destroy(statusstruct->revealer);
statusstruct->revealer = NULL;
int width, height;
gtk_window_get_size(GTK_WINDOW(window),&width,NULL);
gtk_window_resize(GTK_WINDOW(window),width,statusstruct->window_height);
return G_SOURCE_REMOVE;
void yon_ubl_status_box_render(char *text, BACKGROUND_IMAGE_TYPE type){
g_mutex_lock(&_render_block_mutex);
int blocked = _render_blocked;
g_mutex_unlock(&_render_block_mutex);
if (blocked) return;
_yon_ubl_status_box_render(text,type);
}
void _yon_ubl_status_box_timed_remove(struct temp_statusbox *statusstruct){
sleep(statusstruct->times);
if (statusstruct->revealer){
g_idle_add((GSourceFunc)yon_ubl_status_hide_revealer,statusstruct);
g_idle_add((GSourceFunc)yon_status_shrink_window,statusstruct);
sleep(1);
g_idle_add((GSourceFunc)yon_ubl_status_destroy_status,statusstruct);
struct __yon_ubl_status_box_render_thread_struct{
char *text;
BACKGROUND_IMAGE_TYPE type;
};
void _yon_ubl_status_box_render_thread(struct __yon_ubl_status_box_render_thread_struct *data){
struct status_struct *statusbox = render;
yon_ubl_status_box_set(data->type,GTK_REVEALER(statusbox->revealer));
if (data->text){
gtk_label_set_text(GTK_LABEL(statusbox->label), data->text);
free(data->text);
}
free(data);
}
void __yon_ubl_status_box_destroyed(GtkWidget *self,struct temp_statusbox *statusstruct){
statusstruct->revealer=NULL;
void yon_ubl_status_box_render_thread(char *text, BACKGROUND_IMAGE_TYPE type){
g_mutex_lock(&_render_block_mutex);
int blocked = _render_blocked;
g_mutex_unlock(&_render_block_mutex);
if (blocked) return;
struct __yon_ubl_status_box_render_thread_struct *data = malloc(sizeof(struct __yon_ubl_status_box_render_thread_struct));
data->text=yon_char_new(text);
data->type=type;
g_idle_add_once((GSourceOnceFunc)_yon_ubl_status_box_render_thread,data);
}
void yon_status_box_destroyed(){
if (yon_status_thread_id){
free(yon_status_thread_id);
yon_status_thread_id=NULL;
}
// Status spawn functions
void __yon_ubl_status_box_destroyed(GtkWidget *,struct status_struct *statusstruct){
}
int yon_ubl_status_box_spawn_infinite(GtkContainer *container, char *status_id, char *display_text, BACKGROUND_IMAGE_TYPE type){
void yon_ubl_status_box_spawn(GtkContainer *container,char *display_text, int timeout,BACKGROUND_IMAGE_TYPE type){
g_mutex_lock(&_render_block_mutex);
int blocked = _render_blocked;
g_mutex_unlock(&_render_block_mutex);
if (blocked) return 0;
// if (!gtk_container_get_children(container)){
if (yon_status_thread_id){
if (!strcmp(yon_status_thread_id,status_id)){
return 0;
}
free(yon_status_thread_id);
yon_status_thread_id=NULL;
GList *list = gtk_container_get_children(container);
for (int i=0;i<g_list_length(list);i++){
gtk_widget_destroy((GtkWidget*)g_list_nth_data(list,i));
}
if (blocked) return;
GList *list = gtk_container_get_children(container);
guint len = g_list_length(list);
if (len>=3){
struct status_struct *status = g_object_get_data(G_OBJECT(g_list_nth_data(list,len-3)),"status_struct");
g_mutex_lock(&status_remove_mutex);
if (status&&gtk_revealer_get_reveal_child(GTK_REVEALER(status->revealer))){
yon_status_struct_destroy(status);
}
yon_status_thread_id = yon_char_new(status_id);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
GtkWidget *revealer = gtk_revealer_new();
GtkWidget *label = gtk_label_new("");
GtkWidget *icon = gtk_image_new();
g_signal_connect(G_OBJECT(box),"destroy",G_CALLBACK(yon_status_box_destroyed),NULL);
gtk_label_set_line_wrap(GTK_LABEL(label),1);
gtk_label_set_line_wrap_mode(GTK_LABEL(label),PANGO_WRAP_WORD);
gtk_container_add(GTK_CONTAINER(revealer),box);
gtk_box_pack_start(GTK_BOX(box),icon,0,0,5);
gtk_box_pack_start(GTK_BOX(box),label,0,0,0);
gtk_container_add(container,revealer);
gtk_widget_show_all(revealer);
gtk_revealer_set_reveal_child(GTK_REVEALER(revealer),1);
gtk_widget_set_margin_bottom(label,9);
gtk_widget_set_margin_top(label,9);
gtk_label_set_xalign(GTK_LABEL(label),0.0);
PangoAttrList *attributes = pango_attr_list_new();
PangoAttribute *boldAttr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
pango_attr_list_insert(attributes, boldAttr);
gtk_label_set_attributes(GTK_LABEL(label),attributes);
GdkRGBA textColor;
gdk_rgba_parse(&textColor, "#4d4d4d4d4d4d");
PangoAttribute *colorAttr = pango_attr_foreground_new(
(int)(textColor.red * 65535),
(int)(textColor.green * 65535),
(int)(textColor.blue * 65535)
);
pango_attr_list_insert(attributes, colorAttr);
yon_ubl_status_box_set(type,box,GTK_IMAGE(icon));
if (display_text)
gtk_label_set_text(GTK_LABEL(label),display_text);
struct temp_statusbox *statusstruct = malloc(sizeof(struct temp_statusbox));
g_signal_connect(G_OBJECT(revealer),"destroy", G_CALLBACK(__yon_ubl_status_box_destroyed),statusstruct);
statusstruct->revealer = revealer;
gtk_window_get_size(GTK_WINDOW(gtk_widget_get_toplevel(revealer)),NULL,&statusstruct->window_height);
// }
}
g_mutex_unlock(&status_remove_mutex);
}
int delete_busy=0;
int _yon_ubl_status_box_despawn_infinite(GtkContainer *container){
if (!delete_busy){
delete_busy=1;
if (yon_status_thread_id){
free(yon_status_thread_id);
yon_status_thread_id=NULL;
}
GList *list = gtk_container_get_children(container);
for (int i=0; i<g_list_length(list);i++){
GtkWidget *revealer = g_list_nth_data(list,i);
g_list_free(list);
if (GTK_IS_REVEALER(revealer)){
gtk_revealer_set_reveal_child(GTK_REVEALER(revealer),0);
usleep(200000);
list = gtk_container_get_children(container);
if (g_list_length>0){
if (GTK_IS_REVEALER(revealer)){
gtk_widget_destroy(revealer);
}
}
}
}
delete_busy=0;
struct status_struct *status = yon_status_struct_new();
status->sleep_timer = timeout;
gtk_container_add(container,status->revealer);
gtk_revealer_set_reveal_child(GTK_REVEALER(status->revealer),1);
yon_ubl_status_box_set(type,GTK_REVEALER(status->revealer));
if (display_text){
gtk_label_set_text(GTK_LABEL(status->label),display_text);
}
gtk_window_get_size(GTK_WINDOW(gtk_widget_get_toplevel(status->revealer)),NULL,&status->window_height);
if (status->sleep_timer>0){
g_mutex_lock(&status_remove_mutex);
g_mutex_lock(&status->mutex);
status->thread = g_timeout_add(status->sleep_timer*1000,(GSourceFunc)_yon_ubl_status_box_timed_remove,status);
g_mutex_unlock(&status->mutex);
g_mutex_unlock(&status_remove_mutex);
}
}
int yon_ubl_status_box_despawn_infinite(GtkContainer *container){
GThread *thread = g_thread_new("StatusThread",(GThreadFunc)_yon_ubl_status_box_despawn_infinite,container);
// Status despawn functions
void yon_ubl_status_hide_revealer(struct status_struct *status){
gtk_revealer_set_transition_type(GTK_REVEALER(status->revealer),GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP);
gtk_revealer_set_reveal_child(GTK_REVEALER(status->revealer),0);
}
void *__yon_ubl_status_box_despawn(GtkContainer *status_container){
GList *list = gtk_container_get_children(status_container);
GtkWidget *revealer = g_list_nth_data(list,0);
struct temp_statusbox *statusstruct = malloc(sizeof(struct temp_statusbox));
statusstruct->revealer = revealer;
statusstruct->times = 0;
g_idle_add((GSourceFunc)yon_ubl_status_hide_revealer,statusstruct);
sleep(1);
gtk_widget_destroy(statusstruct->revealer);
g_list_free(list);
return NULL;
gboolean __yon_ubl_status_box_despawn(struct status_struct *status){
gtk_widget_destroy(status->revealer);
free(status);
return G_SOURCE_REMOVE;
}
void yon_ubl_status_box_despawn(GtkContainer *status_container){
GList *list = gtk_container_get_children(status_container);
if (!list) return;
GList *iter;
for (iter=list;iter;iter=iter->next){
struct status_struct *status = g_object_get_data(G_OBJECT(status_container),"status_struct");
if (status->thread>(guint)0){
g_mutex_lock(&status->mutex);
g_source_remove(status->thread);
status->thread=0;
g_mutex_unlock(&status->mutex);
}
g_idle_add_once((GSourceOnceFunc)yon_ubl_status_hide_revealer,status);
g_timeout_add(1000,(GSourceFunc)__yon_ubl_status_box_despawn,status);
}
g_list_free(list);
g_thread_new("status_despawn",(GThreadFunc)__yon_ubl_status_box_despawn,status_container);
return;
}
void yon_ubl_status_box_spawn(GtkContainer *container,char *display_text, int timeout,BACKGROUND_IMAGE_TYPE type){
g_mutex_lock(&_render_block_mutex);
int blocked = _render_blocked;
g_mutex_unlock(&_render_block_mutex);
if (blocked) return;
if (gtk_container_get_children(container))return;
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
GtkWidget *revealer = gtk_revealer_new();
GtkWidget *label = gtk_label_new("");
GtkWidget *icon = gtk_image_new();
gtk_label_set_line_wrap(GTK_LABEL(label),1);
gtk_label_set_line_wrap_mode(GTK_LABEL(label),PANGO_WRAP_WORD);
gtk_container_add(GTK_CONTAINER(revealer),box);
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(container,revealer);
gtk_widget_show_all(revealer);
gtk_revealer_set_reveal_child(GTK_REVEALER(revealer),1);
gtk_widget_set_margin_bottom(label,9);
gtk_widget_set_margin_top(label,9);
gtk_label_set_xalign(GTK_LABEL(label),0.0);
PangoAttrList *attributes = pango_attr_list_new();
PangoAttribute *boldAttr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
pango_attr_list_insert(attributes, boldAttr);
gtk_label_set_attributes(GTK_LABEL(label),attributes);
gboolean _yon_ubl_status_box_timed_remove(struct status_struct *statusstruct){
if (statusstruct->revealer){
yon_ubl_status_hide_revealer(statusstruct);
g_idle_add((GSourceFunc)yon_status_shrink_window,statusstruct);
g_timeout_add(200,(GSourceFunc)yon_ubl_status_destroy_status,statusstruct);
}
return G_SOURCE_REMOVE;
}
GdkRGBA textColor;
gdk_rgba_parse(&textColor, "#4d4d4d4d4d4d");
PangoAttribute *colorAttr = pango_attr_foreground_new(
(int)(textColor.red * 65535),
(int)(textColor.green * 65535),
(int)(textColor.blue * 65535)
);
pango_attr_list_insert(attributes, colorAttr);
yon_ubl_status_box_set(type,box,GTK_IMAGE(icon));
if (display_text)
gtk_label_set_text(GTK_LABEL(label),display_text);
struct temp_statusbox *statusstruct = malloc(sizeof(struct temp_statusbox));
statusstruct->revealer = revealer;
statusstruct->times = timeout;
g_object_add_weak_pointer(G_OBJECT(revealer),(gpointer*)&statusstruct->revealer);
gtk_window_get_size(GTK_WINDOW(gtk_widget_get_toplevel(revealer)),NULL,&statusstruct->window_height);
g_signal_connect(G_OBJECT(revealer),"destroy", G_CALLBACK(__yon_ubl_status_box_destroyed),statusstruct);
GThread *thread = g_thread_new("StatusThread",(GThreadFunc)_yon_ubl_status_box_timed_remove,statusstruct);
gboolean yon_ubl_status_destroy_status(struct status_struct *statusstruct){
if (statusstruct->window_height <=0) return G_SOURCE_REMOVE;
GtkWidget *window = gtk_widget_get_toplevel(statusstruct->revealer);
gtk_widget_destroy(statusstruct->revealer);
statusstruct->revealer = NULL;
int width, height;
gtk_window_get_size(GTK_WINDOW(window),&width,NULL);
gtk_window_resize(GTK_WINDOW(window),width,statusstruct->window_height);
return G_SOURCE_REMOVE;
}
int yon_ubl_status_set_text(GtkContainer *status_placeholder,char *text){
GList *placeholder_children = gtk_container_get_children(status_placeholder);
if (placeholder_children){
GList *status_children = gtk_container_get_children(GTK_CONTAINER(placeholder_children->data));
if (status_children){
gtk_label_set_text(GTK_LABEL(g_list_nth_data(status_children,1)),text);
g_list_free(status_children);
}
g_list_free(placeholder_children);
gboolean yon_status_shrink_window(struct status_struct *statusstruct){
if (statusstruct->revealer){
GtkWidget *window = gtk_widget_get_toplevel(statusstruct->revealer);
int width, height;
gtk_window_get_size(GTK_WINDOW(window),&width,NULL);
gtk_window_resize(GTK_WINDOW(window),width,statusstruct->window_height);
return G_SOURCE_CONTINUE;
}
}
void yon_status_struct_destroy(struct status_struct *status){
_yon_ubl_status_box_timed_remove(status);
g_mutex_lock(&status->mutex);
g_source_remove(status->thread);
status->thread=0;
g_mutex_unlock(&status->mutex);
}
// Widget highlight functions
gboolean _yon_ubl_status_highlight_incorrect_start(GtkWidget *widget){
gtk_style_context_add_class(gtk_widget_get_style_context(widget),"errorBox");
return G_SOURCE_REMOVE;
}
gboolean _yon_ubl_status_highlight_incorrect_stop(GtkWidget *widget){
gtk_style_context_remove_class(gtk_widget_get_style_context(widget),"errorBox");
guint *thread = g_object_get_data(G_OBJECT(widget),"highlight_thread");
if (thread&&(*thread)>(guint)0){
g_object_set_data(G_OBJECT(widget),"highlight_thread",NULL);
free(thread);
}
return 0;
return G_SOURCE_REMOVE;
}
gboolean _yon_ubl_status_highlight_incorrect(GtkWidget *widget){
g_idle_add((GSourceFunc)_yon_ubl_status_highlight_incorrect_stop,widget);
return G_SOURCE_REMOVE;
}
void yon_ubl_status_highlight_incorrect(GtkWidget *widget){
guint *thread = NULL;
thread = g_object_get_data(G_OBJECT(widget),"highlight_thread");
if (thread&&(*thread)>(guint)0){
g_source_remove((*thread));
g_object_set_data(G_OBJECT(widget),"highlight_thread",NULL);
free(thread);
}
thread = malloc(sizeof(guint));
_yon_ubl_status_highlight_incorrect_start(widget);
(*thread) = g_timeout_add(5000,(GSourceFunc)_yon_ubl_status_highlight_incorrect,widget);
g_object_set_data(G_OBJECT(widget),"highlight_thread",thread);
}

4
source/libublsettings-gtk3-vte.c
Unescape View File

@ -80,8 +80,8 @@ void yon_terminal_integrated_start_shell(GtkWidget *terminal, char* command, voi
}
void __on_yon_terminal_done(GtkWidget *, int state, terminal_window_struct *data){
if (!state) yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(data->StatusBox),"terminal_done",data->success_label,BACKGROUND_IMAGE_SUCCESS_TYPE);
else yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(data->StatusBox),"terminal_done",data->fail_label,BACKGROUND_IMAGE_FAIL_TYPE);
if (!state) yon_ubl_status_box_spawn(GTK_CONTAINER(data->StatusBox),data->success_label,0,BACKGROUND_IMAGE_SUCCESS_TYPE);
else yon_ubl_status_box_spawn(GTK_CONTAINER(data->StatusBox),data->fail_label,0,BACKGROUND_IMAGE_FAIL_TYPE);
}
struct terminal_window {

6
source/libublsettings-gtk3.h
Unescape View File

@ -432,9 +432,6 @@ void yon_ubl_status_list_store_highlight_incorrect(GtkListStore *list, GtkTreeIt
static int status_thread_busy;
int yon_ubl_status_box_spawn_infinite(GtkContainer *container, char *status_id, char *display_text, BACKGROUND_IMAGE_TYPE type);
int yon_ubl_status_box_despawn_infinite(GtkContainer *container);
/**yon_ubl_status_box_spawn(GtkContainer *container,char *display_text, int timeout,BACKGROUND_IMAGE_TYPE type);
* [EN]
*
@ -449,9 +446,6 @@ int yon_ubl_status_box_despawn_infinite(GtkContainer *container);
void yon_ubl_status_box_spawn(GtkContainer *container,char *display_text, int timeout,BACKGROUND_IMAGE_TYPE type);
void yon_ubl_status_box_despawn(GtkContainer *status_container);
int yon_ubl_status_set_text(GtkContainer *status_placeholder,char *text);
//socket section
/**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]

Write Preview
Loading…
Cancel
Save