static GtkWidget* do_config (MaintainrProjectbox *item)
{
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *hbox;
GtkWidget *button;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_widget_set_halign (vbox, GTK_ALIGN_CENTER);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
table = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (table), 5);
gtk_container_set_border_width (GTK_CONTAINER (table), 0);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
gtk_widget_set_hexpand (table, TRUE);
item->priv->project_name = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (item->priv->project_name), "Untitled");
gtk_grid_attach (GTK_GRID (table), gtk_label_new ("Name"), 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (table), item->priv->project_name, 1, 0, 1, 1);
item->priv->priority = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (item->priv->priority), NULL, "High");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (item->priv->priority), NULL, "Medium");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (item->priv->priority), NULL, "Low");
gtk_grid_attach (GTK_GRID (table), gtk_label_new ("Priority"), 0, 1, 1, 1);
gtk_grid_attach (GTK_GRID (table), item->priv->priority, 1, 1, 1, 1);
item->priv->services_confs = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox), item->priv->services_confs, TRUE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("edit-delete", GTK_ICON_SIZE_BUTTON));
gtk_widget_set_tooltip_text (button, "Remove this project from the list");
g_signal_connect (button, "clicked", G_CALLBACK (delete_project), item);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("document-save", GTK_ICON_SIZE_BUTTON));
gtk_widget_set_tooltip_text (button, "Save settings and back to the main screen");
g_signal_connect (button, "clicked", G_CALLBACK (save_conf), item);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
return vbox;
}
static void
item_end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
ItemParserData *data = (ItemParserData*)user_data;
/* Append the translated strings */
if (data->string->len)
{
if (data->translatable)
{
const gchar *translated;
translated = _gtk_builder_parser_translate (data->domain,
data->context,
data->string->str);
g_string_assign (data->string, translated);
}
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (data->object), data->id, data->string->str);
}
data->translatable = FALSE;
g_string_set_size (data->string, 0);
g_free (data->context);
data->context = NULL;
g_free (data->id);
data->id = NULL;
data->is_text = FALSE;
}
void
glade_gtk_combo_box_text_set_property (GladeWidgetAdaptor *adaptor,
GObject *object,
const gchar *id,
const GValue *value)
{
if (!strcmp (id, "glade-items"))
{
GList *string_list, *l;
GladeString *string;
gint active;
string_list = g_value_get_boxed (value);
active = gtk_combo_box_get_active (GTK_COMBO_BOX (object));
/* Update comboboxtext items */
gtk_combo_box_text_remove_all (GTK_COMBO_BOX_TEXT (object));
for (l = string_list; l; l = l->next)
{
string = l->data;
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (object), string->id, string->string);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (object),
CLAMP (active, 0, g_list_length (string_list) - 1));
}
else
GWA_GET_CLASS (GTK_TYPE_COMBO_BOX)->set_property (adaptor, object, id, value);
}
static GtkWidget *
deserialize_choice (GVariant *choice,
FileDialogHandle *handle)
{
GtkWidget *widget;
const char *choice_id;
const char *label;
const char *selected;
GVariant *choices;
int i;
g_variant_get (choice, "(&s&s@a(ss)&s)", &choice_id, &label, &choices, &selected);
if (g_variant_n_children (choices) > 0)
{
GtkWidget *box;
GtkWidget *combo;
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (label));
combo = gtk_combo_box_text_new ();
g_object_set_data_full (G_OBJECT (combo), "choice-id", g_strdup (choice_id), g_free);
gtk_container_add (GTK_CONTAINER (box), combo);
for (i = 0; i < g_variant_n_children (choices); i++)
{
const char *id;
const char *text;
g_variant_get_child (choices, i, "(&s&s)", &id, &text);
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), id, text);
}
if (strcmp (selected, "") == 0)
g_variant_get_child (choices, 0, "(&s&s)", &selected, NULL);
g_signal_connect (combo, "changed", G_CALLBACK (choice_changed), handle);
gtk_combo_box_set_active_id (GTK_COMBO_BOX (combo), selected);
widget = box;
}
else
{
GtkWidget *check;
check = gtk_check_button_new_with_label (label);
g_object_set_data_full (G_OBJECT (check), "choice-id", g_strdup (choice_id), g_free);
g_signal_connect (check, "toggled", G_CALLBACK (choice_toggled), handle);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), g_strcmp0 (selected, "true") == 0);
widget = check;
}
gtk_widget_show_all (widget);
return widget;
}
static VALUE
rg_append(VALUE self, VALUE id, VALUE text)
{
gtk_combo_box_text_append(_SELF(self),
RVAL2CSTR_ACCEPT_NIL(id),
RVAL2CSTR(text));
return self;
}
void addDropDownList(int numberOfElements, GtkGrid *grid, void (*entryChangedFuncPtr) (GtkComboBox *editable, gpointer),
int col, int row){
GtkWidget* comboBoxWithText = gtk_combo_box_text_new_with_entry ();
int i = 1;
while(i <= numberOfElements){
char *numberAsChar = malloc(20);
sprintf(numberAsChar, "%d", i);
gtk_combo_box_text_append (comboBoxWithText, numberAsChar, numberAsChar);
i = i + 1;
}
gtk_combo_box_set_active_id (comboBoxWithText,"1");
g_signal_connect(comboBoxWithText, "changed", G_CALLBACK(entryChangedFuncPtr), NULL);
gtk_grid_attach(grid, comboBoxWithText, col, row, 1, 1);
gtk_widget_show(comboBoxWithText);
}
static void
g_paste_settings_ui_stack_private_refill_histories (GPasteSettingsUiStackPrivate *priv)
{
G_PASTE_CLEANUP_ERROR_FREE GError *error = NULL;
GStrv histories = g_paste_client_list_histories_sync (priv->client, &error);
if (g_paste_settings_ui_check_connection_error (error))
return;
GtkComboBoxText *targets = priv->targets;
gtk_combo_box_text_remove_all (targets);
for (guint i = 0; histories[i]; ++i)
gtk_combo_box_text_append (targets, histories[i], histories[i]);
gtk_combo_box_set_active_id (GTK_COMBO_BOX (targets),
g_paste_settings_get_history_name (priv->settings));
}
/* ussd_on_operators_changed */
static void _ussd_on_operators_changed(gpointer data)
{
USSD * ussd = data;
GtkTreeModel * model;
int i;
USSDCode * codes;
model = gtk_combo_box_get_model(GTK_COMBO_BOX(ussd->codes));
gtk_list_store_clear(GTK_LIST_STORE(model));
i = gtk_combo_box_get_active(GTK_COMBO_BOX(ussd->operators));
codes = _ussd_operators[i].codes;
for(i = 0; codes[i].name != NULL; i++)
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(ussd->codes),
NULL, codes[i].name);
#else
gtk_combo_box_append_text(GTK_COMBO_BOX(ussd->codes),
codes[i].name);
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(ussd->codes), 0);
}
static void
item_end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
ItemParserData *data = (ItemParserData*)user_data;
/* Append the translated strings */
if (data->string->len)
{
if (data->translatable)
{
gchar *translated;
/* FIXME: This will not use the domain set in the .ui file,
* since the parser is not telling the builder about the domain.
* However, it will work for gtk_builder_set_translation_domain() calls.
*/
translated = _gtk_builder_parser_translate (data->domain,
data->context,
data->string->str);
g_string_set_size (data->string, 0);
g_string_append (data->string, translated);
}
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (data->object), data->id, data->string->str);
}
data->translatable = FALSE;
g_string_set_size (data->string, 0);
g_free (data->context);
data->context = NULL;
g_free (data->id);
data->id = NULL;
data->is_text = FALSE;
}
static void populate_MRUs(NEW_DATA *new_data)
{
/* Create the list of previously used workout types
* and connect them to the combo box
*/
R2RDatabase *database = new_data->database;
GtkComboBoxText *workout_type_entry = new_data->workout_type_entry;
GtkComboBoxText *route_entry = new_data->route_entry;
int i, j;
gboolean already_in;
gchar **types = NULL;
guint ntypes = 0;
for (i = 0; i < database->nruns; i++) {
already_in = false;
for (j = 0; j < ntypes; j++) {
if (g_strcmp0(database->run[i]->type, types[j]) == 0 ||
database->run[i]->type[0] == ' ' ||
database->run[i]->type[0] == '\0')
already_in = true;
}
if (!already_in) {
ntypes++;
types = g_realloc(types, ntypes * sizeof(gchar *));
types[ntypes - 1] = g_malloc(database->run[i]->type_len + 1);
g_strlcpy(types[ntypes - 1], database->run[i]->type,
database->run[i]->type_len + 1);
}
}
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(workout_type_entry));
for (i = 0; i < ntypes; i++) {
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(workout_type_entry),
NULL, types[i]);
g_free(types[i]);
}
g_free(types);
/* Create the list of previously used routes
* and connect them to the combo box
*/
gchar **routes = NULL;
guint nroutes = 0;
for (i = 0; i < database->nruns; i++) {
already_in = false;
for (j = 0; j < nroutes; j++) {
if (g_strcmp0(database->run[i]->route, routes[j]) == 0 ||
database->run[i]->route[0] == ' ' ||
database->run[i]->route[0] == '\0')
already_in = true;
}
if (!already_in) {
nroutes++;
routes = g_realloc(routes, nroutes * sizeof(gchar *));
routes[nroutes - 1] = g_malloc(database->run[i]->route_len + 1);
g_strlcpy(routes[nroutes - 1], database->run[i]->route,
database->run[i]->route_len + 1);
}
}
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(route_entry));
for (i = 0; i < nroutes; i++) {
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(route_entry),
NULL, routes[i]);
g_free(routes[i]);
}
g_free(routes);
}
static Debug * _debug_init(PhonePluginHelper * helper)
{
Debug * debug;
GtkSizeGroup * group;
GtkWidget * vbox;
GtkWidget * widget;
GtkWidget * hbox;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
size_t i;
if((debug = object_new(sizeof(*debug))) == NULL)
return NULL;
debug->helper = helper;
group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
debug->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(debug->window), 200, 300);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(debug->window), plugin.icon);
#endif
gtk_window_set_title(GTK_WINDOW(debug->window), plugin.name);
g_signal_connect_swapped(debug->window, "delete-event", G_CALLBACK(
_debug_on_closex), debug);
/* vbox */
vbox = gtk_vbox_new(FALSE, 0);
/* modem requests */
hbox = gtk_hbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 4);
#if GTK_CHECK_VERSION(3, 0, 0)
debug->requests = gtk_combo_box_text_new();
for(i = 0; _debug_modem_requests[i].name != NULL; i++)
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->requests),
NULL, _debug_modem_requests[i].name);
#else
debug->requests = gtk_combo_box_new_text();
for(i = 0; _debug_modem_requests[i].name != NULL; i++)
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->requests),
_debug_modem_requests[i].name);
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(debug->requests), 0);
gtk_box_pack_start(GTK_BOX(hbox), debug->requests, TRUE, TRUE, 0);
widget = gtk_button_new_from_stock(GTK_STOCK_EXECUTE);
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_debug_on_queue_request), debug);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
/* modem triggers */
hbox = gtk_hbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 4);
#if GTK_CHECK_VERSION(3, 0, 0)
debug->triggers = gtk_combo_box_text_new();
for(i = 0; _debug_modem_triggers[i].name != NULL; i++)
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->triggers),
NULL, _debug_modem_triggers[i].name);
#else
debug->triggers = gtk_combo_box_new_text();
for(i = 0; _debug_modem_triggers[i].name != NULL; i++)
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->triggers),
_debug_modem_triggers[i].name);
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(debug->triggers), 0);
gtk_box_pack_start(GTK_BOX(hbox), debug->triggers, TRUE, TRUE, 0);
widget = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_debug_on_queue_trigger), debug);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
/* events */
debug->events = gtk_list_store_new(3, G_TYPE_UINT, G_TYPE_STRING,
G_TYPE_STRING);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
debug->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
debug->events));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(debug->view), TRUE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Time", renderer,
"text", 1, NULL);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(debug->view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Event", renderer,
"text", 2, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(debug->view), column);
gtk_container_add(GTK_CONTAINER(widget), debug->view);
gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(debug->window), vbox);
gtk_widget_show_all(debug->window);
return debug;
}
static void serverstats_init(void)
{
/** Get an allready exposed widgets to grab theme colors from. */
GtkWidget *colw = (GtkWidget *) playlist3_get_category_tree_view();
GtkWidget *label = NULL;
GtkWidget *table = NULL;
GtkWidget *hbox = NULL;
GtkWidget *event = NULL;
GtkWidget *serverstats_vbox = gtk_vbox_new(FALSE, 0);
GtkWidget *serverstats_event;
gchar *markup = NULL;
int i = 0;
serverstats_sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
serverstats_event = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(serverstats_event), TRUE);
gtk_container_add(GTK_CONTAINER(serverstats_event), serverstats_vbox);
{
GtkStyleContext *cs = gtk_widget_get_style_context(GTK_WIDGET(serverstats_event));
gtk_style_context_add_class(cs, GTK_STYLE_CLASS_VIEW);
}
/* wrap in event box to set bg color */
event = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), TRUE);
//gtk_widget_set_state(GTK_WIDGET(event), GTK_STATE_SELECTED);
{
GtkStyleContext *cs = gtk_widget_get_style_context(GTK_WIDGET(serverstats_event));
gtk_style_context_add_class(cs, GTK_STYLE_CLASS_HEADER);
}
//gtk_widget_modify_bg(serverstats_event, GTK_STATE_NORMAL, &(colw->style->base[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(serverstats_vbox), "style-set", G_CALLBACK(serverstats_header_style_changed),
serverstats_event);
/* set label and padding */
hbox = gtk_hbox_new(FALSE, 6);
label = gtk_image_new_from_icon_name("mpd", GTK_ICON_SIZE_DND);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='xx-large' weight='bold'>%s</span>", _("Server Information"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(event), hbox);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
gtk_box_pack_start(GTK_BOX(serverstats_vbox), event, FALSE, TRUE, 0);
gtk_widget_show_all(event);
label = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(serverstats_vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
/**
* Data list
*/
table = gtk_grid_new();//(SERVERSTATS_NUM_FIELDS + 2, 2, FALSE);
gtk_grid_set_column_spacing(GTK_GRID(table), 6);
gtk_grid_set_row_spacing(GTK_GRID(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 12);
/** Database */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Server"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0,0,2,1);
i = 1;
/** Mpd version */
serverstats_add_entry(table, i++, _("Version"), SERVERSTATS_MPD_VERSION);
serverstats_add_entry(table, i++, _("Uptime"), SERVERSTATS_MPD_UPTIME);
serverstats_add_entry(table, i++, _("Time Playing"), SERVERSTATS_MPD_PLAYTIME);
/** Database */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Database"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0, i, 2, 1);
i++;
/** Mpd Playtime */
serverstats_add_entry(table, i++, _("Total Playtime"), SERVERSTATS_MPD_DB_PLAYTIME);
/** Mpd Artists*/
serverstats_add_entry(table, i++, _("Number of artists"), SERVERSTATS_MPD_DB_ARTISTS);
/** Mpd Albums */
serverstats_add_entry(table, i++, _("Number of albums"), SERVERSTATS_MPD_DB_ALBUMS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("Number of songs"), SERVERSTATS_MPD_DB_SONGS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("URL Handlers"), SERVERSTATS_MPD_URLHANDLERS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("Tag Types"), SERVERSTATS_MPD_TAG_TYPES);
/** Stats */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Tag statistics"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0, i, 2, 1);
i++;
gtk_widget_show_all(table);
/**
* Stats treeview
*/
{
int j;
GtkWidget *combo = NULL;
GtkWidget *sw = NULL, *cancel;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkWidget *pb = gtk_progress_bar_new();
combo = gtk_combo_box_text_new();
for (j = 0; j < MPD_TAG_NUM_OF_ITEM_TYPES - 1; j++)
{
if (mpd_server_tag_supported(connection, j))
{
gtk_combo_box_text_append(GTK_COMBO_BOX(combo),NULL, mpdTagItemKeys[j]);
}
}
gtk_grid_attach(GTK_GRID(table), combo, 0, i, 2, 1);
i++;
gtk_widget_show(combo);
hbox = gtk_hbox_new(FALSE, 6);
cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect(G_OBJECT(cancel), "clicked", G_CALLBACK(cancel_clicked), NULL);
gtk_box_pack_start(GTK_BOX(hbox), pb, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), cancel, FALSE, TRUE, 0);
gtk_grid_attach(GTK_GRID(table), hbox, 0, i, 2, 1);
i++;
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(serverstats_combo_changed), pb);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_container_set_border_width(GTK_CONTAINER(sw), 6);
store = gtk_list_store_new(4, G_TYPE_ULONG, G_TYPE_STRING, G_TYPE_ULONG, G_TYPE_STRING);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 0, GTK_SORT_DESCENDING);
serverstats_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(serverstats_tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(serverstats_tree), TRUE);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, "width-chars", 30,
NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree), -1, "", renderer, "text", 1, NULL);
renderer = gtk_cell_renderer_progress_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree),
-1, "", renderer, "value", 2, "text", 3, NULL);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1);
gtk_container_add(GTK_CONTAINER(sw), serverstats_tree);
gtk_grid_attach(GTK_GRID(table), sw, 0, i, 2, 1);
i++;
gtk_widget_show_all(sw);
}
/**
* Add table
*/
gtk_box_pack_start(GTK_BOX(serverstats_vbox), table, TRUE, TRUE, 0);
/* maintain my own reference to the widget, so it won't get destroyed removing
* from view
*/
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(serverstats_sw), serverstats_event);
gtk_widget_show(serverstats_vbox);
gtk_widget_show(serverstats_event);
gtk_widget_show(serverstats_sw);
g_object_ref_sink(serverstats_sw);
}
static void
mail_config_remote_backend_insert_widgets (EMailConfigServiceBackend *backend,
GtkBox *parent)
{
EMailConfigRemoteBackend *remote_backend;
CamelProvider *provider;
CamelSettings *settings;
ESource *source;
ESourceBackend *extension;
EMailConfigServicePage *page;
EMailConfigServicePageClass *class;
GtkLabel *label;
GtkWidget *widget;
GtkWidget *container;
const gchar *backend_name;
const gchar *extension_name;
const gchar *text;
gchar *markup;
remote_backend = E_MAIL_CONFIG_REMOTE_BACKEND (backend);
page = e_mail_config_service_backend_get_page (backend);
source = e_mail_config_service_backend_get_source (backend);
settings = e_mail_config_service_backend_get_settings (backend);
class = E_MAIL_CONFIG_SERVICE_PAGE_GET_CLASS (page);
extension_name = class->extension_name;
extension = e_source_get_extension (source, extension_name);
backend_name = e_source_backend_get_backend_name (extension);
text = _("Configuration");
markup = g_markup_printf_escaped ("<b>%s</b>", text);
widget = gtk_label_new (markup);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
g_free (markup);
widget = gtk_grid_new ();
gtk_widget_set_margin_left (widget, 12);
gtk_grid_set_row_spacing (GTK_GRID (widget), 6);
gtk_grid_set_column_spacing (GTK_GRID (widget), 6);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
container = widget;
widget = gtk_label_new_with_mnemonic (_("_Server:"));
gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5);
gtk_grid_attach (GTK_GRID (container), widget, 0, 0, 1, 1);
gtk_widget_show (widget);
label = GTK_LABEL (widget);
widget = gtk_entry_new ();
gtk_widget_set_hexpand (widget, TRUE);
gtk_label_set_mnemonic_widget (label, widget);
gtk_grid_attach (GTK_GRID (container), widget, 1, 0, 1, 1);
remote_backend->host_entry = widget; /* do not reference */
gtk_widget_show (widget);
widget = gtk_label_new_with_mnemonic (_("_Port:"));
gtk_grid_attach (GTK_GRID (container), widget, 2, 0, 1, 1);
gtk_widget_show (widget);
label = GTK_LABEL (widget);
widget = e_port_entry_new ();
gtk_label_set_mnemonic_widget (label, widget);
gtk_grid_attach (GTK_GRID (container), widget, 3, 0, 1, 1);
remote_backend->port_entry = widget; /* do not reference */
gtk_widget_show (widget);
widget = gtk_label_new_with_mnemonic (_("User_name:"));
gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5);
gtk_grid_attach (GTK_GRID (container), widget, 0, 1, 1, 1);
gtk_widget_show (widget);
label = GTK_LABEL (widget);
widget = gtk_entry_new ();
gtk_widget_set_hexpand (widget, TRUE);
gtk_label_set_mnemonic_widget (label, widget);
gtk_grid_attach (GTK_GRID (container), widget, 1, 1, 3, 1);
remote_backend->user_entry = widget; /* do not reference */
gtk_widget_show (widget);
text = _("Security");
markup = g_markup_printf_escaped ("<b>%s</b>", text);
widget = gtk_label_new (markup);
gtk_widget_set_margin_top (widget, 6);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
g_free (markup);
widget = gtk_grid_new ();
gtk_widget_set_margin_left (widget, 12);
gtk_grid_set_row_spacing (GTK_GRID (widget), 6);
gtk_grid_set_column_spacing (GTK_GRID (widget), 6);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
container = widget;
widget = gtk_label_new_with_mnemonic (_("Encryption _method:"));
gtk_grid_attach (GTK_GRID (container), widget, 0, 0, 1, 1);
gtk_widget_show (widget);
label = GTK_LABEL (widget);
/* The IDs correspond to the CamelNetworkSecurityMethod enum. */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append (
GTK_COMBO_BOX_TEXT (widget),
"none",
_("No encryption"));
gtk_combo_box_text_append (
GTK_COMBO_BOX_TEXT (widget),
"starttls-on-standard-port",
_("STARTTLS after connecting"));
gtk_combo_box_text_append (
GTK_COMBO_BOX_TEXT (widget),
"ssl-on-alternate-port",
_("SSL on a dedicated port"));
gtk_label_set_mnemonic_widget (label, widget);
gtk_widget_set_halign (widget, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (container), widget, 1, 0, 1, 1);
remote_backend->security_combo_box = widget; /* do not reference */
gtk_widget_show (widget);
provider = camel_provider_get (backend_name, NULL);
if (provider != NULL && provider->port_entries != NULL)
e_port_entry_set_camel_entries (
E_PORT_ENTRY (remote_backend->port_entry),
provider->port_entries);
text = _("Authentication");
markup = g_markup_printf_escaped ("<b>%s</b>", text);
widget = gtk_label_new (markup);
gtk_widget_set_margin_top (widget, 6);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
g_free (markup);
widget = e_mail_config_auth_check_new (backend);
gtk_widget_set_margin_left (widget, 12);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
remote_backend->auth_check = widget; /* do not reference */
gtk_widget_show (widget);
e_binding_bind_object_text_property (
settings, "host",
remote_backend->host_entry, "text",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
g_object_bind_property_full (
settings, "security-method",
remote_backend->security_combo_box, "active-id",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE,
e_binding_transform_enum_value_to_nick,
e_binding_transform_enum_nick_to_value,
NULL, (GDestroyNotify) NULL);
g_object_bind_property (
settings, "port",
remote_backend->port_entry, "port",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
g_object_bind_property (
settings, "security-method",
remote_backend->port_entry, "security-method",
G_BINDING_SYNC_CREATE);
e_binding_bind_object_text_property (
settings, "user",
remote_backend->user_entry, "text",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
/* Don't use G_BINDING_SYNC_CREATE here since the widget
* chooses its initial mechanism more intelligently than
* a simple property binding would. */
g_object_bind_property (
settings, "auth-mechanism",
remote_backend->auth_check, "active-mechanism",
G_BINDING_BIDIRECTIONAL);
}
int main(int argc, char** argv) {
//gtk wdiget init start...
GtkWidget *window, *icon_view, *notebook;
GtkWidget *current_user_name, *current_time, *network_speed;
GtkWidget *home_button, *access_token_entry, *access_token_ok_button;
GtkWidget *access_token_cancel_button;
GtkWidget *get_access_token_button, *post_blog_title_entry;
GtkWidget *post_blog_content_text_view, *post_blog_content_text_buffer;
GtkWidget *post_blog_ok_button, *post_blog_cancel_button;
GtkWidget *blog_access_permission, *blog_password;
GList *post_blog_page = NULL;
GtkBuilder *builder;
GError *error = NULL;
//widget init
gtk_init(&argc, &argv);
builder = gtk_builder_new();
if(!gtk_builder_add_from_file(builder, "./sources/glade.glade", &error))
{
g_print("Error occured while loading UI files\n");
g_print("Message: %s\n", error->message);
g_free(error);
return 1;
}
//widget get from builder(glade files)
window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook1"));
icon_view = GTK_WIDGET(gtk_builder_get_object(builder, "iconview1"));
current_user_name = GTK_WIDGET(gtk_builder_get_object(builder,"label4"));
current_time = GTK_WIDGET(gtk_builder_get_object(builder, "label5"));
network_speed = GTK_WIDGET(gtk_builder_get_object(builder, "label6"));
access_token_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button3"));
access_token_cancel_button = GTK_WIDGET(gtk_builder_get_object(builder, "button6"));
get_access_token_button = GTK_WIDGET(gtk_builder_get_object(builder, "button2"));
home_button = GTK_WIDGET(gtk_builder_get_object(builder, "button1"));
access_token_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry1"));
post_blog_content_text_view= GTK_WIDGET(gtk_builder_get_object(builder, "textview1"));
post_blog_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button4"));
post_blog_title_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry2"));
blog_access_permission = GTK_WIDGET(gtk_builder_get_object(builder, "comboboxtext1"));
blog_password = GTK_WIDGET(gtk_builder_get_object(builder, "entry4"));
//set object attributes
gtk_window_set_title(GTK_WINDOW(window), "Xiao nei Gtk App");
gtk_window_set_default_size(GTK_WINDOW(window), 800, 400);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_icon_view_set_model(GTK_ICON_VIEW(icon_view), create_model());
gtk_icon_view_set_text_column(GTK_ICON_VIEW(icon_view), COL_DISPLAY_NAME);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view), COL_PIXBUF);
gtk_icon_view_set_columns(GTK_ICON_VIEW(icon_view), 4);
gtk_label_set_text(GTK_LABEL(current_user_name), "Current user:fengtianba");
g_timeout_add_seconds(1, (GSourceFunc)set_label_time, current_time);
gtk_label_set_text(GTK_LABEL(network_speed), "Network Speed:100M");
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
int n = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), icon_view);
//gtk_combo_box_set_model(GTK_COMBO_BOX(blog_access_permission), create_combo_box_tree_model());
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "private", "PRIVATE");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "public", "PUBLIC");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "password", "PASSWORD");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "friend", "FRIEND");
printf("n is %d\n", n);
struct tm *time_ptr;
time_t the_time;
char *time_malloc;
(void)time(&the_time);
time_ptr = localtime(&the_time);
time_malloc = malloc(sizeof(struct tm));
memset(time_malloc, 0, sizeof(struct tm));
sprintf(time_malloc, "%d/%d/%d/%d:%d:%d", 1900 + time_ptr->tm_year, time_ptr->tm_mon, time_ptr->tm_mday,
time_ptr->tm_hour, time_ptr->tm_min, time_ptr->tm_sec);
gtk_label_set_text(GTK_LABEL(current_time), time_malloc);
post_blog_page = g_list_append(post_blog_page, post_blog_title_entry);
post_blog_page = g_list_append(post_blog_page, post_blog_content_text_view);
post_blog_page = g_list_append(post_blog_page, blog_access_permission);
post_blog_page = g_list_append(post_blog_page, blog_password);
//signal to connect to widget
g_signal_connect(window, "delete-event", gtk_main_quit, NULL);
g_signal_connect(GTK_BUTTON(get_access_token_button), "clicked", G_CALLBACK(get_access_token_button_clicked), NULL);
g_signal_connect(GTK_ICON_VIEW(icon_view), "item-activated", G_CALLBACK(icon_view_item_select), notebook);
g_signal_connect(GTK_BUTTON(home_button), "clicked", G_CALLBACK(home_button_clicked), notebook);
g_signal_connect(GTK_BUTTON(access_token_ok_button), "clicked", G_CALLBACK(access_token_ok_button_clicked), access_token_entry);
g_signal_connect(GTK_BUTTON(post_blog_ok_button), "clicked", G_CALLBACK(post_blog_ok_button_clicked), post_blog_page);
//object unref
g_object_unref(G_OBJECT(builder));
//show widget
gtk_widget_show_all(window);
gtk_main();
int i = 100;
char *decode_string;
/*CURL *curl;
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
decode_string = curl_easy_unescape(curl, ACCESS_TOKEN, 0, &i);
printf("origin url: %s\n", ACCESS_TOKEN);
printf("new url: %s\n", decode_string);
curl_easy_cleanup(curl);*/
//puts("enter access token\n");
//scanf("%s", accesstoken);
//调用自己写的SDK
xiaonei_gtk_get_blog_list(accesstoken);
xiaonei_gtk_get_one_blog(accesstoken);
return (EXIT_SUCCESS);
}
static void remmina_main_init(RemminaMain *remminamain)
{
RemminaMainPriv *priv;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *hbox;
GtkWidget *quickconnect;
GtkWidget *tool_item;
GtkUIManager *uimanager;
GtkActionGroup *action_group;
GtkWidget *scrolledwindow;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GError *error;
priv = g_new0(RemminaMainPriv, 1);
remminamain->priv = priv;
remminamain->priv->expanded_group = remmina_string_array_new_from_string(remmina_pref.expanded_group);
/* Create main window */
g_signal_connect(G_OBJECT(remminamain), "delete-event", G_CALLBACK(remmina_main_on_delete_event), NULL);
g_signal_connect(G_OBJECT(remminamain), "destroy", G_CALLBACK(remmina_main_destroy), NULL);
g_signal_connect(G_OBJECT(remminamain), "window-state-event", G_CALLBACK(remmina_main_on_window_state_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(remminamain), 0);
gtk_window_set_title(GTK_WINDOW(remminamain), _("Remmina Remote Desktop Client"));
gtk_window_set_default_size(GTK_WINDOW(remminamain), remmina_pref.main_width, remmina_pref.main_height);
gtk_window_set_position(GTK_WINDOW(remminamain), GTK_WIN_POS_CENTER);
if (remmina_pref.main_maximize)
{
gtk_window_maximize(GTK_WINDOW(remminamain));
}
/* Create the main container */
#if GTK_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#elif GTK_VERSION == 2
vbox = gtk_vbox_new(FALSE, 0);
#endif
gtk_container_add(GTK_CONTAINER(remminamain), vbox);
gtk_widget_show(vbox);
/* Create the menubar and toolbar */
uimanager = gtk_ui_manager_new();
priv->uimanager = uimanager;
action_group = gtk_action_group_new("RemminaMainActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_menu_entries, G_N_ELEMENTS(remmina_main_ui_menu_entries),
remminamain);
gtk_action_group_add_toggle_actions(action_group, remmina_main_ui_toggle_menu_entries,
G_N_ELEMENTS(remmina_main_ui_toggle_menu_entries), remminamain);
gtk_action_group_add_radio_actions(action_group, remmina_main_ui_view_file_mode_entries,
G_N_ELEMENTS(remmina_main_ui_view_file_mode_entries), remmina_pref.view_file_mode,
G_CALLBACK(remmina_main_action_view_file_mode), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->main_group = action_group;
action_group = gtk_action_group_new("RemminaMainFileSensitiveActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_file_sensitive_menu_entries,
G_N_ELEMENTS(remmina_main_ui_file_sensitive_menu_entries), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->file_sensitive_group = action_group;
error = NULL;
gtk_ui_manager_add_ui_from_string(uimanager, remmina_main_ui_xml, -1, &error);
if (error)
{
g_message("building menus failed: %s", error->message);
g_error_free(error);
}
remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_TOOL, remmina_main_add_tool_plugin, remminamain);
menubar = gtk_ui_manager_get_widget(uimanager, "/MenuBar");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
priv->toolbar = gtk_ui_manager_get_widget(uimanager, "/ToolBar");
#if GTK_VERSION == 3
gtk_style_context_add_class(gtk_widget_get_style_context(priv->toolbar), GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
#endif
gtk_box_pack_start(GTK_BOX(vbox), priv->toolbar, FALSE, FALSE, 0);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionConnect");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionNew");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
remmina_main_create_quick_search(remminamain);
gtk_window_add_accel_group(GTK_WINDOW(remminamain), gtk_ui_manager_get_accel_group(uimanager));
gtk_action_group_set_sensitive(priv->file_sensitive_group, FALSE);
/* Add a Fast Connection box */
#if GTK_VERSION == 3
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#elif GTK_VERSION == 2
hbox = gtk_hbox_new(FALSE, 0);
#endif
priv->quickconnect_protocol = gtk_combo_box_text_new();
#if GTK_VERSION == 3
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP", "RDP");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC", "VNC");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX", "NX");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH", "SSH");
#elif GTK_VERSION == 2
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->quickconnect_protocol), 0);
gtk_widget_show(priv->quickconnect_protocol);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_protocol, FALSE, FALSE, 0);
priv->quickconnect_server = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(priv->quickconnect_server), 25);
gtk_widget_show(priv->quickconnect_server);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_server, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->quickconnect_server), "key-press-event", G_CALLBACK(remmina_main_quickconnect_on_key_press), remminamain);
quickconnect = gtk_button_new_with_label("Connect !");
gtk_widget_show(quickconnect);
gtk_box_pack_start(GTK_BOX(hbox), quickconnect, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(quickconnect), "clicked", G_CALLBACK(remmina_main_quickconnect_on_click), remminamain);
gtk_container_add(GTK_CONTAINER(vbox), hbox);
gtk_widget_show(hbox);
/* Create the scrolled window for the file list */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
/* Create the remmina file list */
tree = gtk_tree_view_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, NAME_COLUMN);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "icon-name", PROTOCOL_COLUMN);
g_object_set(G_OBJECT(renderer), "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", GROUP_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
priv->group_column = column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Server"), renderer, "text", SERVER_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, SERVER_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_container_add(GTK_CONTAINER(scrolledwindow), tree);
gtk_widget_show(tree);
gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)), remmina_main_selection_func,
remminamain, NULL);
g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(remmina_main_file_list_on_button_press), remminamain);
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(remmina_main_file_list_on_key_press), remminamain);
priv->file_list = tree;
/* Create statusbar */
priv->statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(vbox), priv->statusbar, FALSE, FALSE, 0);
gtk_widget_show(priv->statusbar);
/* Prepare the data */
remmina_main_load_files(remminamain, FALSE);
/* Load the preferences */
if (remmina_pref.hide_toolbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewToolbar")),
FALSE);
}
if (remmina_pref.hide_statusbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewStatusbar")),
FALSE);
}
if (remmina_pref.show_quick_search)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewQuickSearch")), TRUE);
}
if (remmina_pref.small_toolbutton)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewSmallToolbutton")), TRUE);
}
/* Drag-n-drop support */
gtk_drag_dest_set(GTK_WIDGET(remminamain), GTK_DEST_DEFAULT_ALL, remmina_drop_types, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(remminamain), "drag-data-received", G_CALLBACK(remmina_main_on_drag_data_received), NULL);
priv->initialized = TRUE;
remmina_widget_pool_register(GTK_WIDGET(remminamain));
}
void set_serial_dialog(GtkWidget *w, gpointer data)
{
gint i;
GtkWidget *dialog, *used, *device, *baudrate, *table, *devtype;
dialog = gtk_dialog_new_with_buttons (_("Serial Communication"),
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
#if (GTKVER == 3)
table = gtk_grid_new();
#else
table = gtk_table_new(2, 4, FALSE);
#endif
used = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(used), serial_used);
device = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(device), 20);
gtk_entry_set_text(GTK_ENTRY(device), serial_device[0] ? serial_device : "COM1");
#if (GTKVER == 3)
baudrate = gtk_combo_box_text_new();
for (i = 0; i < NUM_BAUDRATES; i++)
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(baudrate), NULL, serial_baudrates[i].text);
gtk_combo_box_set_active(GTK_COMBO_BOX(baudrate), serial_baudrate);
#else
baudrate = gtk_combo_box_new_text();
for (i = 0; i < NUM_BAUDRATES; i++)
gtk_combo_box_append_text((GtkComboBox *)baudrate, serial_baudrates[i].text);
gtk_combo_box_set_active((GtkComboBox *)baudrate, serial_baudrate);
#endif
#if (GTKVER == 3)
devtype = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devtype), NULL, "Normal");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devtype), NULL, "Stathmos/Allvåg");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devtype), NULL, "AP-1");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devtype), NULL, "My Weight");
gtk_combo_box_set_active(GTK_COMBO_BOX(devtype), device_type);
#else
devtype = gtk_combo_box_new_text();
gtk_combo_box_append_text((GtkComboBox *)devtype, "Normal");
gtk_combo_box_append_text((GtkComboBox *)devtype, "Stathmos/Allvåg");
gtk_combo_box_append_text((GtkComboBox *)devtype, "AP-1");
gtk_combo_box_append_text((GtkComboBox *)devtype, "My Weight");
gtk_combo_box_set_active((GtkComboBox *)devtype, device_type);
#endif
#if (GTKVER == 3)
gtk_grid_attach(GTK_GRID(table), gtk_label_new(_("In Use")), 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(table), used, 1, 0, 1, 1);
gtk_grid_attach(GTK_GRID(table), gtk_label_new(_("Device")), 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(table), device, 1, 1, 1, 1);
gtk_grid_attach(GTK_GRID(table), gtk_label_new(_("Baudrate")), 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(table), baudrate, 1, 2, 1, 1);
gtk_grid_attach(GTK_GRID(table), gtk_label_new(_("Type")), 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(table), devtype, 1, 3, 1, 1);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
table, FALSE, FALSE, 0);
#else
gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("In Use")), 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), used, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("Device")), 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table), device, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("Baudrate")), 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(table), baudrate, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("Type")), 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(table), devtype, 1, 2, 3, 4);
gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), table);
#endif
gtk_widget_show_all(dialog);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
strncpy(serial_device, gtk_entry_get_text(GTK_ENTRY(device)), sizeof(serial_device)-1);
serial_baudrate = gtk_combo_box_get_active(GTK_COMBO_BOX(baudrate));
device_type = gtk_combo_box_get_active(GTK_COMBO_BOX(devtype));
g_key_file_set_string(keyfile, "preferences", "serialdevice", serial_device);
g_key_file_set_integer(keyfile, "preferences", "serialbaudrate", serial_baudrate);
g_key_file_set_integer(keyfile, "preferences", "serialtype", device_type);
serial_used = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(used));
serial_changed = TRUE;
}
gtk_widget_destroy(dialog);
}
static GtkWidget * _preferences_window_applets(Panel * panel)
{
GtkSizeGroup * group;
GtkWidget * vbox;
GtkWidget * vbox2;
GtkWidget * vbox3;
GtkWidget * hbox;
GtkWidget * frame;
GtkWidget * widget;
size_t i;
/* FIXME this needs a restart to apply */
group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
hbox = gtk_hbox_new(FALSE, 4);
/* plug-ins */
frame = gtk_frame_new(_("Applets:"));
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(widget), 4);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget),
GTK_SHADOW_ETCHED_IN);
panel->pr_store = _preferences_window_applets_model();
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(panel->pr_store),
2, GTK_SORT_ASCENDING);
panel->pr_view = _preferences_window_applets_view(panel->pr_store,
FALSE);
gtk_container_add(GTK_CONTAINER(widget), panel->pr_view);
gtk_container_add(GTK_CONTAINER(frame), widget);
gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 0);
/* controls */
vbox2 = gtk_vbox_new(FALSE, 4);
widget = gtk_label_new(NULL);
gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
widget = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(
GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_preferences_on_top_add), panel);
gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0);
#ifndef EMBEDDED
widget = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(
GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_preferences_on_top_up), panel);
gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0);
widget = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(
GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_preferences_on_top_down), panel);
gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0);
#endif
widget = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(
GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_preferences_on_top_remove), panel);
gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0);
widget = gtk_label_new(NULL);
gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
widget = gtk_label_new(NULL);
gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
widget = gtk_label_new(NULL);
gtk_box_pack_end(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
widget = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(
GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_preferences_on_bottom_remove), panel);
gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0);
#ifndef EMBEDDED
widget = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(
GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_preferences_on_bottom_down), panel);
gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0);
widget = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(
GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_preferences_on_bottom_up), panel);
gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0);
#endif
widget = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(
GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_preferences_on_bottom_add), panel);
gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 4);
/* top plug-ins */
frame = gtk_frame_new(_("Top panel:"));
vbox3 = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
#if GTK_CHECK_VERSION(3, 0, 0)
panel->pr_top_size = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(panel->pr_top_size), NULL,
_("Default"));
#else
panel->pr_top_size = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_top_size),
_("Default"));
#endif
for(i = 0; i < sizeof(_panel_sizes) / sizeof(*_panel_sizes); i++)
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(
panel->pr_top_size), NULL,
_(_panel_sizes[i].alias));
#else
gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_top_size),
_(_panel_sizes[i].alias));
#endif
gtk_box_pack_start(GTK_BOX(vbox3), panel->pr_top_size, FALSE, TRUE, 0);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget),
GTK_SHADOW_ETCHED_IN);
panel->pr_top_store = _preferences_window_applets_model();
panel->pr_top_view = _preferences_window_applets_view(
panel->pr_top_store, TRUE);
gtk_container_add(GTK_CONTAINER(widget), panel->pr_top_view);
gtk_box_pack_start(GTK_BOX(vbox3), widget, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox3);
gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, 0);
/* bottom plug-ins */
frame = gtk_frame_new(_("Bottom panel:"));
vbox3 = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
#if GTK_CHECK_VERSION(3, 0, 0)
panel->pr_bottom_size = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(panel->pr_bottom_size),
NULL, _("Default"));
#else
panel->pr_bottom_size = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_bottom_size),
_("Default"));
#endif
for(i = 0; i < sizeof(_panel_sizes) / sizeof(*_panel_sizes); i++)
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(
panel->pr_bottom_size), NULL,
_(_panel_sizes[i].alias));
#else
gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_bottom_size),
_(_panel_sizes[i].alias));
#endif
gtk_box_pack_start(GTK_BOX(vbox3), panel->pr_bottom_size, FALSE, TRUE,
0);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget),
GTK_SHADOW_ETCHED_IN);
panel->pr_bottom_store = _preferences_window_applets_model();
panel->pr_bottom_view = _preferences_window_applets_view(
panel->pr_bottom_store, TRUE);
gtk_container_add(GTK_CONTAINER(widget), panel->pr_bottom_view);
gtk_box_pack_start(GTK_BOX(vbox3), widget, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox3);
gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
return vbox;
}
static GtkWidget* pocketvox_setup_get_user_grid(PocketvoxSetup *setup)
{
setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
PocketvoxSetupPrivate *priv = setup->priv;
GtkWidget *grid = gtk_grid_new();
GtkWidget *label_name = gtk_label_new(_("Your name"));
GtkWidget *entry_name = gtk_entry_new();
GtkWidget *label_keyword = gtk_label_new(_("Activation keyword"));
GtkWidget *entry_keyword = gtk_entry_new();
GtkWidget *label_voice = gtk_label_new(("Choose the espeak voice"));
GtkWidget *combo_voice = gtk_combo_box_text_new();
gchar *voicesPath = (gchar *)g_getenv("ESPEAK_VOICES_PATH");
g_return_val_if_fail(NULL != voicesPath, NULL);
GDir *dir = g_dir_open(voicesPath, 0, NULL);
const gchar *file ;
while ((file = g_dir_read_name(dir)) != NULL)
{
gchar *path = g_strdup_printf("%s/%s", voicesPath, file);
if(g_file_test(path, G_FILE_TEST_IS_DIR) == FALSE)
{
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo_voice), g_strdup(file), g_strdup(file));
}
g_free(path);
}
g_dir_close(dir);
gtk_misc_set_alignment(GTK_MISC(label_name), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(label_keyword), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(label_voice), 0.0, 0.5);
gtk_widget_set_hexpand(label_voice, TRUE);
gtk_widget_set_hexpand(label_name, TRUE);
gtk_widget_set_hexpand(label_keyword, TRUE);
g_settings_bind(priv->settings, "name", entry_name, "text", G_SETTINGS_BIND_DEFAULT);
g_settings_bind(priv->settings, "keyword", entry_keyword, "text", G_SETTINGS_BIND_DEFAULT);
g_settings_bind(priv->settings, "voice", combo_voice, "active-id", G_SETTINGS_BIND_DEFAULT);
gtk_widget_set_tooltip_text(entry_name, _("What is your name ?"));
gtk_widget_set_tooltip_text(entry_keyword, _("What is your activation keyword ?"));
gtk_widget_set_tooltip_text(combo_voice, _("Choose the language"));
gtk_grid_attach(GTK_GRID(grid), label_name, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), entry_name, 1, 0, 2, 1);
gtk_grid_attach(GTK_GRID(grid), label_keyword, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), entry_keyword, 1, 1, 2, 1);
gtk_grid_attach(GTK_GRID(grid), label_voice, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid), combo_voice, 1, 2, 2, 1);
gtk_widget_show_all(grid);
return grid;
}
int main (int argc, char *argv[]) {
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Stwitch");
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 20);
GtkWidget *layout = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(layout), 3);
gtk_grid_set_column_spacing(GTK_GRID(layout), 10);
gtk_orientable_set_orientation(GTK_ORIENTABLE(layout), GTK_ORIENTATION_VERTICAL);
gtk_container_add(GTK_CONTAINER(window), layout);
widgets[COMBO_VIDEO_DRIVER] = gtk_combo_box_text_new();
for (int i = 0; i < array_size(video_driver); ++i) {
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_VIDEO_DRIVER]),
video_driver[i], video_driver[i]);
}
g_signal_connect(GTK_COMBO_BOX_TEXT(widgets[COMBO_VIDEO_DRIVER]), "changed",
G_CALLBACK(vid_driver_change), NULL);
add_widget(widgets[COMBO_VIDEO_DRIVER], "Video driver", GTK_GRID(layout));
widgets[TEXT_VIDEO_DEVICE] = gtk_entry_new();
add_widget(widgets[TEXT_VIDEO_DEVICE], "Video device", GTK_GRID(layout));
widgets[TEXT_INPUT_RES] = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(widgets[TEXT_INPUT_RES]), "1280x720");
add_widget(widgets[TEXT_INPUT_RES], "Input resolution", GTK_GRID(layout));
GtkAdjustment *fps_adj = gtk_adjustment_new(30, 5, 999, 5, 1, 1);
widgets[INT_FPS] = gtk_spin_button_new(fps_adj, 1, 0);
add_widget(widgets[INT_FPS], "Frames per second", GTK_GRID(layout));
widgets[COMBO_AUDIO_DRIVER] = gtk_combo_box_text_new();
for (int i = 0; i < array_size(audio_driver); ++i) {
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_AUDIO_DRIVER]),
audio_driver[i], audio_driver[i]);
}
g_signal_connect(GTK_COMBO_BOX_TEXT(widgets[COMBO_AUDIO_DRIVER]), "changed",
G_CALLBACK(audio_driver_change), NULL);
add_widget(widgets[COMBO_AUDIO_DRIVER], "Audio driver", GTK_GRID(layout));
widgets[TEXT_AUDIO_DEVICE] = gtk_entry_new();
add_widget(widgets[TEXT_AUDIO_DEVICE], "Audio device", GTK_GRID(layout));
GtkAdjustment *rate = gtk_adjustment_new(44100, 800, 999999, 100, 1, 1);
widgets[INT_AUDIO_RATE] = gtk_spin_button_new(rate, 1, 0);
add_widget(widgets[INT_AUDIO_RATE], "Audio rate (Hz)", GTK_GRID(layout));
GtkAdjustment *channels = gtk_adjustment_new(1, 1, 65, 1, 1, 1);
widgets[INT_AUDIO_CHANNELS] = gtk_spin_button_new(channels, 1, 0);
add_widget(widgets[INT_AUDIO_CHANNELS], "Audio channels", GTK_GRID(layout));
widgets[TEXT_OUTPUT_RES] = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(widgets[TEXT_OUTPUT_RES]), "1280x720");
add_widget(widgets[TEXT_OUTPUT_RES], "Output resolution", GTK_GRID(layout));
GtkAdjustment *audio_bitrate = gtk_adjustment_new(128, 32, 1280, 32, 1, 1);
widgets[INT_AUDIO_BITRATE] = gtk_spin_button_new(audio_bitrate, 1, 0);
add_widget(widgets[INT_AUDIO_BITRATE], "Audio bitrate (k)", GTK_GRID(layout));
GtkAdjustment *bitrate = gtk_adjustment_new(1000, 100, 100000, 100, 1, 1);
widgets[INT_VIDEO_BITRATE] = gtk_spin_button_new(bitrate, 1, 0);
add_widget(widgets[INT_VIDEO_BITRATE], "Video bitrate (k)", GTK_GRID(layout));
widgets[COMBO_QUALITY] = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_QUALITY]),
"ultrafast", "ultrafast");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_QUALITY]),
"superfast", "superfast");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_QUALITY]),
"faster", "faster");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_QUALITY]),
"fast", "fast");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_QUALITY]),
"medium", "medium");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_QUALITY]),
"slow", "slow");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_QUALITY]),
"slower", "slower");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets[COMBO_QUALITY]),
"veryslow", "veryslow");
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets[COMBO_QUALITY]), 0);
add_widget(widgets[COMBO_QUALITY], "Quality", GTK_GRID(layout));
GtkAdjustment *threads = gtk_adjustment_new(2, 1, 17, 1, 1, 1);
widgets[INT_THREADS] = gtk_spin_button_new(threads, 1, 0);
add_widget(widgets[INT_THREADS], "Threads", GTK_GRID(layout));
widgets[TEXT_STREAM_KEY] = gtk_entry_new();
add_widget(widgets[TEXT_STREAM_KEY], "Stream key", GTK_GRID(layout));
widgets[BTN_CONTROL] = gtk_button_new_with_label("Start");
g_signal_connect(GTK_BUTTON(widgets[BTN_CONTROL]), "clicked", G_CALLBACK(start_stream), NULL);
add_widget(widgets[BTN_CONTROL], "Start stream", GTK_GRID(layout));
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void _settings_window(USSD * ussd)
{
GtkSizeGroup * group;
GtkWidget * vbox;
GtkWidget * hbox;
GtkWidget * image;
GtkWidget * widget;
size_t i;
group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
ussd->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(ussd->window), 4);
gtk_window_set_default_size(GTK_WINDOW(ussd->window), 200, 300);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(ussd->window), "gnome-settings");
#endif
gtk_window_set_title(GTK_WINDOW(ussd->window), "USSD");
g_signal_connect(ussd->window, "delete-event", G_CALLBACK(
gtk_widget_hide), NULL);
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
#else
vbox = gtk_vbox_new(FALSE, 4);
#endif
/* operators */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
widget = gtk_label_new("Operator:");
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
#if GTK_CHECK_VERSION(3, 0, 0)
ussd->operators = gtk_combo_box_text_new();
for(i = 0; _ussd_operators[i].name != NULL; i++)
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(ussd->operators),
NULL, _ussd_operators[i].name);
#else
ussd->operators = gtk_combo_box_new_text();
for(i = 0; _ussd_operators[i].name != NULL; i++)
gtk_combo_box_append_text(GTK_COMBO_BOX(ussd->operators),
_ussd_operators[i].name);
#endif
g_signal_connect_swapped(ussd->operators, "changed", G_CALLBACK(
_ussd_on_operators_changed), ussd);
gtk_box_pack_start(GTK_BOX(hbox), ussd->operators, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
/* codes */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
widget = gtk_label_new("Code:");
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
#if GTK_CHECK_VERSION(3, 0, 0)
ussd->codes = gtk_combo_box_text_new();
#else
ussd->codes = gtk_combo_box_new_text();
#endif
gtk_box_pack_start(GTK_BOX(hbox), ussd->codes, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
/* send */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
widget = gtk_label_new(NULL);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
widget = gtk_button_new_with_label("Send request");
image = gtk_image_new_from_icon_name("mail-send", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(widget), image);
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_ussd_on_settings_send), ussd);
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
/* button box */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbox = gtk_hbutton_box_new();
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 4);
widget = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_ussd_on_settings_close), ussd);
gtk_container_add(GTK_CONTAINER(hbox), widget);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(ussd->window), vbox);
gtk_combo_box_set_active(GTK_COMBO_BOX(ussd->operators), 0);
gtk_widget_show_all(vbox);
}
int
main (int argc, char *argv[])
{
GtkWidget *win;
GtkWidget *box;
GtkWidget *button;
GtkWidget *button2;
GtkBuilder *builder;
GMenuModel *model;
GSimpleActionGroup *actions;
GtkWidget *overlay;
GtkWidget *grid;
GtkWidget *popover;
GtkWidget *popover2;
GtkWidget *label;
GtkWidget *check;
GtkWidget *combo;
gtk_init (&argc, &argv);
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (win), 400, 600);
actions = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (actions), entries, G_N_ELEMENTS (entries), NULL);
gtk_widget_insert_action_group (win, "top", G_ACTION_GROUP (actions));
overlay = gtk_overlay_new ();
gtk_container_add (GTK_CONTAINER (win), overlay);
grid = gtk_grid_new ();
gtk_widget_set_halign (grid, GTK_ALIGN_FILL);
gtk_widget_set_valign (grid, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
gtk_container_add (GTK_CONTAINER (overlay), grid);
label = gtk_label_new ("");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
label = gtk_label_new ("");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 3, 6, 1, 1);
builder = gtk_builder_new_from_file ("popover.ui");
model = (GMenuModel *)gtk_builder_get_object (builder, "menu");
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_menu_button_new ();
gtk_container_add (GTK_CONTAINER (box), button);
button2 = gtk_menu_button_new ();
gtk_container_add (GTK_CONTAINER (box), button2);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), model);
gtk_menu_button_set_use_popover (GTK_MENU_BUTTON (button), TRUE);
popover = GTK_WIDGET (gtk_menu_button_get_popover (GTK_MENU_BUTTON (button)));
builder = gtk_builder_new_from_file ("popover2.ui");
popover2 = (GtkWidget *)gtk_builder_get_object (builder, "popover");
gtk_menu_button_set_popover (GTK_MENU_BUTTON (button2), popover2);
g_object_set (box, "margin", 10, NULL);
gtk_widget_set_halign (box, GTK_ALIGN_END);
gtk_widget_set_valign (box, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), box);
label = gtk_label_new ("Popover hexpand");
check = gtk_check_button_new ();
g_object_bind_property (check, "active", popover, "hexpand", G_BINDING_DEFAULT);
g_object_bind_property (check, "active", popover2, "hexpand", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 2, 1, 1, 1);
label = gtk_label_new ("Popover vexpand");
check = gtk_check_button_new ();
g_object_bind_property (check, "active", popover, "vexpand", G_BINDING_DEFAULT);
g_object_bind_property (check, "active", popover2, "vexpand", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 2, 2, 1, 1);
label = gtk_label_new ("Button direction");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "up", "Up");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "down", "Down");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "left", "Left");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "right", "Right");
g_object_bind_property (combo, "active", button, "direction", G_BINDING_DEFAULT);
g_object_bind_property (combo, "active", button2, "direction", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 3, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 3, 1, 1);
label = gtk_label_new ("Button halign");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "fill", "Fill");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center", "Center");
g_object_bind_property (combo, "active", box, "halign", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 4, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 4, 1, 1);
label = gtk_label_new ("Button valign");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "fill", "Fill");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center", "Center");
g_object_bind_property (combo, "active", box, "valign", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 5, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 5, 1, 1);
gtk_widget_show_all (win);
gtk_main ();
return 0;
}
void settings_window_create (void) {
if(win_set_main != NULL) {
gtk_widget_hide(win_set_main);
gtk_widget_show(win_set_main);
return;
}
GtkWidget *vbox_set_m, *hbox_set_m, *but_set_close, *but_set_save, *but_set_reset;
GtkWidget *nb_set_m, *lab_e, *vbox_nb_up, *vbox_nb_um, *vbox_nb_uq;
GtkWidget *hbox_um_s, *grid_uq, *grid_up, *grid_um;
win_set_main = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win_set_main), "Pomf it! - Settings");
g_signal_connect(win_set_main, "destroy", G_CALLBACK(settings_window_destroy), NULL);
gtk_container_set_border_width(GTK_CONTAINER(win_set_main), 10);
gtk_window_resize(GTK_WINDOW(win_set_main), 320, 200);
gtk_window_set_position(GTK_WINDOW(win_set_main), GTK_WIN_POS_CENTER);
vbox_set_m = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0);
gtk_container_add(GTK_CONTAINER(win_set_main), vbox_set_m);
nb_set_m = gtk_notebook_new();
gtk_container_add(GTK_CONTAINER(vbox_set_m),nb_set_m);
vbox_nb_up = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0);
gtk_container_add(GTK_CONTAINER(nb_set_m), vbox_nb_up);
lab_e = gtk_label_new("Uploader");
g_object_set(G_OBJECT(lab_e), "can-focus", FALSE, NULL);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(nb_set_m),
gtk_notebook_get_nth_page(GTK_NOTEBOOK(nb_set_m), 0),lab_e);
vbox_nb_um = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0);
gtk_container_add(GTK_CONTAINER(nb_set_m), vbox_nb_um);
lab_e = gtk_label_new("Manager");
g_object_set(G_OBJECT(lab_e), "can-focus", FALSE, NULL);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(nb_set_m),
gtk_notebook_get_nth_page(GTK_NOTEBOOK(nb_set_m), 1),lab_e);
vbox_nb_uq = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0);
gtk_container_add(GTK_CONTAINER(nb_set_m), vbox_nb_uq);
lab_e = gtk_label_new("Queue");
g_object_set(G_OBJECT(lab_e), "can-focus", FALSE, NULL);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(nb_set_m),
gtk_notebook_get_nth_page(GTK_NOTEBOOK(nb_set_m), 2),lab_e);
grid_up = gtk_grid_new ();
gtk_box_pack_start(GTK_BOX(vbox_nb_up), grid_up , FALSE, FALSE, 0);
lab_e = gtk_label_new("Profiles: ");
gtk_grid_attach (GTK_GRID (grid_up),lab_e, 0, 0, 2, 1);
com_upm_pl = gtk_combo_box_text_new();
gtk_grid_attach (GTK_GRID (grid_up),com_upm_pl, 2, 0, 2, 1);
profiles_combo_fill();
hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0);
gtk_grid_attach (GTK_GRID (grid_up),hbox_um_s, 4, 0, 4, 1);
GtkWidget *but_up_act = gtk_button_new_with_label("Activate");
g_signal_connect(but_up_act,"clicked",G_CALLBACK(profiles_profile_activate), NULL);
gtk_box_pack_start(GTK_BOX(hbox_um_s),GTK_WIDGET(but_up_act),TRUE,TRUE,0);
GtkWidget *but_up_edit = gtk_button_new_with_label("Edit");
g_signal_connect(but_up_edit,"clicked",G_CALLBACK(profiles_profile_edit), NULL);
gtk_box_pack_start(GTK_BOX(hbox_um_s),GTK_WIDGET(but_up_edit),TRUE,TRUE,0);
hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0);
gtk_grid_attach (GTK_GRID (grid_up),hbox_um_s, 8, 0, 4, 1);
GtkWidget *but_up_add = gtk_button_new_with_label("Add New");
g_signal_connect(but_up_add,"clicked",G_CALLBACK(profiles_window_create), NULL);
gtk_box_pack_end(GTK_BOX(hbox_um_s),GTK_WIDGET(but_up_add),TRUE,FALSE,0);
GtkWidget *but_up_del = gtk_button_new_with_label("Delete");
g_signal_connect(but_up_del,"clicked",G_CALLBACK(profiles_profile_delete), NULL);
gtk_box_pack_start(GTK_BOX(hbox_um_s),GTK_WIDGET(but_up_del),TRUE,FALSE,0);
lab_e = gtk_label_new("Active Profile:");
gtk_grid_attach (GTK_GRID (grid_up),lab_e, 0, 1, 2, 1);
lab_profile = gtk_label_new("none");
gtk_grid_attach (GTK_GRID (grid_up),lab_profile, 2, 1, 2, 1);
lab_e = gtk_label_new("Keep SS:");
gtk_grid_attach (GTK_GRID (grid_up),lab_e, 4, 1, 2, 1);
sw_up_kss = gtk_switch_new();
gtk_grid_attach (GTK_GRID (grid_up),sw_up_kss, 6, 1, 2, 1);
grid_um = gtk_grid_new ();
gtk_box_pack_start(GTK_BOX(vbox_nb_um), grid_um , FALSE, FALSE, 0);
lab_e = gtk_label_new("Picture Preview:");
gtk_grid_attach (GTK_GRID (grid_um),lab_e, 0, 0, 2, 1);
sw_um_pp = gtk_switch_new();
gtk_grid_attach (GTK_GRID (grid_um),sw_um_pp, 2, 0, 2, 1);
lab_e = gtk_label_new("Window Size:");
gtk_grid_attach (GTK_GRID (grid_um),lab_e, 4, 0, 2, 1);
hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0);
gtk_grid_attach (GTK_GRID (grid_um),hbox_um_s, 6, 0, 4, 1);
entry_um_win_w = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_um_win_w);
gtk_entry_set_width_chars(GTK_ENTRY(entry_um_win_w),5);
lab_e = gtk_label_new("X");
gtk_container_add(GTK_CONTAINER(hbox_um_s), lab_e);
entry_um_win_h = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_um_win_h);
gtk_entry_set_width_chars(GTK_ENTRY(entry_um_win_h),5);
lab_e = gtk_label_new("Animate Preview:");
gtk_grid_attach (GTK_GRID (grid_um),lab_e, 0, 1, 2, 1);
sw_um_ap = gtk_switch_new();
gtk_grid_attach (GTK_GRID (grid_um),sw_um_ap, 2, 1, 2, 1);
lab_e = gtk_label_new("Preview Size:");
gtk_grid_attach (GTK_GRID (grid_um),lab_e, 4, 1, 2, 1);
hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0);
gtk_grid_attach (GTK_GRID (grid_um),hbox_um_s, 6, 1, 4, 1);
entry_um_pw_w = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_um_pw_w);
gtk_entry_set_width_chars(GTK_ENTRY(entry_um_pw_w),5);
lab_e = gtk_label_new("X");
gtk_container_add(GTK_CONTAINER(hbox_um_s), lab_e);
entry_um_pw_h = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_um_pw_h);
gtk_entry_set_width_chars(GTK_ENTRY(entry_um_pw_h),5);
lab_e = gtk_label_new("Window Position:");
gtk_grid_attach (GTK_GRID (grid_um),lab_e, 4, 2, 2, 1);
com_um_wp = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_wp), NULL, "Default");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_wp), NULL, "Center");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_wp), NULL, "Mouse");
gtk_grid_attach (GTK_GRID (grid_um),com_um_wp, 6, 2, 2, 1);
lab_e = gtk_label_new("Enable Double Click:");
gtk_grid_attach (GTK_GRID (grid_um),lab_e, 0, 3, 2, 1);
sw_um_dc = gtk_switch_new();
gtk_grid_attach (GTK_GRID (grid_um),sw_um_dc, 2, 3, 2, 1);
lab_e = gtk_label_new("Action:");
gtk_grid_attach (GTK_GRID (grid_um),lab_e, 4, 3, 2, 1);
com_um_dca = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_dca), NULL, "Open File");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_dca), NULL, "Open Link");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_dca), NULL, "Open Folder");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_dca), NULL, "Copy URL");
gtk_grid_attach (GTK_GRID (grid_um),com_um_dca, 6, 3, 2, 1);
grid_uq = gtk_grid_new ();
gtk_box_pack_start(GTK_BOX(vbox_nb_uq), grid_uq , FALSE, FALSE, 0);
lab_e = gtk_label_new("Window Position:");
gtk_grid_attach (GTK_GRID (grid_uq),lab_e, 0, 0, 2, 1);
com_uq_wp = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_uq_wp), NULL, "Default");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_uq_wp), NULL, "Center");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_uq_wp), NULL, "Mouse");
gtk_grid_attach (GTK_GRID (grid_uq),com_uq_wp, 2, 0, 2, 1);
lab_e = gtk_label_new("Window Size:");
gtk_grid_attach (GTK_GRID (grid_uq),lab_e, 4, 0, 2, 1);
hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0);
gtk_grid_attach (GTK_GRID (grid_uq),hbox_um_s, 6, 0, 4, 1);
entry_uq_win_w = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_uq_win_w);
gtk_entry_set_width_chars(GTK_ENTRY(entry_uq_win_w),5);
lab_e = gtk_label_new("X");
gtk_container_add(GTK_CONTAINER(hbox_um_s), lab_e);
entry_uq_win_h = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_uq_win_h);
gtk_entry_set_width_chars(GTK_ENTRY(entry_uq_win_h),5);
hbox_set_m = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0);
gtk_box_pack_end(GTK_BOX(vbox_set_m), hbox_set_m, FALSE, FALSE, 0);
but_set_reset = gtk_button_new_with_label("Reset Settings");
g_signal_connect(but_set_reset,"clicked",G_CALLBACK(settings_conf_default), NULL);
gtk_container_add(GTK_CONTAINER(hbox_set_m), but_set_reset);
but_set_close = gtk_button_new_with_label(" Close ");
g_signal_connect(but_set_close,"clicked",G_CALLBACK(settings_window_destroy), NULL);
gtk_box_pack_end(GTK_BOX(hbox_set_m),GTK_WIDGET(but_set_close),FALSE,FALSE,0);
but_set_save = gtk_button_new_with_label("Save & Close");
g_signal_connect(but_set_save,"clicked",G_CALLBACK(settings_conf_save), NULL);
gtk_box_pack_end(GTK_BOX(hbox_set_m),GTK_WIDGET(but_set_save),FALSE,FALSE,0);
settings_window_create_set_actives();
gtk_widget_show_all(win_set_main);
}
void keybinds_window_create (void) {
int i;
GtkWidget *vbox_kb_m, *hbox_kb_s, *hbox_kb_lay;
GtkWidget *but_kb_close, *but_kb_save, *but_kb_reset;
GtkWidget *lab_kb_e, *hbox_kb_bind[4], *entry_kb_test;
GtkWidget *vbox_kb_s1, *vbox_kb_s2, *hbox_kb_m;
win_kb_main = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win_kb_main), "Pomf it! - Keybinds Settings");
g_signal_connect(win_kb_main, "destroy", G_CALLBACK(keybinds_window_destroy), NULL);
gtk_container_set_border_width(GTK_CONTAINER(win_kb_main), 10);
gtk_window_resize(GTK_WINDOW(win_kb_main), 500, 200);
gtk_window_set_position(GTK_WINDOW(win_kb_main), GTK_WIN_POS_CENTER);
vbox_kb_m = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0);
gtk_container_add(GTK_CONTAINER(win_kb_main), vbox_kb_m);
hbox_kb_m = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0);
gtk_container_add(GTK_CONTAINER(vbox_kb_m), hbox_kb_m);
vbox_kb_s1 = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0);
gtk_container_add(GTK_CONTAINER(hbox_kb_m), vbox_kb_s1);
vbox_kb_s2 = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0);
gtk_container_add(GTK_CONTAINER(hbox_kb_m), vbox_kb_s2);
lab_kb_e = gtk_label_new("File Upload:");
gtk_box_pack_start (GTK_BOX(vbox_kb_s1), GTK_WIDGET(lab_kb_e), FALSE, FALSE, 5);
lab_kb_e = gtk_label_new("Capture Area & UP:");
gtk_box_pack_start (GTK_BOX(vbox_kb_s1), GTK_WIDGET(lab_kb_e), TRUE, FALSE, 5);
lab_kb_e = gtk_label_new("Capture Window & UP:");
gtk_box_pack_start (GTK_BOX(vbox_kb_s1), GTK_WIDGET(lab_kb_e), FALSE, FALSE, 5);
lab_kb_e = gtk_label_new("Capture Fullscreen & UP:");
gtk_box_pack_start (GTK_BOX(vbox_kb_s1), GTK_WIDGET(lab_kb_e), TRUE, FALSE, 5);
lab_kb_e = gtk_label_new("Capture Area:");
gtk_box_pack_start (GTK_BOX(vbox_kb_s1), GTK_WIDGET(lab_kb_e), FALSE, FALSE, 5);
lab_kb_e = gtk_label_new("Capture Window:");
gtk_box_pack_start (GTK_BOX(vbox_kb_s1), GTK_WIDGET(lab_kb_e), TRUE, FALSE, 5);
lab_kb_e = gtk_label_new("Capture Fullscreen:");
gtk_box_pack_start (GTK_BOX(vbox_kb_s1), GTK_WIDGET(lab_kb_e), FALSE, FALSE, 5);
lab_kb_e = gtk_label_new("Open URL(s):");
gtk_box_pack_start (GTK_BOX(vbox_kb_s1), GTK_WIDGET(lab_kb_e), TRUE, FALSE, 5);
for ( i = 0 ; i < HOTKEY_COUNT ; ++i) {
hbox_kb_bind[i] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL ,4);
gtk_container_add (GTK_CONTAINER(vbox_kb_s2),hbox_kb_bind[i]);
com_kb_mod1[i] = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod1[i]), NULL, "");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod1[i]), NULL, "<CTRL>");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod1[i]), NULL, "<SHIFT>");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod1[i]), NULL, "<ALT>");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod1[i]), NULL, "<WIN>");
gtk_container_add(GTK_CONTAINER(hbox_kb_bind[i]), com_kb_mod1[i]);
com_kb_mod2[i] = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod2[i]), NULL, "");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod2[i]), NULL, "<CTRL>");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod2[i]), NULL, "<SHIFT>");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod2[i]), NULL, "<ALT>");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_mod2[i]), NULL, "<WIN>");
gtk_container_add(GTK_CONTAINER(hbox_kb_bind[i]), com_kb_mod2[i]);
com_kb_key[i] = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "!");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "\"");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "#");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "$");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "%");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "&");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "'");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "(");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, ")");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "*");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "+");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, ",");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "-");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, ".");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "/");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "0");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "1");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "2");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "3");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "4");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "5");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "6");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "7");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "8");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "9");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, ":");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, ";");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "<");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "=");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, ">");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "?");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "@");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "A");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "B");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "C");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "D");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "E");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "F");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "G");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "H");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "I");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "J");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "K");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "L");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "M");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "N");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "O");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "P");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "Q");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "R");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "S");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "T");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "U");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "V");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "W");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "X");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "Y");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "Z");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "[");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "\\");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "]");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "^");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "_");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_kb_key[i]), NULL, "`");
gtk_combo_box_set_active(GTK_COMBO_BOX(com_kb_key[i]), 0);
gtk_combo_box_set_wrap_width (GTK_COMBO_BOX(com_kb_key[i]), 8);
gtk_container_add(GTK_CONTAINER(hbox_kb_bind[i]), com_kb_key[i]);
sw_kb[i] = gtk_switch_new();
gtk_container_add(GTK_CONTAINER(hbox_kb_bind[i]), sw_kb[i]);
}
keybinds_window_create_set_actives();
hbox_kb_lay = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 5);
gtk_container_add(GTK_CONTAINER(vbox_kb_m), hbox_kb_lay);
lab_kb_e = gtk_label_new("Wait...What's my keyboard layout again ? ..");
gtk_box_pack_start (GTK_BOX(hbox_kb_lay), GTK_WIDGET(lab_kb_e), FALSE, FALSE, 5);
entry_kb_test = gtk_entry_new ();
gtk_container_add(GTK_CONTAINER(hbox_kb_lay), entry_kb_test);
hbox_kb_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0);
gtk_box_pack_end(GTK_BOX(vbox_kb_m), hbox_kb_s, FALSE, FALSE, 0);
but_kb_reset = gtk_button_new_with_label("Reset Settings");
g_signal_connect(but_kb_reset,"clicked",G_CALLBACK(keybinds_conf_default), NULL);
gtk_container_add(GTK_CONTAINER(hbox_kb_s), but_kb_reset);
but_kb_close = gtk_button_new_with_label(" Close ");
g_signal_connect(but_kb_close,"clicked",G_CALLBACK(keybinds_window_destroy), NULL);
gtk_box_pack_end(GTK_BOX(hbox_kb_s),GTK_WIDGET(but_kb_close),FALSE,FALSE,0);
but_kb_save = gtk_button_new_with_label("Save & Close");
g_signal_connect(but_kb_save,"clicked",G_CALLBACK(keybinds_conf_save), NULL);
gtk_box_pack_end(GTK_BOX(hbox_kb_s),GTK_WIDGET(but_kb_save),FALSE,FALSE,0);
gtk_widget_show_all(win_kb_main);
}
static GtkWidget* pocketvox_setup_get_gstreamer_grid(PocketvoxSetup *setup)
{
setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
PocketvoxSetupPrivate *priv = setup->priv;
GtkWidget *grid = gtk_grid_new();
GtkWidget* label_mode = gtk_label_new(_("Gstreamer source"));
GtkWidget* combo_mode = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo_mode), "Default", _("Default"));
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo_mode), "Alsa", _("Alsa"));
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo_mode), "Network", _("Network"));
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_mode), 0);
gtk_widget_set_tooltip_text(combo_mode, _("Set the source input"));
GtkWidget* label_mic = gtk_label_new(_("Mic"));
GtkWidget* entry_mic = gtk_entry_new();
gtk_widget_set_tooltip_text(entry_mic, _("Which microphone to use ?"));
GtkWidget* label_host = gtk_label_new(_("Host"));
GtkWidget* entry_host = gtk_entry_new();
gtk_widget_set_tooltip_text(entry_host, _("Choose the host"));
GtkWidget* label_port = gtk_label_new(_("Port"));
GtkWidget* entry_port = gtk_entry_new();
gtk_widget_set_tooltip_text(entry_port, _("Choose the port"));
g_settings_bind(priv->settings, "source", combo_mode, "active-id", G_SETTINGS_BIND_DEFAULT);
g_settings_bind(priv->settings, "device", entry_mic, "text", G_SETTINGS_BIND_DEFAULT);
g_settings_bind(priv->settings, "port", entry_port, "text", G_SETTINGS_BIND_DEFAULT);
g_settings_bind(priv->settings, "host", entry_host, "text", G_SETTINGS_BIND_DEFAULT);
g_signal_connect_swapped(combo_mode, "changed", G_CALLBACK(pocketvox_setup_combo_manage_entry_mic), entry_mic);
g_signal_connect_swapped(combo_mode, "changed", G_CALLBACK(pocketvox_setup_combo_manage_entry_mic), label_mic);
g_signal_connect_swapped(combo_mode, "changed", G_CALLBACK(pocketvox_setup_combo_manage_network), label_host);
g_signal_connect_swapped(combo_mode, "changed", G_CALLBACK(pocketvox_setup_combo_manage_network), entry_host);
g_signal_connect_swapped(combo_mode, "changed", G_CALLBACK(pocketvox_setup_combo_manage_network), label_port);
g_signal_connect_swapped(combo_mode, "changed", G_CALLBACK(pocketvox_setup_combo_manage_network), entry_port);
gtk_misc_set_alignment(GTK_MISC(label_mode), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(label_mic), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(label_port), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(label_host), 0.0, 0.5);
gtk_widget_set_hexpand(label_mode, TRUE);
gtk_widget_set_hexpand(label_mic, TRUE);
gtk_widget_set_hexpand(label_port, TRUE);
gtk_widget_set_hexpand(label_host, TRUE);
gtk_grid_attach(GTK_GRID(grid), label_mode, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), combo_mode, 1, 0, 2, 1);
gtk_grid_attach(GTK_GRID(grid), label_mic, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), entry_mic, 1, 1, 2, 1);
gtk_grid_attach(GTK_GRID(grid), label_host, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid), entry_host, 1, 2, 2, 1);
gtk_grid_attach(GTK_GRID(grid), label_port, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(grid), entry_port, 1, 3, 2, 1);
gtk_widget_show_all(grid);
pocketvox_setup_combo_manage_entry_mic(entry_mic, combo_mode);
pocketvox_setup_combo_manage_entry_mic(label_mic, combo_mode);
pocketvox_setup_combo_manage_network(label_host, combo_mode);
pocketvox_setup_combo_manage_network(entry_host, combo_mode);
pocketvox_setup_combo_manage_network(label_port, combo_mode);
pocketvox_setup_combo_manage_network(entry_port, combo_mode);
return grid;
}
GTKGeomWindow::GTKGeomWindow( class GTKPlotter &plotter,
const Geometry &geom,
const EpotField *epot,
const EpotEfield *efield,
const MeshScalarField *scharge,
const MeshScalarField *tdens,
const VectorField *bfield,
const ParticleDataBase *pdb )
: GTKFrameWindow(plotter), _geomplot(_frame,geom),
_geom(geom), _epot(epot), _efield(efield), _scharge(scharge), _tdens(tdens),
_bfield(bfield), _pdb(pdb), _tool(TOOL_UNKNOWN), _prefdata(NULL)
{
//std::cout << "GTKGeomWindow constructor\n";
// Setup GeomPlot
_geomplot.set_epot( epot );
_geomplot.set_scharge( scharge );
_geomplot.set_trajdens( tdens );
_geomplot.set_bfield( bfield );
_geomplot.set_efield( efield );
_geomplot.set_particle_database( pdb );
// Set window title
gtk_window_set_title( GTK_WINDOW(_window), "Simulation geometry" );
// Adding geometry window specific tools to toolbar
// Creating separator
GtkToolItem *toolitem = gtk_separator_tool_item_new();
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
// Creating "Particle diagnostics" button
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_inline( -1, icon_particle_diag_inline, FALSE, NULL );
GtkWidget *icon = gtk_image_new_from_pixbuf( pixbuf );
toolitem = gtk_radio_tool_button_new_from_widget( GTK_RADIO_TOOL_BUTTON(_radioitem) );
gtk_tool_button_set_label( GTK_TOOL_BUTTON(toolitem), "Particle diagnostics" );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Particle diagnostics" );
#endif
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(toolitem), icon );
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
g_signal_connect( G_OBJECT(toolitem), "toggled",
G_CALLBACK(menuitem_tool_change_signal),
(gpointer)this );
// Creating "Field diagnostics" button
pixbuf = gdk_pixbuf_new_from_inline( -1, icon_field_diag_inline, FALSE, NULL );
icon = gtk_image_new_from_pixbuf( pixbuf );
toolitem = gtk_radio_tool_button_new_from_widget( GTK_RADIO_TOOL_BUTTON(_radioitem) );
gtk_tool_button_set_label( GTK_TOOL_BUTTON(toolitem), "Field diagnostics" );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Field diagnostics" );
#endif
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(toolitem), icon );
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
g_signal_connect( G_OBJECT(toolitem), "toggled",
G_CALLBACK(menuitem_tool_change_signal),
(gpointer)this );
// Creating "Geom 3D" button
pixbuf = gdk_pixbuf_new_from_inline( -1, icon_geom3d_inline, FALSE, NULL );
icon = gtk_image_new_from_pixbuf( pixbuf );
toolitem = gtk_tool_button_new( icon, "3D geometry view" );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "3D geometry view" );
#endif
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
if( _geom.geom_mode() != MODE_3D || !_geom.surface_built() )
gtk_widget_set_sensitive( GTK_WIDGET(toolitem), FALSE );
g_signal_connect( G_OBJECT(toolitem), "clicked",
G_CALLBACK(menuitem_geom3d_signal),
(gpointer)this );
// Creating separator
toolitem = gtk_separator_tool_item_new();
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
// Creating view combobox and level spinbutton
//_combobox = gtk_combo_box_new_text();
_combobox = gtk_combo_box_text_new();
if( geom.geom_mode() == MODE_3D ) {
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XY" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XZ" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YX" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YZ" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "ZX" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "ZY" );
/*
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "XY" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "XZ" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "YX" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "YZ" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "ZX" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "ZY" );
*/
gtk_combo_box_set_active( GTK_COMBO_BOX(_combobox), 0 );
_spinbutton = gtk_spin_button_new_with_range( 0, geom.size(2)-1, 1 );
gtk_spin_button_set_value( GTK_SPIN_BUTTON(_spinbutton), geom.size(2)/2 );
_geomplot.set_view( VIEW_XY, geom.size(2)/2 );
} else {
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XY" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YX" );
gtk_combo_box_set_active( GTK_COMBO_BOX(_combobox), 0 );
_spinbutton = gtk_spin_button_new_with_range( 0, 0, 1 );
gtk_spin_button_set_value( GTK_SPIN_BUTTON(_spinbutton), 0 );
}
toolitem = gtk_tool_item_new();
gtk_container_add( GTK_CONTAINER(toolitem), _combobox );
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Select view direction" );
#endif
gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_spinbutton), 0 );
toolitem = gtk_tool_item_new();
gtk_container_add( GTK_CONTAINER(toolitem), _spinbutton );
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Select view level" );
#endif
g_signal_connect( G_OBJECT(_combobox), "changed",
G_CALLBACK(combobox_signal),
(gpointer)this );
g_signal_connect( G_OBJECT(_spinbutton), "value-changed",
G_CALLBACK(spinbutton_signal),
(gpointer)this );
// Drawing area signals
g_signal_connect( G_OBJECT(_darea), "button_press_event",
G_CALLBACK(darea_button_signal2),
(gpointer)this );
g_signal_connect( G_OBJECT(_darea), "button_release_event",
G_CALLBACK(darea_button_signal2),
(gpointer)this );
g_signal_connect( G_OBJECT(_darea), "motion_notify_event",
G_CALLBACK(darea_motion_signal2),
(gpointer)this );
update_view();
show();
}
/* modem */
static ModemPlugin * _debug_init(ModemPluginHelper * helper)
{
Debug * debug;
GtkSizeGroup * group;
GtkWidget * vbox;
GtkWidget * notebook;
GtkWidget * hbox;
GtkWidget * widget;
if((debug = object_new(sizeof(*debug))) == NULL)
return NULL;
debug->helper = helper;
debug->source = 0;
memset(&debug->event_call, 0, sizeof(debug->event_call));
memset(&debug->event_contact, 0, sizeof(debug->event_contact));
memset(&debug->event_message, 0, sizeof(debug->event_message));
/* window */
debug->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(debug->window), 4);
gtk_window_set_title(GTK_WINDOW(debug->window), "Debug");
g_signal_connect_swapped(G_OBJECT(debug->window), "delete-event",
G_CALLBACK(_debug_on_closex), debug);
group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
notebook = gtk_notebook_new();
/* status */
vbox = gtk_vbox_new(FALSE, 4);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_label_new("Status:");
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
debug->status = gtk_label_new("initialized");
gtk_misc_set_alignment(GTK_MISC(debug->status), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), debug->status, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
/* operator */
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_label_new("Operator: ");
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
debug->operator = gtk_entry_new();
g_signal_connect_swapped(debug->operator, "activate", G_CALLBACK(
_debug_on_operator_set), debug);
gtk_box_pack_start(GTK_BOX(hbox), debug->operator, TRUE, TRUE, 0);
widget = gtk_button_new_from_stock(GTK_STOCK_APPLY);
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_debug_on_operator_set), debug);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_label_new(NULL);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
debug->roaming = gtk_check_button_new_with_mnemonic("_Roaming");
gtk_box_pack_start(GTK_BOX(hbox), debug->roaming, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
gtk_label_new("Status"));
/* calls */
vbox = gtk_vbox_new(FALSE, 4);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_label_new("Number: ");
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
debug->ca_number = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), debug->ca_number, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_label_new("Direction: ");
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
#if GTK_CHECK_VERSION(3, 0, 0)
debug->ca_direction = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->ca_direction), NULL,
"Incoming");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->ca_direction), NULL,
"Outgoing");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->ca_direction), NULL,
"Established");
#else
debug->ca_direction = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->ca_direction),
"Incoming");
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->ca_direction),
"Outgoing");
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->ca_direction),
"Established");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(debug->ca_direction), 1);
gtk_box_pack_start(GTK_BOX(hbox), debug->ca_direction, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_button_new_with_label("Call");
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_icon_name(
"call-start", GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(G_OBJECT(widget), "clicked", G_CALLBACK(
_debug_on_call), debug);
gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
gtk_label_new("Calls"));
/* messages */
vbox = gtk_vbox_new(FALSE, 4);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_label_new("Number: ");
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
debug->me_number = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), debug->me_number, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_label_new("Folder: ");
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
#if GTK_CHECK_VERSION(3, 0, 0)
debug->me_folder = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->me_folder), NULL,
"Unknown");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->me_folder), NULL,
"Inbox");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->me_folder), NULL,
"Sent");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->me_folder), NULL,
"Drafts");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(debug->me_folder), NULL,
"Trash");
#else
debug->me_folder = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->me_folder), "Unknown");
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->me_folder), "Inbox");
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->me_folder), "Sent");
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->me_folder), "Drafts");
gtk_combo_box_append_text(GTK_COMBO_BOX(debug->me_folder), "Trash");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(debug->me_folder), 1);
gtk_box_pack_start(GTK_BOX(hbox), debug->me_folder, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget),
GTK_SHADOW_ETCHED_IN);
debug->me_message = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(widget), debug->me_message);
gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_button_new_with_label("Send");
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_icon_name(
"mail-send", GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(G_OBJECT(widget), "clicked", G_CALLBACK(
_debug_on_message_send), debug);
gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
gtk_label_new("Messages"));
/* notification */
vbox = gtk_vbox_new(FALSE, 4);
hbox = gtk_hbox_new(FALSE, 4);
widget = gtk_label_new("Notification: ");
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_size_group_add_widget(group, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
debug->notification = gtk_entry_new();
g_signal_connect_swapped(debug->notification, "activate", G_CALLBACK(
_debug_on_notification), debug);
gtk_box_pack_start(GTK_BOX(hbox), debug->notification, TRUE, TRUE, 0);
widget = gtk_button_new_with_label("Send");
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_icon_name(
"mail-send", GTK_ICON_SIZE_BUTTON));
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_debug_on_notification), debug);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
gtk_label_new("Notifications"));
gtk_container_add(GTK_CONTAINER(debug->window), notebook);
gtk_widget_show_all(debug->window);
return debug;
}
void create_alert_form(GtkWidget *widget, char* type) {
UNUSED(widget);
GtkWidget *windowAlertForm;
GtkWidget *compte_cat_list, *type_temps_list;
GtkWidget *montant_field;
GtkWidget *button_create_alert, *button_exit;
GtkWidget *grid;
windowAlertForm = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(windowAlertForm), "Creation d'alerte");
gtk_window_set_default_size(GTK_WINDOW(windowAlertForm), 400,400);
gtk_window_set_position(GTK_WINDOW(windowAlertForm), GTK_WIN_POS_CENTER);
grid = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(windowAlertForm), grid);
montant_field = gtk_entry_new();
compte_cat_list = gtk_combo_box_text_new();
char **listCompteCat;
if (strcmp(type, "max_cat") == 0) {
listCompteCat = bdd_get_categorie();
gtk_entry_set_placeholder_text(GTK_ENTRY(montant_field), "maximum autorise");
} else if (strcmp(type, "min_account") == 0) {
listCompteCat = bdd_get_libelle_account();
gtk_entry_set_placeholder_text(GTK_ENTRY(montant_field), "minimum autorise");
}
while(*listCompteCat != NULL) {
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(compte_cat_list), NULL, *listCompteCat);
listCompteCat++;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(compte_cat_list), 0);
type_temps_list = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(type_temps_list), NULL, "monthly");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(type_temps_list), NULL, "yearly");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(type_temps_list), NULL, "total");
gtk_combo_box_set_active(GTK_COMBO_BOX(type_temps_list), 0);
//linking GtkWidgets to entries to send to create_alert function
alert_entry_t *entries = (alert_entry_t*) malloc(sizeof(alert_entry_t));
strcpy(entries->type, type);
entries->type_temps = type_temps_list;
entries->compte_cat = compte_cat_list;
entries->montant = montant_field;
button_create_alert = gtk_button_new_with_label("Create Alert");
g_signal_connect(GTK_BUTTON(button_create_alert), "clicked", G_CALLBACK(create_alert), entries);
button_exit = gtk_button_new_with_label("Exit form");
g_signal_connect(GTK_BUTTON(button_exit), "clicked", G_CALLBACK(close_window), windowAlertForm);
gtk_grid_attach(GTK_GRID(grid), compte_cat_list, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), type_temps_list, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), montant_field, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid), button_create_alert, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(grid), button_exit, 0, 4, 1, 1);
gtk_widget_show_all(windowAlertForm);
}
/** \brief Create DIGIMAX widget
*
* \param[in] parent parent widget
*
* \return GtkGrid
*/
GtkWidget *digimax_widget_create(GtkWidget *parent)
{
GtkWidget *grid;
GtkWidget *label;
GtkWidget *digimax;
GtkWidget *combo;
unsigned int base;
int current;
int index;
char text[256];
char id_str[80];
grid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(grid), 16);
gtk_grid_set_row_spacing(GTK_GRID(grid), 8);
digimax = vice_gtk3_resource_check_button_new("DIGIMAX", "Enable DIGIMAX");
gtk_grid_attach(GTK_GRID(grid), digimax, 0, 0, 1, 1);
resources_get_int("DIGIMAXbase", ¤t);
index = 0;
combo = gtk_combo_box_text_new();
if (machine_class != VICE_MACHINE_VIC20) {
for (base = 0xde00; base < 0xe000; base += 0x20) {
g_snprintf(text, 256, "$%04X", base);
g_snprintf(id_str, 80, "%u", base);
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo), id_str, text);
if (current == base) {
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), index);
}
index++;
}
} else {
for (base = 0x9800; base < 0x9900; base += 0x20) {
g_snprintf(text, 256, "$%04X", base);
g_snprintf(id_str, 80, "%u", base);
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo), id_str, text);
if (current == base) {
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), index);
}
index++;
}
for (base = 0x9c00; base < 0x9d00; base += 0x20) {
g_snprintf(text, 256, "$%04X", base);
g_snprintf(id_str, 80, "%u", base);
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo), id_str, text);
if (current == base) {
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), index);
}
index++;
}
}
g_signal_connect(combo, "changed", G_CALLBACK(on_combo_changed), NULL);
g_signal_connect(digimax, "toggled", G_CALLBACK(on_digimax_toggled),
(gpointer)combo);
label = gtk_label_new("DigiMAX base");
gtk_grid_attach(GTK_GRID(grid), label, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), combo, 1, 1, 1, 1);
on_digimax_toggled(digimax, combo);
gtk_widget_show_all(grid);
return grid;
}
