GtkWidget *
do_css_accordion (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *container, *child;
GtkStyleProvider *provider;
GBytes *bytes;
gsize data_size;
const guint8 *data;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 600, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_halign (container, GTK_ALIGN_CENTER);
gtk_widget_set_valign (container, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (window), container);
child = gtk_button_new_with_label ("This");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("Is");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("A");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("CSS");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("Accordion");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label (":-)");
gtk_container_add (GTK_CONTAINER (container), child);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
bytes = g_resources_lookup_data ("/css_accordion/css_accordion.css", 0, NULL);
data = g_bytes_get_data (bytes, &data_size);
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider), (gchar *)data, data_size, NULL);
g_bytes_unref (bytes);
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
static void context_apply_config(GtkWidget *console)
{
#if !GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_modify_base(console, GTK_STATE_NORMAL, &pref_vte_colour_back);
gtk_widget_modify_cursor(console, &pref_vte_colour_fore, &pref_vte_colour_back);
#else
GString *css_string;
GtkStyleContext *context;
GtkCssProvider *provider;
gchar *css_code, *color, *background_color;
color = gdk_rgba_to_string (&pref_vte_colour_fore);
background_color = gdk_rgba_to_string (&pref_vte_colour_back);
gtk_widget_set_name(console, "scope-console");
context = gtk_widget_get_style_context(console);
provider = gtk_css_provider_new();
gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
css_string = g_string_new(NULL);
g_string_printf(css_string, "#scope-console { color: %s; background-color: %s; }",
color, background_color);
css_code = g_string_free(css_string, FALSE);
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider), css_code, -1, NULL);
g_free(css_code);
g_object_unref(provider);
#endif
ui_widget_modify_font_from_string(console, pref_vte_font);
}
int main(int argc, char ** argv)
{
/* Init GTK+ */
gtk_init( &argc, &argv );
builder = gtk_builder_new();
MainWindow* window = new MainWindow(GTK_BUILDER(builder));
gtk_builder_connect_signals( GTK_BUILDER(builder), window );
/* ============== CSS ============== */
GtkCssProvider *provider;
GdkDisplay *display;
GdkScreen *screen;
provider = gtk_css_provider_new ();
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
gtk_style_context_add_provider_for_screen (screen,
GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
gtk_css_provider_load_from_path(GTK_CSS_PROVIDER(provider), "style.css", NULL);
g_object_unref (provider);
/* ============== /// ============== */
/* Start main loop */
gtk_main();
return 0;
}
CalendarDatePrivate::CalendarDatePrivate()
: m_viewType(VIEWTYPE_DAY)
, m_focusUnit(-1)
, m_yearBefore(1)
, m_weekStart(0)
, m_isShowWeekNum(FALSE) {
time_t tmp_time;
time_t secs;
struct tm * tm;
char buffer[255];
int i = 0;
for (i = 0; i < 7; ++i) {
tmp_time = (i + 3) * SEC_IN_A_DAY;
strftime(buffer, sizeof(buffer), "%a", localtime(&tmp_time));
m_defaultAbbreviatedDayname[i] = g_locale_to_utf8(buffer, -1, NULL, NULL, NULL);
}
for (i = 0; i < 12; ++i) {
tmp_time = i * 32 * SEC_IN_A_DAY;
strftime(buffer, sizeof(buffer), "%B", localtime(&tmp_time));
m_defaultMonthname[i] = g_locale_to_utf8(buffer, -1, NULL, NULL, NULL);
}
secs = time(NULL);
tm = localtime(&secs);
m_selectedYear = tm->tm_year + 1900;
m_selectedMonth = tm->tm_mon + 1;
m_selectedDayOfMonth = tm->tm_mday;
ComputeDays();
m_actor = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_name(m_actor, "calendar");
m_topBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_name(m_topBox, "calendar-top");
gtk_widget_set_halign(GTK_WIDGET(m_topBox), GTK_ALIGN_CENTER);
m_mainBox = gtk_fixed_new();
gtk_widget_set_halign(GTK_WIDGET(m_mainBox), GTK_ALIGN_CENTER);
m_swipeBox[VIEWTYPE_DAY] = NULL;
m_swipeBox[VIEWTYPE_MONTH] = NULL;
m_swipeBox[VIEWTYPE_YEAR] = NULL;
gtk_box_pack_start(GTK_BOX(m_actor), GTK_WIDGET(m_topBox), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(m_actor), GTK_WIDGET(m_mainBox), TRUE, TRUE, 0);
m_provider = GTK_STYLE_PROVIDER(gtk_css_provider_new());
gtk_css_provider_load_from_path(GTK_CSS_PROVIDER(m_provider), GLOBAL_RESOURCE_DIR"/testCalendar/testCalendar.css", NULL);
buildHeader();
updateDayView(FALSE, 0);
}
void cc_set_css(GtkWidget*w,gchar*file)
{
GFile *cssfile=g_file_new_for_path(file);
GtkCssProvider*provider=gtk_css_provider_new();
GtkStyleContext*context=gtk_widget_get_style_context(w);
gtk_style_context_add_provider(context,GTK_STYLE_PROVIDER(provider),GTK_STYLE_PROVIDER_PRIORITY_USER);
gtk_css_provider_load_from_file(GTK_CSS_PROVIDER(provider),cssfile,NULL);
g_object_unref(provider);
}
static void set_button_text_color(GtkWidget *widget,char *color) {
GtkStyleContext *style_context;
GtkCssProvider *provider = gtk_css_provider_new ();
gchar tmp[64];
style_context = gtk_widget_get_style_context(widget);
gtk_style_context_add_provider(style_context, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_snprintf(tmp, sizeof tmp, "GtkButton, GtkLabel { color: %s; }", color);
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider), tmp, -1, NULL);
g_object_unref (provider);
}
void theme_init(){
char *theme_file;
theme_file = get_theme_file("default.css");
if (!theme_file){
return;
}
provider = GTK_STYLE_PROVIDER(gtk_css_provider_new());
gtk_css_provider_load_from_path(
GTK_CSS_PROVIDER(provider), theme_file, NULL);
g_free(theme_file);
}
/**************************************************************************
Updates a gui font style.
**************************************************************************/
void gui_update_font(const char *font_name, const char *font_value)
{
char *str;
GtkCssProvider *provider;
str = g_strdup_printf("#Freeciv #%s { font: %s;}", font_name, font_value);
provider = gtk_css_provider_new();
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider),
str, -1, NULL);
gtk_style_context_add_provider_for_screen(
gtk_widget_get_screen(toplevel), GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_free(str);
}
static void sc_button_set_style(GtkButton* button)
{
GtkCssProvider* provider;
GtkStyleContext*context;
provider=gtk_css_provider_new();
context=gtk_widget_get_style_context(GTK_WIDGET(button));
gtk_style_context_add_provider(context,GTK_STYLE_PROVIDER(provider),GTK_STYLE_PROVIDER_PRIORITY_USER);
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider),"GtkButton {border-radius:0px ;padding:0}",-1,NULL);
g_object_unref(provider);
}
void cc_style_setup()
{
GtkCssProvider* provider=gtk_css_provider_new();
GdkScreen*screen=gdk_display_get_default_screen(gdk_display_get_default());
GFile* cssfile=g_file_new_for_path(STYLE_PATH "image.css");
gtk_css_provider_load_from_file(GTK_CSS_PROVIDER(provider),cssfile,NULL);
gtk_style_context_add_provider_for_screen(screen,GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
g_object_unref(provider);
}
static void style_window(GtkWidget *window, wconf_t conf)
{
GdkDisplay *display;
GdkScreen *screen;
GtkCssProvider *provider;
GFile *file;
GError *err;
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window),
SEARCH_WIDTH,
SEARCH_HEIGHT);
gtk_window_set_title(GTK_WINDOW(window), "Morun");
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
char path[256];
if (conf.style == NULL)
snprintf(path, sizeof(path), "%s/.morun.css", getenv("HOME"));
else
snprintf(path, sizeof(path), "%s", conf.style);
file = g_file_new_for_path(path);
provider = gtk_css_provider_new();
display = gdk_display_get_default();
screen = gdk_display_get_default_screen(display);
err = NULL;
gtk_style_context_add_provider_for_screen(screen,
GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
gtk_css_provider_load_from_file(GTK_CSS_PROVIDER(provider), file, &err);
if (err != NULL) {
printf("Error occurred while loading style:\n%s\n", err->message);
exit(1);
}
g_object_unref(provider);
}
static void
setup_am_pm_button (CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv = self->priv;
GtkCssProvider *provider;
GtkStyleContext *context;
GtkWidget *am_pm_button;
char *text;
text = format_am_label ();
priv->am_label = gtk_label_new (text);
g_free (text);
text = format_pm_label ();
priv->pm_label = gtk_label_new (text);
g_free (text);
priv->am_pm_stack = W ("am_pm_stack");
gtk_container_add (GTK_CONTAINER (priv->am_pm_stack), priv->am_label);
gtk_container_add (GTK_CONTAINER (priv->am_pm_stack), priv->pm_label);
gtk_widget_show_all (priv->am_pm_stack);
priv->am_pm_visiblity_changed_id = g_signal_connect_swapped (priv->am_pm_stack,
"notify::visible-child",
G_CALLBACK (am_pm_stack_visible_child_changed_cb),
self);
am_pm_stack_visible_child_changed_cb (self);
am_pm_button = W ("am_pm_button");
g_signal_connect (am_pm_button, "clicked",
G_CALLBACK (am_pm_button_clicked), self);
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider),
".gnome-control-center-ampm-toggle-button {\n"
" font-size: 150%;\n"
"}", -1, NULL);
context = gtk_widget_get_style_context (am_pm_button);
gtk_style_context_add_provider (context,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
}
static GtkStyleProvider *
add_extra_css (const char *testname,
const char *extension)
{
GtkStyleProvider *provider = NULL;
char *css_file;
css_file = get_test_file (testname, extension, TRUE);
if (css_file == NULL)
return NULL;
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
gtk_css_provider_load_from_path (GTK_CSS_PROVIDER (provider),
css_file,
NULL);
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
provider,
GTK_STYLE_PROVIDER_PRIORITY_FORCE);
g_free (css_file);
return provider;
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *ebox;
GtkStyleContext *context;
GtkStyleProvider *provider;
gtk_init (&argc, &argv);
if (argc > 1)
what = argv[1];
else
what = "check";
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip (GTK_WINDOW (window), FALSE);
ebox = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (ebox), TRUE);
gtk_container_add (GTK_CONTAINER (window), ebox);
gtk_widget_set_name (ebox, "ebox");
context = gtk_widget_get_style_context (ebox);
provider = (GtkStyleProvider *)gtk_css_provider_new ();
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider),
".frame1 {\n"
" border-image: url('gradient1.png') 10 10 10 10 stretch;\n"
"}\n"
".frame2 {\n"
" border-style: solid;\n"
" border-color: rgb(255,0,0);\n"
" border-width: 10;\n"
" border-radius: 10;\n"
"}\n"
".frame3 {\n"
" border-style: solid;\n"
" border-color: rgb(0,0,0);\n"
" border-width: 2;\n"
" border-radius: 10;\n"
"}\n"
".background {\n"
" border-radius: 10;\n"
" border-width: 0;\n"
" background-image: -gtk-gradient (linear, left top, right bottom, from(#ff00ff), to(#aabbcc));\n"
"}\n"
".frame {\n"
" border-style: solid;\n"
" border-width: 1;\n"
" border-radius: 0;\n"
"}\n", -1, NULL);
gtk_style_context_add_provider (context, provider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_signal_connect_after (ebox, "draw", G_CALLBACK (draw_cb), NULL);
gtk_widget_show_all (window);
gtk_main ();
gtk_style_context_remove_provider (context, provider);
return 0;
}
static void
gdaui_bar_init (GdauiBar *bar)
{
GtkWidget *widget = GTK_WIDGET (bar);
GtkWidget *content_area;
GtkWidget *action_area;
bar->priv = g_new0 (GdauiBarPrivate, 1);
content_area = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (content_area);
gtk_box_pack_start (GTK_BOX (bar), content_area, TRUE, TRUE, 0);
action_area = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (action_area);
gtk_box_pack_start (GTK_BOX (bar), action_area, FALSE, TRUE, 0);
gtk_widget_set_app_paintable (widget, TRUE);
gtk_widget_set_redraw_on_allocate (widget, TRUE);
bar->priv->content_area = content_area;
bar->priv->action_area = action_area;
/* set default spacings */
gtk_box_set_spacing (GTK_BOX (bar->priv->action_area), ACTION_AREA_DEFAULT_SPACING);
gtk_container_set_border_width (GTK_CONTAINER (bar->priv->action_area), ACTION_AREA_DEFAULT_BORDER);
gtk_box_set_spacing (GTK_BOX (bar->priv->content_area), CONTENT_AREA_DEFAULT_SPACING);
gtk_container_set_border_width (GTK_CONTAINER (bar->priv->content_area), CONTENT_AREA_DEFAULT_BORDER);
bar->priv->show_icon = FALSE;
bar->priv->icon = gtk_image_new ();
gtk_misc_set_alignment (GTK_MISC (bar->priv->icon), 1., 0.5);
gtk_widget_hide (bar->priv->icon);
gtk_box_pack_end (GTK_BOX (bar->priv->content_area), bar->priv->icon,
FALSE, TRUE, 0);
bar->priv->label = gtk_label_new ("");
gtk_label_set_selectable (GTK_LABEL (bar->priv->label), FALSE);
gtk_misc_set_alignment (GTK_MISC (bar->priv->label), 0., 0.5);
gtk_box_pack_end (GTK_BOX (bar->priv->content_area), bar->priv->label,
TRUE, TRUE, 0);
gtk_widget_show (bar->priv->label);
/* CSS theming */
GtkStyleContext *context;
if (!css_provider) {
#define CSS ".gdauibar {\n" \
"background-color: #b3b3b3;\n" \
"padding: 5px;\n" \
"}" \
".gdauibar_button {\n" \
"-GtkButton-default-border : 0px;\n" \
"-GtkButton-default-outside-border : 0px;\n" \
"-GtkWidget-focus-line-width : 0px;\n" \
"-GtkWidget-focus-padding : 0px;\n" \
"padding: 0px;\n" \
"-GtkButtonBox-child-internal-pad-x : 1px;\n" \
"-GtkButtonBox-child-min-width : 0px;\n" \
"border-style: none;\n" \
"}" \
".gdauibar_entry {\n" \
"-GtkWidget-focus-line-width : 0px;\n" \
"-GtkWidget-focus-padding : 0px;\n" \
"padding: 1px;\n" \
"-GtkButtonBox-child-internal-pad-x : 1px;\n" \
"-GtkButtonBox-child-min-width : 0px;\n" \
"border-style: solid;\n" \
"border-radius: 5px;\n" \
"}"
css_provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (css_provider), CSS, -1, NULL);
}
context = gtk_widget_get_style_context (GTK_WIDGET (bar));
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar");
}
int main(int argc, char *argv[])
{
GtkBuilder *builder;
gtk_init(&argc, &argv);
builder = gtk_builder_new();
GError *error = NULL;
gtk_builder_add_from_file(builder, "src/ui/mainwindow.glade", &error);
if (error != NULL)
{
printf("Error loading user interface: %s", error->message);
g_error_free(error);
return 0;
}
sooshi_error_t sooshi_error = 0;
SooshiState *state = sooshi_state_new(&sooshi_error);
if (sooshi_error)
return -1;
AppState *s = g_new0(AppState, 1);
s->channel1_top = gtk_builder_get_object(builder, "channel1_top");
s->channel1 = gtk_builder_get_object(builder, "channel1");
s->channel1_bottom = gtk_builder_get_object(builder, "channel1_bottom");
s->channel2_top = gtk_builder_get_object(builder, "channel2_top");
s->channel2 = gtk_builder_get_object(builder, "channel2");
s->channel2_bottom = gtk_builder_get_object(builder, "channel2_bottom");
s->battery_level = gtk_builder_get_object(builder, "battery_level");
s->battery_level_str = gtk_builder_get_object(builder, "battery_level_str");
s->trigger = GTK_COMBO_BOX(gtk_builder_get_object(builder, "Trigger"));
s->sample_rate = GTK_COMBO_BOX(gtk_builder_get_object(builder, "Sample Rate"));
s->sample_depth = GTK_COMBO_BOX(gtk_builder_get_object(builder, "Sample Depth"));
s->sooshi = state;
GObject *window = gtk_builder_get_object(builder, "MainWindow");
g_signal_connect(window, "destroy", G_CALLBACK(app_shutdown), s);
/* Set up CSS style provider */
GtkCssProvider *provider = gtk_css_provider_new();
GdkDisplay *display = gdk_display_get_default();
GdkScreen *screen = gdk_display_get_default_screen(display);
gtk_style_context_add_provider_for_screen(screen,
GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
gtk_css_provider_load_from_path(GTK_CSS_PROVIDER(provider),
"src/ui/style.css", &error);
if (error != NULL)
{
printf("Error loading user interface style: %s", error->message);
g_error_free(error);
return 0;
}
g_object_unref(provider);
sooshi_setup(state,
mooshi_initialized, s,
mooshi_scan_timed_out, s
);
gtk_widget_show_all(GTK_WIDGET(window));
gtk_main();
sooshi_state_delete(state);
return 0;
}
static gboolean
nimf_candidate_start (NimfService *service)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
NimfCandidate *candidate = NIMF_CANDIDATE (service);
if (candidate->active)
return TRUE;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column[N_COLUMNS];
GtkListStore *store;
gint fixed_height = 32;
gint horizontal_space;
gtk_init (NULL, NULL);
/* gtk entry */
candidate->entry = gtk_entry_new ();
gtk_editable_set_editable (GTK_EDITABLE (candidate->entry), FALSE);
gtk_widget_set_no_show_all (candidate->entry, TRUE);
g_signal_connect_after (candidate->entry, "draw",
G_CALLBACK (on_entry_draw), NULL);
/* gtk tree view */
store = gtk_list_store_new (N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
candidate->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (candidate->treeview), FALSE);
gtk_widget_style_get (candidate->treeview, "horizontal-separator",
&horizontal_space, NULL);
candidate->cell_height = fixed_height + horizontal_space / 2;
gtk_widget_set_size_request (candidate->treeview,
(gint) (candidate->cell_height * 10 / 1.6),
candidate->cell_height * 10);
g_signal_connect (candidate->treeview, "row-activated",
(GCallback) on_tree_view_row_activated, candidate);
/* column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "height", fixed_height, "font", "Sans 14", NULL);
column[INDEX_COLUMN] = gtk_tree_view_column_new_with_attributes ("Index",
renderer, "text", INDEX_COLUMN, NULL);
column[MAIN_COLUMN] = gtk_tree_view_column_new_with_attributes ("Main",
renderer, "text", MAIN_COLUMN, NULL);
column[EXTRA_COLUMN] = gtk_tree_view_column_new_with_attributes ("Extra",
renderer, "text", EXTRA_COLUMN, NULL);
gtk_tree_view_column_set_sizing (column[INDEX_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sizing (column[MAIN_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sizing (column[EXTRA_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
column[INDEX_COLUMN]);
gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
column[MAIN_COLUMN]);
gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
column[EXTRA_COLUMN]);
/* scrollbar */
GtkAdjustment *adjustment = gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 1.0, 1.0);
candidate->scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment);
gtk_range_set_slider_size_fixed (GTK_RANGE (candidate->scrollbar), FALSE);
g_signal_connect (candidate->scrollbar, "change-value",
G_CALLBACK (on_range_change_value), candidate);
GtkCssProvider *provider;
GtkStyleContext *style_context;
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider),
".scrollbar {"
" -GtkScrollbar-has-backward-stepper: true;"
" -GtkScrollbar-has-forward-stepper: true;"
" -GtkScrollbar-has-secondary-forward-stepper: true;"
"}" , -1, NULL);
style_context = gtk_widget_get_style_context (candidate->scrollbar);
gtk_style_context_add_provider (style_context,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
/* gtk box */
GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), candidate->entry, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), candidate->treeview, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (hbox), candidate->scrollbar, FALSE, TRUE, 0);
/* gtk window */
candidate->window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_type_hint (GTK_WINDOW (candidate->window),
GDK_WINDOW_TYPE_HINT_POPUP_MENU);
gtk_container_set_border_width (GTK_CONTAINER (candidate->window), 1);
gtk_container_add (GTK_CONTAINER (candidate->window), vbox);
gtk_widget_realize (candidate->window);
candidate->active = TRUE;
return TRUE;
}
void start_GUI() {
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), "telerobot client");
gtk_window_set_icon_from_file(GTK_WINDOW(main_window), "icons/PlayStation_3_gamepad.svg", NULL);
/* gdk_window_set_icon_list(GTK_WINDOW(main_window), NULL); */
gtk_window_set_default_size(GTK_WINDOW(main_window), 973, 309); /* actually 1024, 254 */
gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER);
/* gtk_widget_show(main_window); */
left_table = gtk_table_new(6, 3, TRUE);
gtk_table_set_row_spacings(GTK_TABLE(left_table), 2);
gtk_table_set_col_spacings(GTK_TABLE(left_table), 2);
provider = gtk_css_provider_new();
/* gtk_css_provider_load_from_path(cssProvider,"./style.css", NULL); */
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider), "GtkProgressBar {\n"
"min-height: 30px;\n"
"}\n", -1, NULL);
display = gdk_display_get_default();
screen = gdk_display_get_default_screen(display);
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref(provider);
progress1 = gtk_progress_bar_new();
//gtk_progress_bar_set_inverted(progress1, TRUE);
/* this would invert progressbar direction */
gtk_progress_bar_set_text(progress1, "L2:");
gtk_progress_bar_set_show_text(progress1, TRUE);
/*g_object_set(progress1, "min-height", 30, NULL);*/
gtk_table_attach(GTK_TABLE(left_table), progress1, 0, 3, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress1), GTK_ALIGN_CENTER);
progress2 = gtk_progress_bar_new();
gtk_progress_bar_set_text(progress2, "R2:");
gtk_progress_bar_set_show_text(progress2, TRUE);
/*g_object_set(progress2, "min-height", 30, NULL);*/
gtk_table_attach(GTK_TABLE(left_table), progress2, 0, 3, 1, 2, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress2), GTK_ALIGN_CENTER);
progress3 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress3, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress3, 0, 3, 2, 3, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress3), GTK_ALIGN_CENTER);
progress4 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress4, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress4, 0, 3, 3, 4, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress4), GTK_ALIGN_CENTER);
progress5 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress5, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress5, 0, 3, 4, 5, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress5), GTK_ALIGN_CENTER);
/* feedback labels */
label_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
label_roll = gtk_label_new("roll (\u00B0)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_roll, FALSE, FALSE, 10);
label_pitch = gtk_label_new("pitch (\u00B0)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_pitch, FALSE, FALSE, 10);
label_alt = gtk_label_new("altitude (m)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_alt, FALSE, FALSE, 10);
gtk_table_attach(GTK_TABLE(left_table), label_box, 0, 3, 5, 6, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(label_box), GTK_ALIGN_CENTER);
left_frame = gtk_aspect_frame_new(NULL, /* label */
0.5, /* horizontal position */
0.0, /* vertical position */
1, /* xsize/ysize = 1 */
FALSE /* ignore child's aspect */);
drawing_area_frame = gtk_aspect_frame_new(NULL, 0.5, 0.0, 1, TRUE /* ignore child's aspect */);
gtk_frame_set_shadow_type(GTK_FRAME(drawing_area_frame), GTK_SHADOW_ETCHED_IN);
GtkWidget *text_area_frame;
text_area_frame = gtk_aspect_frame_new(NULL, 0.5, 0.0, 1, TRUE);
gtk_frame_set_shadow_type(GTK_FRAME(text_area_frame), GTK_SHADOW_ETCHED_IN);
drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(drawing_area, 320, 320);
gtk_container_add(GTK_CONTAINER(drawing_area_frame), drawing_area);
g_signal_connect(G_OBJECT(drawing_area), "draw", G_CALLBACK(on_draw_event), NULL);
g_signal_connect(main_window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_frame_set_shadow_type(GTK_FRAME(left_frame), GTK_SHADOW_ETCHED_IN);
/* draws a frame */
gtk_container_add(GTK_CONTAINER(left_frame), left_table);
/* places the widget inside frame */
main_table = gtk_table_new(1, 3, FALSE);
/* creates three column table */
gtk_table_attach_defaults(GTK_TABLE(main_table), left_frame, 0, 1, 0, 1);
/* places the widget inside leftmost cell of the table */
gtk_table_attach_defaults(GTK_TABLE(main_table), drawing_area_frame, 1, 2, 0, 1);
/* places the video/artificial horizon widget inside middle cell */
/* prawa komórka głównej tabeli */
// grid method
// right_table = gtk_grid_new();
// table method
right_table = gtk_table_new(3, 3, TRUE);
/* prawa ramka */
right_frame = gtk_aspect_frame_new(NULL, /* label */
0.5, /* wyrównanie w poziomie */
0.0, /* wyrównanie w pionie */
1, /* xsize/ysize = 1 */
FALSE /* ignore child's aspect */);
/* zamiast "0" może być NULL - wtedy pole jest puste */
label_x1 = gtk_label_new("");
label_y1 = gtk_label_new("");
label_x2 = gtk_label_new("");
label_y2 = gtk_label_new("");
/* 0 - pierwsza kolumna, 1 - druga kolumna następna (numerowane od zera) */
/* umieszcza wskaźniki w polach tabeli */
gtk_label_set_justify(label_x1, GTK_JUSTIFY_RIGHT);
gtk_label_set_justify(label_y1, GTK_JUSTIFY_RIGHT);
/* "0,2,Y,Y" oznacza że zajmują dwie komórki tabeli */
/* typ obwiedni */
gtk_frame_set_shadow_type(GTK_FRAME(right_frame), GTK_SHADOW_ETCHED_IN);
/* umieszcza right_table w wskazniki */
gtk_container_add(GTK_CONTAINER(right_frame), right_table);
gtk_table_attach_defaults(GTK_TABLE(main_table), right_frame, 2, 3, 0, 1);
/* umieszcza ramkę wskazniki w prawej (2,3) komórce głównej tabeli */
/* tworzy przycisk wyłączający serwer */
/*
GtkWidget *quit_icon;
GtkWidget *quit_button;
quit_icon = gtk_image_new_from_file("icons/system-shutdown.svg");
quit_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(quit_button), quit_icon);
g_signal_connect(quit_button, "pressed", G_CALLBACK(wyslij_przycisk_13_on), NULL);
g_signal_connect(quit_button, "released", G_CALLBACK(wyslij_przycisk_13_off), NULL);
gtk_button_set_relief(quit_button, GTK_RELIEF_NONE);
*/
/* Sets whether the button will grab focus when it is clicked with the mouse.
Making mouse clicks not grab focus is useful in places like toolbars
where you don't want the keyboard focus removed from the main area of the application. */
/* gtk_button_set_focus_on_click(quit_button, 0); */
/* regulator & servo controller buttons */
servocontroller_enable_button = gtk_button_new_with_label("enable\nUSC-16");
gtk_button_set_relief(servocontroller_enable_button, GTK_RELIEF_NONE);
gtk_table_attach_defaults(GTK_TABLE(right_table), servocontroller_enable_button, 0, 1, 2, 3);
servocontroller_disable_button = gtk_button_new_with_label("disable\nUSC-16");
gtk_button_set_relief(servocontroller_disable_button, GTK_RELIEF_NONE);
gtk_table_attach_defaults(GTK_TABLE(right_table), servocontroller_disable_button, 0, 1, 2, 3);
check_button_regulator = gtk_check_button_new_with_label("50 Hz");
gtk_toggle_button_set_active(check_button_regulator, FALSE);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_regulator, 1, 2, 2, 3);
/* record buttons */
record_start_icon = gtk_image_new_from_file("icons/media-record.svg");
record_start_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(record_start_button), record_start_icon);
gtk_table_attach_defaults(GTK_TABLE(right_table), record_start_button, 2, 3, 1, 2);
gtk_button_set_relief(GTK_BUTTON(record_start_button), GTK_RELIEF_NONE);
record_stop_icon = gtk_image_new_from_file("icons/media-playback-stop.svg");
record_stop_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(record_stop_button), record_stop_icon);
gtk_table_attach_defaults(GTK_TABLE(right_table), record_stop_button, 2, 3, 1, 2);
gtk_button_set_relief(GTK_BUTTON(record_stop_button), GTK_RELIEF_NONE);
/* fullscreen buttons */
fullscreen_enable_icon = gtk_image_new_from_file("icons/view-fullscreen.svg");
fullscreen_enable_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(fullscreen_enable_button), fullscreen_enable_icon);
g_signal_connect(fullscreen_enable_button, "clicked", G_CALLBACK(enable_Fullscreen), NULL);
gtk_button_set_relief(fullscreen_enable_button, GTK_RELIEF_NONE);
fullscreen_disable_icon = gtk_image_new_from_file("icons/view-windowed.svg");
fullscreen_disable_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(fullscreen_disable_button), fullscreen_disable_icon);
g_signal_connect(fullscreen_disable_button, "clicked", G_CALLBACK(disable_Fullscreen), NULL);
gtk_button_set_relief(fullscreen_disable_button, GTK_RELIEF_NONE);
/* joystick button */
// https://commons.wikimedia.org/wiki/File:PlayStation_3_gamepad.svg
joystick_icon = gtk_image_new_from_file("icons/PlayStation_3_gamepad.svg");
check_button_joystick = gtk_check_button_new();
/* gtk_container_add (GTK_CONTAINER (check_button_joystick), joystick_icon); */
/* łączenie sygnału przeniesione za pierwsze wykrycie joysticka */
/* video button */
video_icon = gtk_image_new_from_file("icons/camera-web.svg");
check_button_video = gtk_check_button_new();
gtk_toggle_button_set_active(check_button_video, TRUE);
/* reconnect button */
reconnect_icon = gtk_image_new_from_file("icons/gnome-modem.svg");
reconnect_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(reconnect_button), reconnect_icon);
gtk_button_set_relief(reconnect_button, GTK_RELIEF_NONE);
/* table method */
gtk_table_attach_defaults(GTK_TABLE(right_table), label_x1, 0, 1, 0, 1);
gtk_table_attach(GTK_TABLE(right_table), label_y1, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 20);
gtk_table_attach_defaults(GTK_TABLE(right_table), label_x2, 1, 2, 0, 1);
gtk_table_attach(GTK_TABLE(right_table), label_y2, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 20);
gtk_table_attach_defaults(GTK_TABLE(right_table), reconnect_button, 2, 3, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), fullscreen_enable_button, 2, 3, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(right_table), fullscreen_disable_button, 2, 3, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(right_table), video_icon, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_video, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), joystick_icon, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_joystick, 0, 1, 3, 4);
/* grid method */
// FIXME: works only with GTK+ 3.0
/*
gtk_grid_attach(GTK_GRID(right_table), label_x, 0, 0, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_y, 0, 1, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_x2, 1, 0, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_y2, 1, 1, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), fullscreen_enable_button, 2, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), fullscreen_disable_button, 2, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), video_icon, 1, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_video, 1, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), joystick_icon, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_joystick, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_serwokontroler, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_regulator, 1, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), quit_button, 2, 3, 1, 1);
*/
statusbar = gtk_statusbar_new();
context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "Statusbar example");
/* pakowanie głównych elementów okna programu: */
vbox = gtk_vbox_new(FALSE, 2);
/* ustawianie szerokości marginesu wokół elementu */
gtk_box_pack_start(GTK_BOX(vbox), main_table, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
gtk_container_set_border_width(GTK_CONTAINER(main_table), 5);
gtk_container_add(GTK_CONTAINER(main_window), vbox);
}
static void
setup_datetime_dialog (CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv = self->priv;
GtkAdjustment *adjustment;
GdkScreen *screen;
GtkCssProvider *provider;
GtkWidget *dialog;
guint num_days;
setup_am_pm_button (self);
/* Big time buttons */
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider),
".gnome-control-center-datetime-setup-time>spinbutton,\n"
".gnome-control-center-datetime-setup-time>label {\n"
" font-size: 250%;\n"
"}\n"
".gnome-control-center-datetime-setup-time>spinbutton>entry {\n"
" padding: 8px 13px;\n"
"}", -1, NULL);
screen = gdk_screen_get_default ();
gtk_style_context_add_provider_for_screen (screen,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
dialog = W ("datetime-dialog");
g_signal_connect (dialog, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
/* Force the direction for the time, so that the time
* is presented correctly for RTL languages */
gtk_widget_set_direction (W ("time_grid"), GTK_TEXT_DIR_LTR);
/* Month */
gtk_combo_box_set_active (GTK_COMBO_BOX (W ("month-combobox")),
g_date_time_get_month (priv->date) - 1);
g_signal_connect (G_OBJECT (W("month-combobox")), "changed",
G_CALLBACK (month_year_changed), self);
/* Day */
num_days = g_date_get_days_in_month (g_date_time_get_month (priv->date),
g_date_time_get_year (priv->date));
adjustment = (GtkAdjustment*) gtk_adjustment_new (g_date_time_get_day_of_month (priv->date), 1,
num_days + 1, 1, 10, 1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (W ("day-spinbutton")),
adjustment);
g_signal_connect (G_OBJECT (W ("day-spinbutton")), "value-changed",
G_CALLBACK (day_changed), self);
/* Year */
adjustment = (GtkAdjustment*) gtk_adjustment_new (g_date_time_get_year (priv->date),
1, G_MAXDOUBLE, 1,
10, 1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (W ("year-spinbutton")),
adjustment);
g_signal_connect (G_OBJECT (W ("year-spinbutton")), "value-changed",
G_CALLBACK (month_year_changed), self);
/* Hours and minutes */
g_signal_connect (W ("h_spinbutton"), "output",
G_CALLBACK (format_hours_combobox), self);
g_signal_connect (W ("m_spinbutton"), "output",
G_CALLBACK (format_minutes_combobox), self);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (W ("h_spinbutton")), 1, 0);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (W ("m_spinbutton")), 1, 0);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (W ("h_spinbutton")), 0, 23);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (W ("m_spinbutton")), 0, 59);
g_signal_connect_swapped (W ("h_spinbutton"), "value-changed",
G_CALLBACK (change_time), self);
g_signal_connect_swapped (W ("m_spinbutton"), "value-changed",
G_CALLBACK (change_time), self);
}
