//=====================================================================
int GUI_entry_styl (MemObj *o_par, int imod) {
//=====================================================================
/// \code
/// GUI_entry_styl modify frame of entry;
/// imod 0=GUI_STYL_normal=default_frame; 1=GUI_STYL_activ=red_frame.
/// \endcode
// see GUI_button_styl
static GtkRcStyle *styl0 = NULL, *styl1;
int pTyp, i1;
Obj_Unknown *go;
GUI_obj_typ (&pTyp, (void**)&go, o_par);
if(!pTyp) return (-1);
if(!styl0) {
styl0 = gtk_rc_style_new ();
styl0->color_flags[GTK_STATE_NORMAL] = GTK_RC_BASE;
gdk_color_parse ("gray90", &styl0->base[0]);
styl1 = gtk_rc_style_new ();
styl1->color_flags[GTK_STATE_NORMAL] = GTK_RC_BASE;
gdk_color_parse ("white", &styl1->base[0]); // from X11 rgb.txt file
}
// gtk_widget_set_can_focus(go->widget, TRUE);
// gtk_widget_set_can_default (go->widget, TRUE);
// gtk_entry_set_has_frame (GTK_ENTRY(go->widget), TRUE);
if(imod < 1) { // GUI_STYL_normal
gtk_widget_modify_style (go->widget, styl0);
// gtk_widget_modify_bg (go->widget, GTK_STATE_NORMAL, &col1);
// gtk_entry_set_has_frame (GTK_ENTRY(go->widget), FALSE);
// i1 = GTK_SHADOW_IN;
// i1 = GTK_SHADOW_ETCHED_IN;
// g_object_set (G_OBJECT(go->widget),"shadow-type", i1, NULL);
// gtk_widget_restore_default_style (go->widget);
} else { // GUI_STYL_activ
gtk_widget_modify_style (go->widget, styl1);
// gtk_entry_set_has_frame (GTK_ENTRY(go->widget), TRUE);
// gtk_widget_grab_focus (go->widget);
// gtk_widget_has_default (go->widget);
// gtk_entry_set_has_frame (GTK_ENTRY(go->widget), TRUE);
// i1 = GTK_SHADOW_ETCHED_OUT;
// i1 = GTK_SHADOW_OUT;
// i1 = GTK_SHADOW_ETCHED_OUT;
// g_object_set (G_OBJECT(go->widget),"shadow-type", i1, NULL);
// gtk_widget_set_style (go->widget, UI_stylTab[iCol]);
}
return 0;
}
void applet_back_change (MyPanelApplet *a, MyPanelAppletBackgroundType type, GdkColor *color, GdkPixmap *pixmap, streamer_applet *applet) {
// taken from the TrashApplet
GtkRcStyle *rc_style;
GtkStyle *style;
// reset style
gtk_widget_set_style (GTK_WIDGET(applet->applet), NULL);
gtk_widget_set_style (GTK_WIDGET(applet->event_box), NULL);
rc_style = gtk_rc_style_new ();
gtk_widget_modify_style (GTK_WIDGET(applet->applet), rc_style);
gtk_widget_modify_style (GTK_WIDGET(applet->event_box), rc_style);
g_object_unref (rc_style);
switch (type) {
case PANEL_COLOR_BACKGROUND:
gtk_widget_modify_bg (GTK_WIDGET(applet->applet), GTK_STATE_NORMAL, color);
gtk_widget_modify_bg (GTK_WIDGET(applet->event_box), GTK_STATE_NORMAL, color);
break;
case PANEL_PIXMAP_BACKGROUND:
style = gtk_style_copy (gtk_widget_get_style (GTK_WIDGET(applet->applet)));
if (style->bg_pixmap[GTK_STATE_NORMAL])
g_object_unref (style->bg_pixmap[GTK_STATE_NORMAL]);
style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap);
gtk_widget_set_style (GTK_WIDGET(applet->applet), style);
gtk_widget_set_style (GTK_WIDGET(applet->event_box), style);
g_object_unref (style);
break;
case PANEL_NO_BACKGROUND:
default:
break;
}
}
void
setup_sload(t_sload *sload)
{
GtkRcStyle *rc;
gtk_widget_hide(sload->label);
gtk_label_set_text(GTK_LABEL(sload->label), sload->options.label_text);
if (sload->options.use_label)
{
gtk_widget_show(sload->label);
}
gtk_widget_hide(GTK_WIDGET(sload->status));
rc = gtk_widget_get_modifier_style(GTK_WIDGET(sload->status));
if (!rc) {
rc = gtk_rc_style_new();
}
if (rc) {
rc->color_flags[GTK_STATE_PRELIGHT] |= GTK_RC_BG;
rc->bg[GTK_STATE_PRELIGHT] = sload->options.color;
}
gtk_widget_modify_style(GTK_WIDGET(sload->status), rc);
gtk_widget_show(GTK_WIDGET(sload->status));
}
/* Create a new tab. */
LXTab * lxterminal_tab_label_new(const gchar * str)
{
/* Allocate LXTab structure. */
LXTab * tab = g_slice_new0(LXTab);
/* Create a horizontal box as the toplevel. */
tab->main = gtk_hbox_new(FALSE, 4);
/* Create the Close button. */
tab->close_btn = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(tab->close_btn), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click(GTK_BUTTON(tab->close_btn), FALSE);
gtk_container_add(GTK_CONTAINER(tab->close_btn), gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU));
/* Make the button as small as possible. */
GtkRcStyle * rcstyle = gtk_rc_style_new();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style(tab->close_btn, rcstyle);
gtk_rc_style_unref(rcstyle),
/* Create the label. */
tab->label = gtk_label_new(str);
gtk_widget_set_size_request(GTK_WIDGET(tab->label), 100, -1);
gtk_label_set_ellipsize(GTK_LABEL(tab->label), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment(GTK_MISC(tab->label), 0.0, 0.5);
gtk_misc_set_padding(GTK_MISC(tab->label), 0, 0);
/* Pack everything, show the widget and return. */
gtk_box_pack_start(GTK_BOX(tab->main), tab->label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(tab->main), tab->close_btn, FALSE, FALSE, 0);
gtk_widget_show_all(tab->main);
return tab;
}
void tabmanagergui_create_label (GuTabPage* tp, gchar* labeltext) {
static unsigned count = 0;
GtkRcStyle* rcstyle = NULL;
GtkWidget* image = NULL;
GtkHBox* hbox;
tp->labelbox = gtk_event_box_new ();
hbox = GTK_HBOX (gtk_hbox_new (FALSE, 0));
tp->unsavednr = ++count;
gtk_event_box_set_visible_window (GTK_EVENT_BOX (tp->labelbox), FALSE);
gtk_container_add (GTK_CONTAINER(tp->labelbox), GTK_WIDGET (hbox));
tp->label = GTK_LABEL (gtk_label_new (labeltext));
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (tp->label), TRUE, TRUE, 5);
tp->button = GTK_BUTTON (gtk_button_new());
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_button_set_image (tp->button, image);
g_object_set (tp->button, "relief", GTK_RELIEF_NONE,
"focus-on-click", FALSE, NULL);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (tp->button), FALSE,FALSE,0);
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style (GTK_WIDGET (tp->button), rcstyle);
g_object_unref (rcstyle);
gtk_widget_show_all (GTK_WIDGET (hbox));
}
/*
* Change font used to display log text, NULL means reset to default
*/
void
GTK_change_log_font(gchar *fontname)
{
#if 0 // old GTK
GtkRcStyle *rcstyle = gtk_rc_style_new();
#else
GtkStyle *rcstyle = gtk_style_new();
#endif
// if (GTK_OBJECT(v9t9_command_log)->flags & GTK_DESTROYED) {//2.0
if (!v9t9_command_log) {
g_free(rcstyle);
return;
}
if (fontname && *fontname) {
#if 0 // old GTK
rcstyle->font_name = fontname;
gtk_widget_modify_style(v9t9_command_log, rcstyle);
#else
gtk_style_set_font(rcstyle, gdk_font_load(fontname));
gtk_widget_set_style(v9t9_command_log, rcstyle);
#endif
} else {
// this is probably too harsh for a cancel
gtk_widget_restore_default_style(v9t9_command_log);
}
// g_free(rcstyle);
}
void make_cancel_button(GtkWidget *fixed_base)
{
GtkWidget *fixed;
GtkWidget *event_box;
GtkWidget *label;
fixed = fixed_base;
label = gtk_label_new(cancel_text);
gtk_widget_set_size_request(label, cancel_label_width, cancel_label_height);
gtk_widget_show(label);
GdkColor white = {0, 65535, 65535, 65535};
GtkRcStyle *rc_style = gtk_rc_style_new ();
rc_style->fg[GTK_STATE_NORMAL] = white;
rc_style->color_flags[GTK_STATE_NORMAL] |= GTK_RC_FG;
gtk_widget_modify_style(label, rc_style);
gtk_rc_style_unref(rc_style);
event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), label);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
gtk_widget_show(event_box);
g_signal_connect(G_OBJECT(event_box), "enter_notify_event",
G_CALLBACK(cancel_enter), NULL);
g_signal_connect(G_OBJECT(event_box), "leave_notify_event",
G_CALLBACK(cancel_leave), NULL);
g_signal_connect(G_OBJECT(event_box), "button_press_event",
G_CALLBACK(cancel_press), NULL);
gtk_widget_show(event_box);
gtk_fixed_put(GTK_FIXED(fixed), event_box, cancel_label_pos_x, cancel_label_pos_y);
}
/* AW: I pulled this code off the interwebs. It makes background
* transparency actually work */
void change_bg(PanelApplet *applet, PanelAppletBackgroundType type,
GdkColor *color, GdkPixmap *pixmap)
{
GtkRcStyle *rc_style;
GtkStyle *style;
/* reset style */
gtk_widget_set_style(GTK_WIDGET(applet), NULL);
rc_style = gtk_rc_style_new();
gtk_widget_modify_style(GTK_WIDGET(applet), rc_style);
gtk_rc_style_unref(rc_style);
switch(type) {
case PANEL_NO_BACKGROUND:
break;
case PANEL_COLOR_BACKGROUND:
gtk_widget_modify_bg(GTK_WIDGET(applet), GTK_STATE_NORMAL, color);
break;
case PANEL_PIXMAP_BACKGROUND:
style = gtk_style_copy(GTK_WIDGET(applet)->style);
if(style->bg_pixmap[GTK_STATE_NORMAL])
g_object_unref(style->bg_pixmap[GTK_STATE_NORMAL]);
style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap);
gtk_widget_set_style(GTK_WIDGET(applet), style);
g_object_unref(style);
break;
}
}
static void setup_monitor(t_global_monitor *global)
{
GtkRcStyle *rc;
gint i;
gtk_widget_hide(GTK_WIDGET(global->monitor->ebox));
gtk_widget_hide(global->monitor->label);
gtk_label_set_text(GTK_LABEL(global->monitor->label),
global->monitor->options.label_text);
for (i = 0; i < SUM; i++)
{
gtk_widget_hide(GTK_WIDGET(global->monitor->status[i]));
rc = gtk_widget_get_modifier_style(GTK_WIDGET(global->monitor->status[i]));
if (!rc) {
rc = gtk_rc_style_new();
}
else
{
rc->color_flags[GTK_STATE_PRELIGHT] |= GTK_RC_BG;
rc->bg[GTK_STATE_PRELIGHT] = global->monitor->options.color[i];
}
gtk_widget_modify_style(GTK_WIDGET(global->monitor->status[i]), rc);
gtk_widget_show(GTK_WIDGET(global->monitor->status[i]));
/* Maximum */
if( global->monitor->options.auto_max )
{
global->monitor->net_max[i] = INIT_MAX;
}
else
{
global->monitor->net_max[i] = global->monitor->options.max[i];
}
}
gtk_widget_show(GTK_WIDGET(global->monitor->ebox));
if (global->monitor->options.use_label)
{
gtk_widget_show(global->monitor->label);
}
if (!strcmp(global->monitor->options.network_device,
global->monitor->options.old_network_device) == 0)
{
init_netload( &(global->monitor->data), global->monitor->options.network_device);
if (global->monitor->options.old_network_device)
{
g_free(global->monitor->options.old_network_device);
}
global->monitor->options.old_network_device = g_strdup(global->monitor->options.network_device);
}
run_update( global );
}
/*----------------------------------------------------------------------------------------------------------------------*/
void SetColourMB(gint Index,gchar *ColourStr) //Set colours for multiple banana gates
{
GdkColor Colour;
gdk_color_parse(ColourStr,&Colour);
if (MBColour[Index] != NULL) gtk_rc_style_unref(MBColour[Index]);
MBColour[Index]=gtk_rc_style_new();
MBColour[Index]->fg[GTK_STATE_NORMAL]=Colour;
MBColour[Index]->color_flags[GTK_STATE_NORMAL]|=GTK_RC_FG;
}
/*----------------------------------------------------------------------------------------------------------------------*/
void SetColourD1(gint Index,gchar *ColourStr) //Set colours for 1d plots
{
GdkColor Colour;
gdk_color_parse(ColourStr,&Colour);
if (D1Colour[Index] != NULL) gtk_rc_style_unref(D1Colour[Index]);
D1Colour[Index]=gtk_rc_style_new();
D1Colour[Index]->fg[GTK_STATE_NORMAL]=Colour;
D1Colour[Index]->color_flags[GTK_STATE_NORMAL]|=GTK_RC_FG;
}
void
terminal_util_set_style_thinkess (GtkWidget *widget,
gint thinkness)
{
GtkRcStyle *style;
style = gtk_rc_style_new ();
style->xthickness = style->ythickness = thinkness;
gtk_widget_modify_style (widget, style);
g_object_unref (G_OBJECT (style));
}
void matenu_menu_bar_set_background (MatenuMenuBar* self, MatenuBackground* value) {
MatenuBackgroundType old_type;
GdkColor old_color;
GdkPixmap* _tmp0_;
g_return_if_fail (self != NULL);
old_type = self->priv->_background->type;
old_color = self->priv->_background->color;
self->priv->_background->type = value->type;
self->priv->_background->pixmap = (_tmp0_ = _g_object_ref0 (value->pixmap), _g_object_unref0 (self->priv->_background->pixmap), _tmp0_);
self->priv->_background->color = value->color;
self->priv->_background->offset_x = value->offset_x;
self->priv->_background->offset_y = value->offset_y;
switch (self->priv->_background->type) {
case MATENU_BACKGROUND_TYPE_NONE:
{
if (old_type != self->priv->_background->type) {
GtkRcStyle* rc_style;
gtk_widget_set_style ((GtkWidget*) self, NULL);
rc_style = gtk_rc_style_new ();
gtk_widget_modify_style ((GtkWidget*) self, rc_style);
_g_object_unref0 (rc_style);
}
break;
}
case MATENU_BACKGROUND_TYPE_COLOR:
{
gboolean _tmp1_ = FALSE;
if (old_type != self->priv->_background->type) {
_tmp1_ = TRUE;
} else {
gboolean _tmp2_ = FALSE;
if (old_type == self->priv->_background->type) {
_tmp2_ = !gdk_color_equal (&old_color, &self->priv->_background->color);
} else {
_tmp2_ = FALSE;
}
_tmp1_ = _tmp2_;
}
if (_tmp1_) {
gtk_widget_modify_bg ((GtkWidget*) self, GTK_STATE_NORMAL, &self->priv->_background->color);
}
break;
}
case MATENU_BACKGROUND_TYPE_PIXMAP:
{
matenu_menu_bar_reset_bg_pixmap (self);
break;
}
}
g_object_notify ((GObject *) self, "background");
}
void Color_Widget(char *colorstring, GtkWidget * widget)
{
GtkRcStyle *rc_style;
GdkColor color;
gdk_color_parse (colorstring, &color);
rc_style = gtk_rc_style_new ();
/* Set foreground (fg) color in normal state to red */
rc_style->fg[GTK_STATE_NORMAL] = color;
rc_style->color_flags[GTK_STATE_NORMAL] |= GTK_RC_FG;
gtk_widget_modify_style (widget, rc_style);
gtk_rc_style_unref (rc_style);
}
/* Applet Callback : Change the applet background. */
void
applet_change_bg_cb (MatePanelApplet *mate_panel_applet,
MatePanelAppletBackgroundType type,
GdkColor *color,
#if GTK_CHECK_VERSION (3, 0, 0)
cairo_pattern_t *pattern,
#else
GdkPixmap *pixmap,
#endif
StickyNotesApplet *applet)
{
#if !GTK_CHECK_VERSION (3, 0, 0)
/* Taken from TrashApplet */
GtkRcStyle *rc_style;
GtkStyle *style;
if (!applet) g_print ("arrg, no applet!\n");
/* reset style */
gtk_widget_set_style (GTK_WIDGET (applet->w_applet), NULL);
rc_style = gtk_rc_style_new ();
gtk_widget_modify_style (GTK_WIDGET (applet->w_applet), rc_style);
g_object_unref (rc_style);
switch (type)
{
case PANEL_NO_BACKGROUND:
break;
case PANEL_COLOR_BACKGROUND:
gtk_widget_modify_bg (GTK_WIDGET (applet->w_applet),
GTK_STATE_NORMAL, color);
break;
case PANEL_PIXMAP_BACKGROUND:
style = gtk_style_copy (
gtk_widget_get_style (GTK_WIDGET (applet->w_applet)));
if (style->bg_pixmap[GTK_STATE_NORMAL])
g_object_unref (
style->bg_pixmap[GTK_STATE_NORMAL]);
style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref (
pixmap);
gtk_widget_set_style (
GTK_WIDGET (applet->w_applet), style);
g_object_unref (style);
break;
}
#endif
}
Gobby::CloseButton::CloseButton()
{
set_relief(Gtk::RELIEF_NONE);
set_focus_on_click(false);
//set_flags(get_flags() & ~Gtk::CAN_FOCUS);
GtkRcStyle* rc_style = gtk_rc_style_new();
rc_style->xthickness = 0;
rc_style->ythickness = 0;
gtk_widget_modify_style(GTK_WIDGET(gobj()), rc_style);
g_object_unref(rc_style);
Gtk::Image* button_image = Gtk::manage(
new Gtk::Image(Gtk::Stock::CLOSE, Gtk::ICON_SIZE_MENU));
add(*button_image);
button_image->show();
}
void calendar_select_font (GtkWidget *button,
CalendarData *calendar)
{
const char *font = NULL;
GtkRcStyle *style;
if (calendar->window)
font = gtk_font_button_get_font_name (GTK_FONT_BUTTON (button));
if (font)
{
style = gtk_rc_style_new ();
pango_font_description_free (style->font_desc);
style->font_desc = pango_font_description_from_string (font);
gtk_widget_modify_style (calendar->window, style);
}
}
static void
gedit_close_button_init (GeditCloseButton *button)
{
GtkRcStyle *rcstyle;
GtkWidget *image;
/* make it as small as possible */
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style (GTK_WIDGET (button), rcstyle);
g_object_unref (rcstyle);
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (button), image);
}
static void applet_change_background(MatePanelApplet* applet, MatePanelAppletBackgroundType type, GdkColor* color, cairo_pattern_t *pattern, PagerData* pager)
{
GtkStyleContext *new_context;
gtk_widget_reset_style (GTK_WIDGET (pager->pager));
new_context = gtk_style_context_new ();
gtk_style_context_set_path (new_context, gtk_widget_get_path (GTK_WIDGET (pager->pager)));
g_object_unref (new_context);
wnck_pager_set_shadow_type (WNCK_PAGER (pager->pager),
type == PANEL_NO_BACKGROUND ? GTK_SHADOW_NONE : GTK_SHADOW_IN);
#else
static void applet_change_background(MatePanelApplet* applet, MatePanelAppletBackgroundType type, GdkColor* color, GdkPixmap* pixmap, PagerData* pager)
{
/* taken from the TrashApplet */
GtkRcStyle *rc_style;
GtkStyle *style;
/* reset style */
gtk_widget_set_style (GTK_WIDGET (pager->pager), NULL);
rc_style = gtk_rc_style_new ();
gtk_widget_modify_style (GTK_WIDGET (pager->pager), rc_style);
g_object_unref (rc_style);
switch (type)
{
case PANEL_COLOR_BACKGROUND:
gtk_widget_modify_bg (GTK_WIDGET (pager->pager), GTK_STATE_NORMAL, color);
break;
case PANEL_PIXMAP_BACKGROUND:
style = gtk_style_copy (gtk_widget_get_style (GTK_WIDGET (pager->pager)));
if (style->bg_pixmap[GTK_STATE_NORMAL])
g_object_unref (style->bg_pixmap[GTK_STATE_NORMAL]);
style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap);
gtk_widget_set_style (GTK_WIDGET (pager->pager), style);
g_object_unref (style);
break;
case PANEL_NO_BACKGROUND:
default:
break;
}
#endif
}
static void set_bg(GtkWidget * widget, gpointer data)
{
GtkRcStyle *rc_style;
rc_style = gtk_rc_style_new ();
rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_BASE;
#if 1
rc_style->base[GTK_STATE_NORMAL].red = widget->style->bg[GTK_STATE_NORMAL].red;
rc_style->base[GTK_STATE_NORMAL].green = widget->style->bg[GTK_STATE_NORMAL].green;
rc_style->base[GTK_STATE_NORMAL].blue = widget->style->bg[GTK_STATE_NORMAL].blue;
rc_style->base[GTK_STATE_NORMAL].pixel = widget->style->bg[GTK_STATE_NORMAL].pixel;
#endif
gtk_widget_modify_style(widget, rc_style);
#if GTK_MINOR_VERSION >= 12
g_object_unref (rc_style);
#else
gtk_rc_style_unref (rc_style);
#endif
}
void set_widget_thickness(GtkWidget *widget, gint thickness)
{
#ifdef DETAIL
g_debug("! Launch set_widget_thickness() with widget = %p, thickness = %d!", widget, thickness);
#endif
#ifdef DEFENSIVE
if (widget==NULL) return;
#endif
GtkRcStyle *rc_style = gtk_rc_style_new();
#ifdef DEFENSIVE
if (rc_style)
{
#endif
rc_style->xthickness = rc_style->ythickness = thickness;
gtk_widget_modify_style(widget, rc_style);
#ifdef DEFENSIVE
}
#endif
g_object_unref(rc_style);
}
void set_widget_thickness(GtkWidget *widget, gint thickness)
{
#ifdef DETAIL
g_debug("! Launch set_widget_thickness() with widget = %p, thickness = %d!", widget, thickness);
#endif
#ifdef SAFEMODE
if (widget==NULL) return;
#endif
#ifdef USING_OLD_GTK_RC_STYLE_NEW
GtkRcStyle *rc_style = gtk_rc_style_new();
# ifdef SAFEMODE
if (rc_style)
{
# endif
rc_style->xthickness = rc_style->ythickness = thickness;
gtk_widget_modify_style(widget, rc_style);
# ifdef SAFEMODE
}
# endif
g_object_unref(rc_style);
#else
GtkCssProvider *css = gtk_css_provider_new ();
GtkStyleContext *context = gtk_widget_get_style_context(widget);
gchar *modified_style = g_strdup_printf("* {\n"
" -GtkWidget-focus-line-width: 0;\n"
" -GtkWidget-focus-padding: 0;\n"
" padding: %dpx;\n"
"}",
thickness);
if (gtk_css_provider_load_from_data (css, modified_style, -1, NULL))
gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (css);
g_free (modified_style);
#endif
}
static void accessx_status_applet_background(MatePanelApplet* a, MatePanelAppletBackgroundType type, GdkColor* color, GdkPixmap* pixmap, gpointer user_data)
{
AccessxStatusApplet* sapplet = user_data;
GtkRcStyle* rc_style;
GtkStyle* style;
/* reset style */
gtk_widget_set_style(GTK_WIDGET(sapplet->applet), NULL);
rc_style = gtk_rc_style_new();
gtk_widget_modify_style(GTK_WIDGET(sapplet->applet), rc_style);
g_object_unref(rc_style);
switch (type)
{
case PANEL_COLOR_BACKGROUND:
gtk_widget_modify_bg(GTK_WIDGET(sapplet->applet), GTK_STATE_NORMAL, color);
break;
case PANEL_PIXMAP_BACKGROUND:
style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(sapplet->applet)));
if (style->bg_pixmap[GTK_STATE_NORMAL])
{
g_object_unref(style->bg_pixmap[GTK_STATE_NORMAL]);
}
style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap);
gtk_widget_set_style(GTK_WIDGET(sapplet->applet), style);
g_object_unref(style);
break;
case PANEL_NO_BACKGROUND:
default:
break;
}
}
GtkWindow* create_notification(UrlClickedCb url_clicked)
{
GtkWidget* win;
GtkWidget* main_vbox;
GtkWidget* vbox;
GtkWidget* close_button;
GtkWidget* image;
GtkWidget* alignment;
AtkObject* atkobj;
GtkRcStyle* rcstyle;
WindowData* windata;
#ifdef USE_COMPOSITE
GdkColormap* colormap;
GdkScreen* screen;
#endif
windata = g_new0(WindowData, 1);
windata->urgency = URGENCY_NORMAL;
windata->url_clicked = url_clicked;
win = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_resizable(GTK_WINDOW(win), FALSE);
gtk_widget_set_app_paintable(win, TRUE);
g_signal_connect(G_OBJECT(win), "style-set", G_CALLBACK(on_style_set), windata);
g_signal_connect(G_OBJECT(win), "map-event", G_CALLBACK(on_window_map), windata);
g_signal_connect(G_OBJECT(win), "expose-event", G_CALLBACK(on_window_expose), windata);
g_signal_connect(G_OBJECT(win), "realize", G_CALLBACK(on_window_realize), windata);
windata->win = win;
windata->composited = FALSE;
#ifdef USE_COMPOSITE
screen = gtk_window_get_screen(GTK_WINDOW(win));
colormap = gdk_screen_get_rgba_colormap(screen);
if (colormap != NULL)
{
gtk_widget_set_colormap(win, colormap);
if (gdk_screen_is_composited(screen))
{
windata->composited = TRUE;
}
}
g_signal_connect(win, "composited-changed", G_CALLBACK(on_composited_changed), windata);
#endif
gtk_window_set_title(GTK_WINDOW(win), "Notification");
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify) destroy_windata);
atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT);
g_signal_connect(G_OBJECT(win), "configure-event", G_CALLBACK(on_configure_event), windata);
main_vbox = gtk_vbox_new(FALSE, 0);
g_signal_connect(G_OBJECT(main_vbox), "style-set", G_CALLBACK(on_style_set), windata);
gtk_widget_show(main_vbox);
gtk_container_add(GTK_CONTAINER(win), main_vbox);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 12);
windata->main_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(windata->main_hbox);
gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox, FALSE, FALSE, 0);
/* First row (icon, vbox, close) */
windata->iconbox = gtk_alignment_new(0.5, 0, 0, 0);
gtk_widget_show(windata->iconbox);
gtk_alignment_set_padding(GTK_ALIGNMENT(windata->iconbox), 5, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), windata->iconbox, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1);
windata->icon = gtk_image_new();
gtk_widget_show(windata->icon);
gtk_container_add(GTK_CONTAINER(windata->iconbox), windata->icon);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
/* Add the close button */
alignment = gtk_alignment_new(0.5, 0, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), alignment, FALSE, FALSE, 0);
close_button = gtk_button_new();
g_signal_connect(G_OBJECT(close_button), "style-set", G_CALLBACK(on_style_set), windata);
gtk_widget_show(close_button);
windata->close_button = close_button;
gtk_container_add(GTK_CONTAINER(alignment), close_button);
gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_container_set_border_width(GTK_CONTAINER(close_button), 0);
g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(gtk_widget_destroy), win);
rcstyle = gtk_rc_style_new();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style(close_button, rcstyle);
g_object_unref(rcstyle);
atkobj = gtk_widget_get_accessible(close_button);
atk_action_set_description(ATK_ACTION(atkobj), 0, "Closes the notification.");
atk_object_set_name(atkobj, "");
atk_object_set_description(atkobj, "Closes the notification.");
image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(close_button), image);
/* center vbox */
windata->summary_label = gtk_label_new(NULL);
g_signal_connect(G_OBJECT(windata->summary_label), "style-set", G_CALLBACK(on_style_set), windata);
gtk_widget_show(windata->summary_label);
gtk_box_pack_start(GTK_BOX(vbox), windata->summary_label, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0, 0);
gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE);
atkobj = gtk_widget_get_accessible(windata->summary_label);
atk_object_set_description(atkobj, "Notification summary text.");
windata->content_hbox = gtk_hbox_new(FALSE, 6);
gtk_widget_show(windata->content_hbox);
gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0);
windata->body_label = gtk_label_new(NULL);
g_signal_connect(G_OBJECT(windata->body_label), "style-set", G_CALLBACK(on_style_set), windata);
gtk_widget_show(windata->body_label);
gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0, 0);
gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE);
g_signal_connect_swapped(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(windata->url_clicked), win);
atkobj = gtk_widget_get_accessible(windata->body_label);
atk_object_set_description(atkobj, "Notification body text.");
alignment = gtk_alignment_new(1, 0.5, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);
windata->actions_box = gtk_hbox_new(FALSE, 6);
gtk_widget_show(windata->actions_box);
gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box);
return GTK_WINDOW(win);
}
GtkWidget * create_layer_view_widget (void)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *hide_button;
GtkRcStyle *rcstyle; /* For hide_button */
GtkWidget *image; /* For hide_button */
GtkWidget *list;
GtkWidget *separator;
GtkWidget *scrolled_win;
GtkWidget *button_box;
/* if layer_dialog were renamed to layer_view_data this would make
* more sense.
*/
layer_dialog = g_new (struct LayerDialog, 1);
layer_dialog->diagram = NULL;
layer_dialog->dialog = vbox = gtk_vbox_new (FALSE, 1);
hbox = gtk_hbox_new (FALSE, 1);
label = gtk_label_new (_ ("Layers:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_widget_show (label);
layer_dialog->diagram_omenu = NULL;
/* Hide Button */
hide_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (hide_button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (hide_button), FALSE);
/* make it as small as possible */
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style (hide_button, rcstyle);
g_object_unref (rcstyle);
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER(hide_button), image);
g_signal_connect (G_OBJECT (hide_button), "clicked",
G_CALLBACK (layer_view_hide_button_clicked), NULL);
gtk_box_pack_start (GTK_BOX (hbox), hide_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
gtk_widget_show_all (hbox);
button_box = create_button_box(vbox, FALSE);
gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 2);
gtk_widget_show (button_box);
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 2);
gtk_widget_show (separator);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 2);
layer_dialog->layer_list = list = gtk_list_new();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (list),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win)));
gtk_widget_show (scrolled_win);
gtk_widget_show (list);
g_signal_connect (G_OBJECT (list), "event",
G_CALLBACK (layer_list_events), NULL);
return vbox;
}
/**
* \internal
*/
static GtkWidget *
gebr_gui_program_edit_load(GebrGuiProgramEdit *program_edit, GebrGeoXmlParameters * parameters)
{
GtkWidget *frame;
GtkWidget *vbox;
GebrGeoXmlSequence *parameter;
GebrGeoXmlParameterGroup *parameter_group;
GSList *radio_group;
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(frame);
parameter_group = gebr_geoxml_parameters_get_group(parameters);
if (parameter_group != NULL) {
GtkWidget *hbox;
GtkWidget *button;
GtkRcStyle *style;
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT);
hbox = gtk_hbox_new(FALSE, 0);
if (gebr_geoxml_parameter_group_get_is_instanciable(parameter_group)) {
button = gtk_button_new();
style = gtk_rc_style_new();
style->xthickness = style->ythickness = 0;
gtk_widget_modify_style(button, style);
g_object_unref(style);
g_object_set(button, "relief", GTK_RELIEF_NONE, NULL);
g_object_set_data(G_OBJECT(button), "frame", frame);
gtk_container_add(GTK_CONTAINER(button),
gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU));
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0);
g_signal_connect(button, "clicked", G_CALLBACK(on_delete_clicked), parameter_group);
g_object_set_data(G_OBJECT(frame), "delete", button);
}
if (program_edit->mpi_params) {
button = gtk_button_new();
style = gtk_rc_style_new();
style->xthickness = style->ythickness = 0;
gtk_widget_modify_style(button, style);
g_object_unref(style);
g_object_set(button, "relief", GTK_RELIEF_NONE, NULL);
gtk_container_add(GTK_CONTAINER(button), gtk_image_new_from_stock(GTK_STOCK_HELP, GTK_ICON_SIZE_MENU));
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0);
g_signal_connect(button, "clicked", G_CALLBACK(on_mpi_parameters_help_clicked), NULL);
}
button = gtk_button_new();
style = gtk_rc_style_new();
style->xthickness = style->ythickness = 0;
gtk_widget_modify_style(button, style);
g_object_unref(style);
g_object_set(button, "relief", GTK_RELIEF_NONE, NULL);
g_object_set_data(G_OBJECT(button), "frame", frame);
g_object_set_data(G_OBJECT(frame), "arrow-down", button);
g_signal_connect(button, "clicked", G_CALLBACK(on_arrow_down_clicked), parameter_group);
gtk_container_add(GTK_CONTAINER(button), gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE));
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0);
button = gtk_button_new();
style = gtk_rc_style_new();
style->xthickness = style->ythickness = 0;
gtk_widget_modify_style(button, style);
g_object_unref(style);
g_object_set(button, "relief", GTK_RELIEF_NONE, NULL);
g_object_set_data(G_OBJECT(button), "frame", frame);
g_object_set_data(G_OBJECT(frame), "arrow-up", button);
g_signal_connect(button, "clicked", G_CALLBACK(on_arrow_up_clicked), parameter_group);
gtk_container_add(GTK_CONTAINER(button), gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_NONE));
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
}
gtk_widget_show_all(vbox);
gtk_container_add(GTK_CONTAINER(frame), vbox);
GList *groups = NULL;
radio_group = NULL;
parameter = gebr_geoxml_parameters_get_first_parameter(parameters);
for (gboolean first_parameter = TRUE; parameter != NULL; gebr_geoxml_sequence_next(¶meter)) {
GtkWidget * widget;
widget = gebr_gui_program_edit_load_parameter(program_edit, GEBR_GEOXML_PARAMETER(parameter), &radio_group);
if (first_parameter) {
/* used in on_group_expander_mnemonic_activate */
g_object_set_data(G_OBJECT(frame), "first-parameter", parameter);
g_object_set_data(G_OBJECT(frame), "first-parameter-widget", widget);
first_parameter = FALSE;
}
if (gebr_geoxml_parameter_get_group(GEBR_GEOXML_PARAMETER(parameter))) {
gebr_geoxml_object_ref(parameter);
groups = g_list_prepend(groups, GEBR_GEOXML_PARAMETER(parameter));
}
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
}
for (GList *i = groups; i; i = i->next)
gebr_gui_group_validate(program_edit->validator,
i->data,
program_edit->group_warning_widget);
g_list_foreach(groups, (GFunc)gebr_geoxml_object_unref, NULL);
g_list_free(groups);
return frame;
}
static t_sload *
sload_new(void)
{
t_sload *sload;
GtkRcStyle *rc;
if (!tooltips) {
tooltips = gtk_tooltips_new();
}
sload = g_new(t_sload, 1);
sload->options.use_label = TRUE;
sload->options.label_text = g_strdup(DEFAULTTEXT);
gdk_color_parse(DEFAULTCOLOR, &sload->options.color);
sload->timeout_id = 0;
sload->cpu_history[0] = 0;
sload->cpu_history[1] = 0;
sload->cpu_history[2] = 0;
sload->cpu_history[3] = 0;
sload->ebox = gtk_event_box_new();
gtk_widget_show(sload->ebox);
sload->hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_widget_set_name(GTK_WIDGET(sload->hbox), "system_load");
gtk_container_set_border_width(GTK_CONTAINER(sload->hbox), border_width);
gtk_widget_show(GTK_WIDGET(sload->hbox));
sload->label = gtk_label_new(sload->options.label_text);
gtk_widget_show(sload->label);
gtk_box_pack_start(GTK_BOX(sload->hbox), GTK_WIDGET(sload->label),
FALSE, FALSE, 0);
sload->status = GTK_PROGRESS_BAR(gtk_progress_bar_new());
gtk_progress_bar_set_orientation(sload->status, GTK_PROGRESS_BOTTOM_TO_TOP);
rc = gtk_widget_get_modifier_style(GTK_WIDGET(sload->status));
if (!rc) {
rc = gtk_rc_style_new();
}
if (rc) {
rc->color_flags[GTK_STATE_PRELIGHT] |= GTK_RC_BG;
rc->bg[GTK_STATE_PRELIGHT] = sload->options.color;
}
gtk_widget_modify_style(GTK_WIDGET(sload->status), rc);
gtk_widget_show(GTK_WIDGET(sload->status));
gtk_box_pack_start(GTK_BOX(sload->hbox), GTK_WIDGET(sload->status),
FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(sload->ebox), GTK_WIDGET(sload->hbox));
return sload;
}
/**
* @param ddisp The diagram display object that a window is created for
* @param title
*/
static void
use_integrated_ui_for_display_shell(DDisplay *ddisp, char *title)
{
GtkWidget *table;
GtkWidget *label; /* Text label for the notebook page */
GtkWidget *tab_label_container; /* Container to hold text label & close button */
int width, height; /* Width/Heigth of the diagram */
GtkWidget *image;
GtkWidget *close_button; /* Close button for the notebook page */
GtkRcStyle *rcstyle;
gint notebook_page_index;
ddisp->is_standalone_window = FALSE;
ddisp->shell = GTK_WIDGET (ui.main_window);
ddisp->modified_status = GTK_WIDGET (ui.statusbar);
tab_label_container = gtk_hbox_new(FALSE,3);
label = gtk_label_new( title );
gtk_box_pack_start( GTK_BOX(tab_label_container), label, FALSE, FALSE, 0 );
gtk_widget_show (label);
/* Create a new tab page */
ddisp->container = gtk_vbox_new(FALSE, 0);
/* <from GEdit> */
/* don't allow focus on the close button */
close_button = gtk_button_new();
gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
/* make it as small as possible */
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style (close_button, rcstyle);
g_object_unref (rcstyle),
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER(close_button), image);
g_signal_connect (G_OBJECT (close_button), "clicked",
G_CALLBACK (close_notebook_page_callback), ddisp->container);
/* </from GEdit> */
gtk_box_pack_start( GTK_BOX(tab_label_container), close_button, FALSE, FALSE, 0 );
gtk_widget_show (close_button);
gtk_widget_show (image);
/* Set events for new tab page */
_ddisplay_setup_events (ddisp, ddisp->container);
notebook_page_index = gtk_notebook_append_page (GTK_NOTEBOOK(ui.diagram_notebook),
ddisp->container,
tab_label_container);
g_object_set_data (G_OBJECT (ddisp->container), "DDisplay", ddisp);
g_object_set_data (G_OBJECT (ddisp->container), "tab-label", label);
g_object_set_data (G_OBJECT (ddisp->container), "window", ui.main_window);
/* the table containing all widgets */
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
gtk_box_pack_start( GTK_BOX(ddisp->container), table, TRUE, TRUE, 0 );
/* scrollbars, rulers, canvas, menu popup button */
ddisp->origin = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT);
_ddisplay_setup_rulers (ddisp, ddisp->container, table);
/* Get the width/height of the Notebook child area */
/* TODO: Fix width/height hardcoded values */
width = 100;
height = 100;
_ddisplay_setup_scrollbars (ddisp, table, width, height);
_ddisplay_setup_navigation (ddisp, table);
ddisp->canvas = create_canvas (ddisp);
/* place all remaining widgets */
gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
ddisp->common_toolbar = ui.toolbar;
/* Stand-alone window menubar */
ddisp->menu_bar = NULL;
/* Stand-alone window Zoom status/menu */
ddisp->zoom_status = NULL;
/* Stand-alone window Grid on/off button */
ddisp->grid_status = NULL;
/* Stand-alone window Object Snapping button */
ddisp->mainpoint_status = NULL;
gtk_widget_show (ddisp->container);
gtk_widget_show (table);
display_rulers_show (ddisp);
gtk_widget_show (ddisp->canvas);
/* Show new page */
gtk_notebook_set_current_page (ui.diagram_notebook, notebook_page_index);
integrated_ui_toolbar_grid_snap_synchronize_to_display (ddisp);
integrated_ui_toolbar_object_snap_synchronize_to_display (ddisp);
/* set the focus to the canvas area */
gtk_widget_grab_focus (ddisp->canvas);
}
GtkWindow* create_notification(UrlClickedCb url_clicked)
{
GtkWidget* spacer;
GtkWidget* win;
GtkWidget* main_vbox;
GtkWidget* hbox;
GtkWidget* vbox;
GtkWidget* close_button;
GtkWidget* image;
GtkWidget* alignment;
AtkObject* atkobj;
#if !GTK_CHECK_VERSION(3, 0, 0)
GtkRcStyle* rcstyle;
#endif
WindowData* windata;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkVisual *visual;
#else
GdkColormap* colormap;
#endif
GdkScreen* screen;
windata = g_new0(WindowData, 1);
windata->urgency = URGENCY_NORMAL;
windata->url_clicked = url_clicked;
win = gtk_window_new(GTK_WINDOW_POPUP);
windata->win = win;
windata->composited = FALSE;
screen = gtk_window_get_screen(GTK_WINDOW(win));
#if GTK_CHECK_VERSION (3, 0, 0)
visual = gdk_screen_get_rgba_visual(screen);
if (visual != NULL)
{
gtk_widget_set_visual(win, visual);
if (gdk_screen_is_composited(screen))
{
windata->composited = TRUE;
}
}
#else
colormap = gdk_screen_get_rgba_colormap(screen);
if (colormap != NULL && gdk_screen_is_composited(screen))
{
gtk_widget_set_colormap(win, colormap);
windata->composited = TRUE;
}
#endif
gtk_window_set_title(GTK_WINDOW(win), "Notification");
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_realize(win);
gtk_widget_set_size_request(win, WIDTH, -1);
g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify) destroy_windata);
atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT);
g_signal_connect(G_OBJECT(win), "configure_event", G_CALLBACK(configure_event_cb), windata);
main_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(main_vbox);
gtk_container_add (GTK_CONTAINER (win), main_vbox);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 1);
#if GTK_CHECK_VERSION (3, 0, 0)
g_signal_connect (G_OBJECT (main_vbox), "draw", G_CALLBACK (on_draw), windata);
#else
g_signal_connect (G_OBJECT (main_vbox), "expose_event", G_CALLBACK (on_expose_event), windata);
#endif
windata->top_spacer = gtk_image_new();
gtk_box_pack_start(GTK_BOX(main_vbox), windata->top_spacer, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->top_spacer, -1, DEFAULT_ARROW_HEIGHT);
windata->main_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(windata->main_hbox);
gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox, FALSE, FALSE, 0);
windata->bottom_spacer = gtk_image_new();
gtk_box_pack_start(GTK_BOX(main_vbox), windata->bottom_spacer, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->bottom_spacer, -1, DEFAULT_ARROW_HEIGHT);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
hbox = gtk_hbox_new(FALSE, 6);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
spacer = gtk_image_new();
gtk_widget_show(spacer);
gtk_box_pack_start(GTK_BOX(hbox), spacer, FALSE, FALSE, 0);
gtk_widget_set_size_request(spacer, SPACER_LEFT, -1);
windata->summary_label = gtk_label_new(NULL);
gtk_widget_show(windata->summary_label);
gtk_box_pack_start(GTK_BOX(hbox), windata->summary_label, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION (3, 15, 2)
gtk_label_set_xalign (GTK_LABEL (windata->summary_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (windata->summary_label), 0.0);
#else
gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0, 0);
#endif
gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_label_set_line_wrap_mode (GTK_LABEL (windata->summary_label), PANGO_WRAP_WORD_CHAR);
#endif
atkobj = gtk_widget_get_accessible(windata->summary_label);
atk_object_set_description(atkobj, "Notification summary text.");
/* Add the close button */
alignment = gtk_alignment_new(1, 0, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(hbox), alignment, FALSE, FALSE, 0);
close_button = gtk_button_new();
windata->close_button = close_button;
gtk_widget_show(close_button);
gtk_container_add(GTK_CONTAINER(alignment), close_button);
gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_container_set_border_width(GTK_CONTAINER(close_button), 0);
//gtk_widget_set_size_request(close_button, 20, 20);
g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(gtk_widget_destroy), win);
#if !GTK_CHECK_VERSION(3, 0, 0)
rcstyle = gtk_rc_style_new();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style(close_button, rcstyle);
g_object_unref(rcstyle);
#endif
atkobj = gtk_widget_get_accessible(close_button);
atk_action_set_description(ATK_ACTION(atkobj), 0, "Closes the notification.");
atk_object_set_name(atkobj, "");
atk_object_set_description(atkobj, "Closes the notification.");
image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(close_button), image);
windata->content_hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0);
windata->iconbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(windata->iconbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), windata->iconbox, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1);
windata->icon = gtk_image_new();
gtk_box_pack_start(GTK_BOX(windata->iconbox), windata->icon, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->icon), 0.5, 0.0);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0);
windata->body_label = gtk_label_new(NULL);
gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION (3, 15, 2)
gtk_label_set_xalign (GTK_LABEL (windata->body_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (windata->body_label), 0.0);
#else
gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0, 0);
#endif
gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_label_set_line_wrap_mode (GTK_LABEL (windata->body_label), PANGO_WRAP_WORD_CHAR);
#endif
g_signal_connect(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(activate_link), windata);
atkobj = gtk_widget_get_accessible(windata->body_label);
atk_object_set_description(atkobj, "Notification body text.");
alignment = gtk_alignment_new(1, 0.5, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);
windata->actions_box = gtk_hbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box);
return GTK_WINDOW(win);
}
static void configuration_received_callback(bool_t res)
{
char labels[1024];
char values[1024];
int i,nb_values=0;
gdk_threads_enter();
PRINT("%s %s\n",__FILE__,__FUNCTION__);
GtkRcStyle *rc_style1,*rc_style2;
GdkColor color1,white;
color1.red=40000;
color1.blue=40000;
color1.green=65535;
color1.pixel=0;
rc_style1=gtk_rc_style_new();
// rc_style1->bg[GTK_STATE_NORMAL]=color1;
rc_style1->base[GTK_STATE_NORMAL]=color1;
// rc_style1->color_flags[GTK_STATE_NORMAL]|=GTK_RC_BG;
rc_style1->color_flags[GTK_STATE_NORMAL]|=GTK_RC_BASE;
white.red=0xffff;
white.blue=0xffff;
white.green=0xffff;
white.pixel=0;
rc_style2=gtk_rc_style_new();
//rc_style2->bg[GTK_STATE_NORMAL]=color2;
rc_style2->base[GTK_STATE_NORMAL]=white;
//rc_style2->color_flags[GTK_STATE_NORMAL]|=GTK_RC_BG;
rc_style2->color_flags[GTK_STATE_NORMAL]|=GTK_RC_BASE;
if (!GTK_IS_WIDGET(ihm_config.config_values_frame)) //{ gtk_widget_destroy(ihm_config.config_values_frame); ihm_config.config_values_frame = NULL; }
{
if (ihm_config.config_values!=NULL){ vp_os_free(ihm_config.config_values); ihm_config.config_values = NULL; }
ihm_config.config_values_frame = gtk_scrolled_window_new(NULL,NULL);
gtk_box_pack_start(GTK_BOX(ihm_config.config_frame_vbox),ihm_config.config_values_frame,TRUE, TRUE, 0);
ihm_config.config_values_hbox = gtk_hbox_new(FALSE,0);
ihm_config.config_values_vbox1 = gtk_vbox_new(FALSE,0);
ihm_config.config_values_vbox2 = gtk_vbox_new(FALSE,0);
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW (ihm_config.config_values_frame),ihm_config.config_values_hbox);
gtk_box_pack_start(GTK_BOX(ihm_config.config_values_hbox),ihm_config.config_values_vbox1,TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(ihm_config.config_values_hbox),ihm_config.config_values_vbox2,TRUE, TRUE, 0);
#define DISPLAY(KEY,NAME,C_TYPE,RW)\
ihm_config.config_values = vp_os_realloc(ihm_config.config_values,(nb_values+1)*sizeof(ihm_config_value_t)); \
sprintf(labels,"%s:%s",KEY,CFG_STRINGIFY(NAME)); \
ihm_config.config_values[nb_values].label = gtk_label_new(labels); \
ihm_config.config_values[nb_values].value = gtk_entry_new(); \
ihm_config.config_values[nb_values].hbox = gtk_hbox_new(FALSE,0); \
if ((RW)&K_WRITE) ihm_config.config_values[nb_values].send_button = gtk_button_new_with_label("send"); else ihm_config.config_values[nb_values].send_button=NULL; \
gtk_box_pack_start(GTK_BOX(ihm_config.config_values_vbox1),ihm_config.config_values[nb_values].label,FALSE, FALSE, ((RW)&K_WRITE)?6:5);\
gtk_box_pack_start(GTK_BOX(ihm_config.config_values_vbox2),ihm_config.config_values[nb_values].hbox,FALSE, FALSE, 0);\
gtk_box_pack_start(GTK_BOX(ihm_config.config_values[nb_values].hbox),ihm_config.config_values[nb_values].value,TRUE, TRUE, 0);\
gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[nb_values].value),rc_style2); \
if (ihm_config.config_values[nb_values].send_button)\
{gtk_box_pack_start(GTK_BOX(ihm_config.config_values[nb_values].hbox),ihm_config.config_values[nb_values].send_button,FALSE, FALSE, 0);\
gtk_signal_connect(GTK_OBJECT(ihm_config.config_values[nb_values].send_button), "clicked", G_CALLBACK(set_configuration_callback), NULL);}\
nb_values++;
#undef ARDRONE_CONFIG_KEY_IMM
#undef ARDRONE_CONFIG_KEY_REF
#undef ARDRONE_CONFIG_KEY_STR
#define ARDRONE_CONFIG_KEY_IMM(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) DISPLAY(KEY,NAME,C_TYPE,RW)
#define ARDRONE_CONFIG_KEY_REF(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) DISPLAY(KEY,NAME,C_TYPE,RW)
#define ARDRONE_CONFIG_KEY_STR(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) DISPLAY(KEY,NAME,C_TYPE,RW)
#include <config_keys.h>
}
//sprintf(labels,"%s:%s",STRINGIFY(abc),STRINGIFY(def));
// sprintf(values,PRINTF_KEY(C_TYPE)),get_##NAME());
//gtk_entry_set_text( GTK_ENTRY(ihm_config.config_values[nb_values].value) , values );
//sprintf(values,PRINTF_KEY(uint32_t),123);
i=0;
#define CONFIGURATION_GETTER(x) ardrone_control_config.x
#define ARDRONE_CONFIG_KEY_IMM(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) \
if(strcmp("" #INI_TYPE, "INI_FLOAT") == 0) { sprintf( values,"%f",(float)CONFIGURATION_GETTER(NAME)); } \
else if(strcmp("" #INI_TYPE, "INI_INT") == 0) { sprintf( values,"%d",(int)CONFIGURATION_GETTER(NAME)); } \
else if(strcmp("" #INI_TYPE, "INI_BOOLEAN") == 0) { sprintf( values,"%s",(CONFIGURATION_GETTER(NAME)) ? "TRUE" : "FALSE"); } \
if (strcmp(gtk_entry_get_text(GTK_ENTRY(ihm_config.config_values[i].value)),values)!=0) \
gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[i].value),rc_style1); \
else gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[i].value),rc_style2); \
gtk_entry_set_text( GTK_ENTRY(ihm_config.config_values[i].value) , values );\
i++;
//PRINT(" Received parameter <%s:%s> with value <%f>\n",#KEY,#NAME,(float)CONFIGURATION_GETTER(NAME) );
#define ARDRONE_CONFIG_KEY_REF(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) \
i++;
#define ARDRONE_CONFIG_KEY_STR(KEY, NAME, INI_TYPE, C_TYPE, C_TYPE_PTR, RW, DEFAULT, CALLBACK) \
if (strcmp(gtk_entry_get_text(GTK_ENTRY(ihm_config.config_values[i].value)),CONFIGURATION_GETTER(NAME))!=0) \
gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[i].value),rc_style1); \
else gtk_widget_modify_style(GTK_WIDGET(ihm_config.config_values[i].value),rc_style2); \
gtk_entry_set_text( GTK_ENTRY(ihm_config.config_values[i].value) , CONFIGURATION_GETTER(NAME) ); i++;
#include <config_keys.h>
ihm_config.nb_config_values = i;
gtk_widget_show_all(ihm_config.window);
gtk_rc_style_unref(rc_style1);
gtk_rc_style_unref(rc_style2);
gdk_threads_leave();
}
