GtkWidget *
do_popover (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
GtkWidget *popover, *box, *widget;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 24);
gtk_container_set_border_width (GTK_CONTAINER (box), 24);
gtk_container_add (GTK_CONTAINER (window), box);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
widget = gtk_toggle_button_new_with_label ("Button");
popover = create_popover (widget,
gtk_label_new ("This popover does not grab input"),
GTK_POS_TOP);
gtk_popover_set_modal (GTK_POPOVER (popover), FALSE);
g_signal_connect (widget, "toggled",
G_CALLBACK (toggle_changed_cb), popover);
gtk_container_add (GTK_CONTAINER (box), widget);
widget = gtk_entry_new ();
popover = create_complex_popover (widget, GTK_POS_TOP);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_PRIMARY, "edit-find");
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "edit-clear");
g_signal_connect (widget, "icon-press",
G_CALLBACK (entry_icon_press_cb), popover);
g_signal_connect (widget, "size-allocate",
G_CALLBACK (entry_size_allocate_cb), popover);
gtk_container_add (GTK_CONTAINER (box), widget);
widget = gtk_calendar_new ();
g_signal_connect (widget, "day-selected",
G_CALLBACK (day_selected_cb), NULL);
gtk_container_add (GTK_CONTAINER (box), widget);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
void gtkhash_properties_list_check_digests(struct page_s *page)
{
const char *check = gtk_entry_get_text(page->entry_check);
const char *icon = NULL;
GtkTreeModel *model = gtkhash_properties_list_get_model(page);
GtkTreeIter iter;
if (*check && gtk_tree_model_get_iter_first(model, &iter)) {
do {
char *digest = NULL;;
gtk_tree_model_get(model, &iter, COL_DIGEST, &digest, -1);
if (g_ascii_strcasecmp(check, digest) == 0) {
// FIXME: find a real alternative for GTK_STOCK_YES
icon = "gtk-yes";
break;
}
g_free(digest);
} while (gtk_tree_model_iter_next(model, &iter));
}
gtk_entry_set_icon_from_icon_name(page->entry_check,
GTK_ENTRY_ICON_SECONDARY, icon);
}
static gboolean
presence_chooser_flash_timeout_cb (EmpathyPresenceChooser *chooser)
{
EmpathyPresenceChooserPriv *priv;
TpConnectionPresenceType state;
static gboolean on = FALSE;
GtkWidget *entry;
priv = GET_PRIV (chooser);
if (on) {
state = priv->flash_state_1;
}
else {
state = priv->flash_state_2;
}
entry = gtk_bin_get_child (GTK_BIN (chooser));
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
empathy_icon_name_for_presence (state));
on = !on;
return TRUE;
}
static void
open_cb (GtkWidget *w, gpointer d)
{
GtkWidget *dlg, *cnt, *lbl, *entry;
dlg = gtk_dialog_new_with_buttons (_("Open URI"),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gtk_window_set_default_size (GTK_WINDOW (dlg), 350, -1);
cnt = gtk_dialog_get_content_area (GTK_DIALOG (dlg));
lbl = gtk_label_new (_("Enter URI or file name:"));
gtk_label_set_xalign (GTK_LABEL (lbl), 0);
gtk_widget_show (lbl);
gtk_box_pack_start (GTK_BOX (cnt), lbl, TRUE, FALSE, 2);
entry = gtk_entry_new ();
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, "gtk-directory");
gtk_widget_show (entry);
gtk_box_pack_start (GTK_BOX (cnt), entry, TRUE, FALSE, 2);
g_signal_connect (G_OBJECT (entry), "icon-press", G_CALLBACK (select_file_cb), NULL);
g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (do_open_cb), dlg);
if (gtk_dialog_run (GTK_DIALOG (dlg)) == GTK_RESPONSE_ACCEPT)
load_uri (gtk_entry_get_text (GTK_ENTRY (entry)));
gtk_widget_destroy (dlg);
}
void
set_entry_generation_icon (GtkEntry *entry)
{
g_object_set (entry, "caps-lock-warning", FALSE, NULL);
gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "system-run-symbolic");
gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, TRUE);
}
void
set_entry_validation_checkmark (GtkEntry *entry)
{
g_object_set (entry, "caps-lock-warning", FALSE, NULL);
gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "object-select-symbolic");
gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, FALSE);
}
/*
* entry_check_content_mask:
* @entry: the entry for which to check the mask
* @user_data: user data set when the signal was connected
*
* Display an icon in the entry if the current text contains an invalid mask.
*/
static void
entry_check_content_mask (GtkEntry *entry, gpointer user_data)
{
gchar *tmp = NULL;
gchar *mask = NULL;
g_return_if_fail (entry != NULL);
mask = g_strdup (gtk_entry_get_text (entry));
if (et_str_empty (mask))
goto Bad_Mask;
while (mask)
{
if ( (tmp=strrchr(mask,'%'))==NULL )
{
/* There is no more code. */
/* No code in mask is accepted. */
goto Good_Mask;
}
if (strlen(tmp)>1 && (tmp[1]=='t' || tmp[1]=='a' || tmp[1]=='b' || tmp[1]=='y' ||
tmp[1]=='g' || tmp[1]=='n' || tmp[1]=='l' || tmp[1]=='c' || tmp[1]=='i'))
{
/* The code is valid. */
/* No separator is accepted. */
*(mask+strlen(mask)-strlen(tmp)) = '\0';
}else
{
goto Bad_Mask;
}
}
Bad_Mask:
g_free(mask);
gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY,
"emblem-unreadable");
gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY,
_("Invalid scanner mask"));
return;
Good_Mask:
g_free(mask);
gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY,
NULL);
return;
}
static gboolean
dict_check_word_timeout_cb (IdeEditorSpellWidget *self)
{
const gchar *word;
g_autofree gchar *tooltip = NULL;
gchar *icon_name;
gboolean valid = FALSE;
g_assert (IDE_IS_EDITOR_SPELL_WIDGET (self));
self->dict_check_word_state = CHECK_WORD_CHECKING;
word = gtk_entry_get_text (GTK_ENTRY (self->dict_word_entry));
if (!ide_str_empty0 (word))
{
if (ide_editor_spell_dict_personal_contains (self->dict, word))
gtk_widget_set_tooltip_text (self->dict_word_entry, _("This word is already in the personal dictionary"));
else if (gspell_checker_check_word (self->checker, word, -1, NULL))
{
tooltip = g_strdup_printf (_("This word is already in the %s dictionary"), gspell_language_get_name (self->spellchecker_language));
gtk_widget_set_tooltip_text (self->dict_word_entry, tooltip);
}
else
{
valid = TRUE;
gtk_widget_set_tooltip_text (self->dict_word_entry, NULL);
}
icon_name = valid ? "" : "dialog-warning-symbolic";
}
else
icon_name = "";
gtk_widget_set_sensitive (GTK_WIDGET (self->dict_add_button), valid);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->dict_word_entry),
GTK_ENTRY_ICON_SECONDARY,
icon_name);
self->dict_check_word_state = CHECK_WORD_NONE;
self->dict_check_word_timeout_id = 0;
if (self->is_dict_check_word_invalid == TRUE)
{
self->dict_check_word_timeout_id = g_timeout_add_full (G_PRIORITY_DEFAULT,
DICT_CHECK_WORD_INTERVAL_MIN,
(GSourceFunc)dict_check_word_timeout_cb,
self,
NULL);
self->dict_check_word_state = CHECK_WORD_IDLE;
self->is_dict_check_word_invalid = FALSE;
}
return G_SOURCE_REMOVE;
}
static gboolean
validate_entry (GtkEntry *entry, const gchar *str)
{
gint argcp = 0;
gchar **argvp;
gboolean ret = FALSE;
if (g_shell_parse_argv (str, &argcp, &argvp, NULL)) {
if (argcp > 0) {
gchar *path_exec = g_find_program_in_path (argvp[0]);
if (path_exec) {
ret = TRUE;
} else {
if (!g_file_test (str, G_FILE_TEST_IS_DIR) &&
g_file_test (str, G_FILE_TEST_IS_EXECUTABLE)) {
ret = TRUE;
}
}
g_free (path_exec);
}
}
g_strfreev (argvp);
if (ret) {
gtk_entry_set_icon_from_icon_name (entry,
GTK_ENTRY_ICON_SECONDARY,
"ok");
gtk_entry_set_icon_tooltip_text (entry,
GTK_ENTRY_ICON_SECONDARY,
_("Valid"));
} else {
gtk_entry_set_icon_from_icon_name (entry,
GTK_ENTRY_ICON_SECONDARY,
"stop");
gtk_entry_set_icon_tooltip_text (entry,
GTK_ENTRY_ICON_SECONDARY,
_("Not a valid executable. Spaces in the file path must be escaped with backslash (\\)."));
}
return ret;
}
static void
presence_chooser_set_favorite_icon (EmpathyPresenceChooser *self)
{
GtkWidget *entry;
PresenceChooserEntryType type;
entry = gtk_bin_get_child (GTK_BIN (self));
type = presence_chooser_get_entry_type (self);
if (type == ENTRY_TYPE_CUSTOM || type == ENTRY_TYPE_SAVED) {
if (presence_chooser_is_preset (self)) {
/* saved entries can be removed from the list */
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
"empathy-starred");
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
_("Click to remove this status as a favorite"));
}
else {
/* custom entries can be favorited */
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
"empathy-unstarred");
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
_("Click to make this status a favorite"));
}
}
else {
/* built-in entries cannot be favorited */
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
NULL);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
NULL);
}
}
void
_gtk_entry_use_as_password_entry (GtkEntry *entry)
{
gtk_entry_set_visibility (entry, FALSE);
gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "security-medium-symbolic");
gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, TRUE);
gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY, _("Change password visibility"));
g_signal_connect (entry,
"icon-press",
G_CALLBACK (password_entry_icon_press_cb),
NULL);
}
static void
custom_command_entry_changed_cb (GtkEntry *entry)
{
const char *command;
gs_free_error GError *error = NULL;
command = gtk_entry_get_text (entry);
if (command[0] == '\0' ||
g_shell_parse_argv (command, NULL, NULL, &error))
{
gtk_entry_set_icon_from_icon_name (entry, GTK_PACK_END, NULL);
}
else
{
gs_free char *tooltip;
gtk_entry_set_icon_from_icon_name (entry, GTK_PACK_END, "dialog-warning");
tooltip = g_strdup_printf (_("Error parsing command: %s"), error->message);
gtk_entry_set_icon_tooltip_text (entry, GTK_PACK_END, tooltip);
}
}
static gboolean
check_word_timeout_cb (IdeEditorSpellWidget *self)
{
const gchar *word;
g_autoptr(GError) error = NULL;
gchar *icon_name;
gboolean ret = TRUE;
g_assert (IDE_IS_EDITOR_SPELL_WIDGET (self));
self->check_word_state = CHECK_WORD_CHECKING;
word = gtk_entry_get_text (self->word_entry);
if (!ide_str_empty0 (word))
{
/* FIXME: suggestions can give a multiple-words suggestion
* that failed to the checkword test, ex: auto tools
*/
ret = gspell_checker_check_word (self->checker, word, -1, &error);
if (error != NULL)
{
g_message ("check error:%s\n", error->message);
}
icon_name = ret ? "" : "dialog-warning-symbolic";
}
else
icon_name = "";
gtk_entry_set_icon_from_icon_name (self->word_entry,
GTK_ENTRY_ICON_SECONDARY,
icon_name);
self->check_word_state = CHECK_WORD_NONE;
self->is_word_entry_valid = ret;
self->check_word_timeout_id = 0;
if (self->is_check_word_invalid == TRUE)
{
self->check_word_timeout_id = g_timeout_add_full (G_PRIORITY_DEFAULT,
CHECK_WORD_INTERVAL_MIN,
(GSourceFunc)check_word_timeout_cb,
self,
NULL);
self->check_word_state = CHECK_WORD_IDLE;
self->is_check_word_invalid = FALSE;
}
return G_SOURCE_REMOVE;
}
static void
custom_entry_changed_cb (GtkEditable *entry, gpointer user_data)
{
NemoMimeApplicationChooser *chooser = user_data;
const gchar *entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
gboolean empty = g_strcmp0 (entry_text, "") == 0;
if (!empty && validate_entry (GTK_ENTRY (entry), entry_text)) {
GAppInfo *default_app;
gchar *cl = g_strdup_printf ("%s", entry_text);
GAppInfo *info = g_app_info_create_from_commandline (cl, get_nice_name (cl),
G_APP_INFO_CREATE_NONE, NULL);
default_app = g_app_info_get_default_for_type (chooser->details->content_type, FALSE);
gtk_widget_set_sensitive (chooser->details->set_as_default_button,
!g_app_info_equal (info, default_app));
gtk_widget_set_sensitive (chooser->details->add_button,
app_info_can_add (info, chooser->details->content_type));
g_object_unref (default_app);
if (chooser->details->custom_info != NULL) {
g_object_unref (chooser->details->custom_info);
chooser->details->custom_info = NULL;
}
chooser->details->custom_info = info;
} else {
if (chooser->details->custom_info != NULL) {
g_object_unref (chooser->details->custom_info);
chooser->details->custom_info = NULL;
}
if (empty) {
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
NULL);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
NULL);
}
gtk_widget_set_sensitive (chooser->details->set_as_default_button, FALSE);
gtk_widget_set_sensitive (chooser->details->add_button, FALSE);
}
}
static void
change_password_storage_icon (GtkWidget *passwd_entry, MenuItem item)
{
const char *old_pwd;
gboolean ask_mode;
g_return_if_fail (item >= 0 && item <= ITEM_STORAGE_MAX);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (passwd_entry),
GTK_ENTRY_ICON_SECONDARY,
icon_name_table[item]);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (passwd_entry),
GTK_ENTRY_ICON_SECONDARY,
gettext (icon_desc_table[item]));
/* We want to make entry insensitive when ITEM_STORAGE_ASK is selected
* Unfortunately, making GtkEntry insensitive will also make the icon
* insensitive, which prevents user from reverting the action.
* Let's workaround that by disabling focus for entry instead of
* sensitivity change.
*/
ask_mode = !!g_object_get_data (G_OBJECT (passwd_entry), ASK_MODE_TAG);
if ( (item == ITEM_STORAGE_ASK && !ask_mode)
|| item == ITEM_STORAGE_UNUSED) {
/* Store the old password */
old_pwd = gtk_entry_get_text (GTK_ENTRY (passwd_entry));
if (old_pwd && *old_pwd)
g_object_set_data_full (G_OBJECT (passwd_entry), "password-old",
g_strdup (old_pwd), g_free_str0);
gtk_entry_set_text (GTK_ENTRY (passwd_entry), "");
if (gtk_widget_is_focus (passwd_entry))
gtk_widget_child_focus ((gtk_widget_get_toplevel (passwd_entry)), GTK_DIR_TAB_BACKWARD);
gtk_widget_set_can_focus (passwd_entry, FALSE);
} else {
/* Set the old password to the entry */
old_pwd = g_object_get_data (G_OBJECT (passwd_entry), "password-old");
if (old_pwd && *old_pwd)
gtk_entry_set_text (GTK_ENTRY (passwd_entry), old_pwd);
g_object_set_data (G_OBJECT (passwd_entry), "password-old", NULL);
if (!gtk_widget_get_can_focus (passwd_entry)) {
gtk_widget_set_can_focus (passwd_entry, TRUE);
gtk_widget_grab_focus (passwd_entry);
}
}
}
static void
presence_chooser_flash_stop (EmpathyPresenceChooser *chooser,
TpConnectionPresenceType state)
{
EmpathyPresenceChooserPriv *priv = GET_PRIV (chooser);
GtkWidget *entry;
if (priv->flash_timeout_id) {
g_source_remove (priv->flash_timeout_id);
priv->flash_timeout_id = 0;
}
entry = gtk_bin_get_child (GTK_BIN (chooser));
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
empathy_icon_name_for_presence (state));
}
static void
xmr_search_box_init(XmrSearchBox *box)
{
XmrSearchBoxPrivate *priv;
GtkWidget *vbox;
priv = box->priv = G_TYPE_INSTANCE_GET_PRIVATE(box, XMR_TYPE_SEARCH_BOX, XmrSearchBoxPrivate);
priv->parent = NULL;
priv->need_to_show = FALSE;
priv->thread = NULL;
priv->chooser = XMR_CHOOSER(xmr_chooser_new(_("Artist Radio"), GTK_ORIENTATION_VERTICAL));
priv->event_queue = g_async_queue_new();
priv->event_idle_id = 0;
priv->progress_idle_id = 0;
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
gtk_container_add(GTK_CONTAINER(box), vbox);
priv->entry_box = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), priv->entry_box, TRUE, TRUE, 0);
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(priv->entry_box), GTK_ENTRY_ICON_SECONDARY, "edit-find");
gtk_entry_set_placeholder_text(GTK_ENTRY(priv->entry_box), _("Enter artist name..."));
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(box), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(box), TRUE);
gtk_window_set_title(GTK_WINDOW(box), _("Search Artist Radio"));
gtk_widget_set_size_request(GTK_WIDGET(box), 350, 45);
gtk_window_set_decorated(GTK_WINDOW(priv->chooser), FALSE);
gtk_window_set_transient_for(GTK_WINDOW(priv->chooser), GTK_WINDOW(box));
gtk_window_set_resizable(GTK_WINDOW(priv->chooser), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(priv->chooser), 350, 200);
xmr_chooser_set_hide_on_clicked(priv->chooser, FALSE);
g_signal_connect(box, "delete-event", G_CALLBACK(on_delete), NULL);
g_signal_connect(box, "key-release-event", G_CALLBACK(on_key_release), NULL);
g_signal_connect(priv->entry_box, "activate", G_CALLBACK(on_search_box_activate), box);
g_signal_connect(priv->chooser, "widget-selected", G_CALLBACK(on_artist_clicked), box);
gtk_window_set_position(GTK_WINDOW(box), GTK_WIN_POS_CENTER);
gtk_widget_show_all(vbox);
}
void
set_entry_validation_error (GtkEntry *entry,
const gchar *text)
{
g_object_set (entry, "caps-lock-warning", FALSE, NULL);
gtk_entry_set_icon_from_icon_name (entry,
GTK_ENTRY_ICON_SECONDARY,
"dialog-warning-symbolic");
gtk_entry_set_icon_activatable (entry,
GTK_ENTRY_ICON_SECONDARY,
TRUE);
g_signal_connect (entry, "icon-release",
G_CALLBACK (icon_released), FALSE);
g_signal_connect (entry, "query-tooltip",
G_CALLBACK (query_tooltip), NULL);
g_object_set (entry, "has-tooltip", TRUE, NULL);
gtk_entry_set_icon_tooltip_text (entry,
GTK_ENTRY_ICON_SECONDARY,
text);
}
static void
gimp_combo_tag_entry_init (GimpComboTagEntry *entry)
{
entry->popup = NULL;
entry->normal_item_attr = NULL;
entry->selected_item_attr = NULL;
entry->insensitive_item_attr = NULL;
gtk_widget_add_events (GTK_WIDGET (entry),
GDK_BUTTON_PRESS_MASK |
GDK_POINTER_MOTION_MASK);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
"go-down");
g_signal_connect (entry, "icon-press",
G_CALLBACK (gimp_combo_tag_entry_icon_press),
NULL);
}
static void
rejilla_project_name_icon_update (RejillaProjectName *self,
RejillaTrackDataCfg *track)
{
GIcon *icon;
icon = rejilla_track_data_cfg_get_icon (track);
if (!icon) {
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self),
GTK_ENTRY_ICON_PRIMARY,
"media-optical");
return;
}
gtk_entry_set_icon_from_gicon (GTK_ENTRY (self),
GTK_ENTRY_ICON_PRIMARY,
icon);
g_object_unref (icon);
}
static void
ui_set_custom_state (EmpathyPresenceChooser *self,
TpConnectionPresenceType state,
const char *status)
{
EmpathyPresenceChooserPriv *priv = GET_PRIV (self);
GtkWidget *entry;
const char *icon_name;
entry = gtk_bin_get_child (GTK_BIN (self));
priv->block_set_editing++;
priv->block_changed++;
icon_name = empathy_icon_name_for_presence (state);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
icon_name);
gtk_entry_set_text (GTK_ENTRY (entry), status == NULL ? "" : status);
presence_chooser_set_favorite_icon (self);
priv->block_changed--;
priv->block_set_editing--;
}
static GtkWidget* pocketvox_setup_get_pocketsphinx_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 *entry_lm = gtk_entry_new();
GtkWidget *entry_acoustic = gtk_entry_new();
GtkWidget *entry_dictionnary = gtk_entry_new();
GtkWidget *et_lm = gtk_label_new("");
GtkWidget *et_dict = gtk_label_new("");
GtkWidget *et_hmm = gtk_label_new("");
gtk_label_set_markup(GTK_LABEL(et_lm), _("<b> Language model </b>"));
gtk_label_set_markup(GTK_LABEL(et_hmm), _("<b> Acoustic model </b>"));
gtk_label_set_markup(GTK_LABEL(et_dict),_("<b> Dictionnary </b>"));
gtk_misc_set_alignment(GTK_MISC(et_lm), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(et_dict), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(et_hmm), 0.0, 0.5);
gtk_widget_set_hexpand(et_lm, TRUE);
gtk_widget_set_hexpand(et_dict, TRUE);
gtk_widget_set_hexpand(et_hmm, TRUE);
gtk_widget_set_hexpand(entry_lm, TRUE);
gtk_widget_set_hexpand(entry_acoustic, TRUE);
gtk_widget_set_hexpand(entry_dictionnary, TRUE);
gtk_widget_set_tooltip_text(entry_lm, _("Set the pocketsphinx's language model"));
gtk_widget_set_tooltip_text(entry_acoustic, _("Set the pocketsphinx's acoustic model"));
gtk_widget_set_tooltip_text(entry_dictionnary, _("Set the pocketsphinx's dictionnary"));
gtk_widget_set_name(entry_lm, "lm");
gtk_widget_set_name(entry_dictionnary, "dict");
gtk_widget_set_name(entry_acoustic, "hmm");
gtk_entry_set_icon_from_icon_name (GTK_ENTRY(entry_lm), GTK_ENTRY_ICON_SECONDARY, "gtk-search");
g_signal_connect(entry_lm, "icon-press", G_CALLBACK(pocketvox_setup_search_dict), NULL);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY(entry_dictionnary), GTK_ENTRY_ICON_SECONDARY, "gtk-search");
g_signal_connect(entry_dictionnary, "icon-press", G_CALLBACK(pocketvox_setup_search_dict), NULL);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY(entry_acoustic), GTK_ENTRY_ICON_SECONDARY, "gtk-search");
g_signal_connect(entry_acoustic, "icon-press", G_CALLBACK(pocketvox_setup_search_dict), NULL);
g_settings_bind(priv->settings, "lm", entry_lm, "text", G_SETTINGS_BIND_DEFAULT);
g_settings_bind(priv->settings, "hmm", entry_acoustic, "text", G_SETTINGS_BIND_DEFAULT);
g_settings_bind(priv->settings, "dict", entry_dictionnary, "text", G_SETTINGS_BIND_DEFAULT);
gtk_grid_attach(GTK_GRID(grid), et_lm, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), entry_lm, 0, 1, 2, 1);
gtk_grid_attach(GTK_GRID(grid), et_hmm, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid), entry_acoustic, 0, 3, 2, 1);
gtk_grid_attach(GTK_GRID(grid), et_dict, 0, 4, 1, 1);
gtk_grid_attach(GTK_GRID(grid), entry_dictionnary, 0, 5, 2, 1);
gtk_widget_show_all(grid);
return grid;
}
static void
build_tab_view(AccountGeneralTab *view)
{
g_return_if_fail(IS_ACCOUNT_GENERAL_TAB(view));
AccountGeneralTabPrivate *priv = ACCOUNT_GENERAL_TAB_GET_PRIVATE(view);
int grid_row = 0;
GtkWidget *label = NULL;
/* separate pointers for each so that we reference them in the account changed callback */
GtkWidget *entry_alias = NULL;
GtkWidget *entry_username = NULL;
GtkWidget *entry_hostname = NULL;
GtkWidget *entry_password = NULL;
GtkWidget *entry_proxy = NULL;
GtkWidget *entry_voicemail = NULL;
GtkWidget *checkbutton_autoanswer = NULL;
GtkWidget *checkbutton_upnp = NULL;
GtkWidget *radiobutton_dtmf_rtp = NULL;
GtkWidget *radiobutton_dtmf_sip = NULL;
/* build account grid */
/* check if its ip2ip account */
const QByteArray& alias = priv->account->alias().toLocal8Bit();
if (strcmp(alias.constData(), "IP2IP") == 0) {
label = gtk_label_new("IP2IP");
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_account), label, 0, grid_row, 1, 1);
++grid_row;
} else {
/* account alias */
label = gtk_label_new(_("Alias"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_account), label, 0, grid_row, 1, 1);
entry_alias = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entry_alias), alias.constData());
gtk_widget_set_halign(entry_alias, GTK_ALIGN_START);
g_signal_connect(entry_alias, "changed", G_CALLBACK(account_alias_changed), view);
gtk_grid_attach(GTK_GRID(priv->grid_account), entry_alias, 1, grid_row, 1, 1);
++grid_row;
/* account type */
label = gtk_label_new(_("Type"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_account), label, 0, grid_row, 1, 1);
label = gtk_label_new("");
gtk_widget_set_halign(label, GTK_ALIGN_START);
switch (priv->account->protocol()) {
case Account::Protocol::SIP:
gtk_label_set_text(GTK_LABEL(label), "SIP");
break;
case Account::Protocol::IAX:
gtk_label_set_text(GTK_LABEL(label), "IAX");
break;
case Account::Protocol::RING:
gtk_label_set_text(GTK_LABEL(label), "RING");
break;
case Account::Protocol::COUNT__:
break;
}
gtk_grid_attach(GTK_GRID(priv->grid_account), label, 1, grid_row, 1, 1);
++grid_row;
}
if (priv->account->protocol() == Account::Protocol::RING) {
label = gtk_label_new("RingID");
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_account), label, 0, grid_row, 1, 1);
entry_username = gtk_entry_new();
gtk_entry_set_placeholder_text(GTK_ENTRY(entry_username), _("auto-generating..."));
gtk_entry_set_text(GTK_ENTRY(entry_username), priv->account->username().toLocal8Bit().constData());
g_object_set(G_OBJECT(entry_username), "editable", FALSE, NULL);
g_object_set(G_OBJECT(entry_username), "max-width-chars", 50, NULL);
gtk_widget_override_font(entry_username, pango_font_description_from_string("monospace"));
gtk_entry_set_alignment(GTK_ENTRY(entry_username), 0.5);
gtk_grid_attach(GTK_GRID(priv->grid_account), entry_username, 1, grid_row, 1, 1);
++grid_row;
}
gtk_widget_show_all(priv->grid_account);
/* build parameters grid */
grid_row = 0;
if (strcmp(alias.constData(), "IP2IP") != 0) {
if (priv->account->protocol() != Account::Protocol::RING) {
/* SIP and IAX have the same params */
/* host name */
label = gtk_label_new(_("Hostname"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1);
entry_hostname = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entry_hostname), priv->account->hostname().toLocal8Bit().constData());
g_signal_connect(entry_hostname, "changed", G_CALLBACK(account_hostname_changed), view);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_hostname, 1, grid_row, 1, 1);
++grid_row;
/* user name */
label = gtk_label_new(_("Username"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1);
entry_username = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entry_username), priv->account->username().toLocal8Bit().constData());
g_signal_connect(entry_username, "changed", G_CALLBACK(account_username_changed), view);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_username, 1, grid_row, 1, 1);
++grid_row;
/* password */
label = gtk_label_new(_("Password"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1);
entry_password = gtk_entry_new();
gtk_entry_set_input_purpose(GTK_ENTRY(entry_password), GTK_INPUT_PURPOSE_PASSWORD);
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(entry_password), GTK_ENTRY_ICON_PRIMARY, "dialog-password");
gtk_entry_set_visibility(GTK_ENTRY(entry_password), FALSE);
gtk_entry_set_text(GTK_ENTRY(entry_password), priv->account->password().toLocal8Bit().constData());
g_signal_connect(entry_password, "changed", G_CALLBACK(account_password_changed), view);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_password, 1, grid_row, 1, 1);
++grid_row;
/* show password */
GtkWidget *checkbutton = gtk_check_button_new_with_label(_("Show password"));
gtk_grid_attach(GTK_GRID(priv->grid_parameters), checkbutton, 1, grid_row, 1, 1);
g_signal_connect(checkbutton, "toggled", G_CALLBACK(show_password), entry_password);
++grid_row;
/* proxy */
label = gtk_label_new(_("Proxy"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1);
entry_proxy = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entry_proxy), priv->account->proxy().toLocal8Bit().constData());
g_signal_connect(entry_proxy, "changed", G_CALLBACK(account_proxy_changed), view);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_proxy, 1, grid_row, 1, 1);
++grid_row;
/* voicemail number */
label = gtk_label_new(_("Voicemail number"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1);
entry_voicemail = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entry_voicemail), priv->account->mailbox().toLocal8Bit().constData());
g_signal_connect(entry_voicemail, "changed", G_CALLBACK(account_mailbox_changed), view);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_voicemail, 1, grid_row, 1, 1);
++grid_row;
} else {
/* RING accoutn */
/* bootstrap */
label = gtk_label_new(C_("The DHT bootstrap server url", "Bootstrap"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1);
entry_hostname = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entry_hostname), priv->account->hostname().toLocal8Bit().constData());
g_signal_connect(entry_hostname, "changed", G_CALLBACK(account_hostname_changed), view);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_hostname, 1, grid_row, 1, 1);
++grid_row;
}
}
/* auto answer */
checkbutton_autoanswer = gtk_check_button_new_with_label(_("Auto-answer calls"));
gtk_widget_set_halign(checkbutton_autoanswer, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), checkbutton_autoanswer, 0, grid_row, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_autoanswer), priv->account->isAutoAnswer());
g_signal_connect(checkbutton_autoanswer, "toggled", G_CALLBACK(auto_answer), view);
++grid_row;
/* upnp */
checkbutton_upnp = gtk_check_button_new_with_label(_("UPnP enabled"));
gtk_widget_set_halign(checkbutton_upnp, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), checkbutton_upnp, 0, grid_row, 1, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_upnp), priv->account->isUpnpEnabled());
g_signal_connect(checkbutton_upnp, "toggled", G_CALLBACK(upnp_enabled), view);
++grid_row;
/* DTMF tone type */
label = gtk_label_new(_("DTMF tone type:"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1);
GtkWidget *dtmf_box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dtmf_box), GTK_BUTTONBOX_START);
gtk_box_set_spacing(GTK_BOX(dtmf_box), 10);
radiobutton_dtmf_rtp = gtk_radio_button_new_with_label(NULL, "RTP");
radiobutton_dtmf_sip = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(radiobutton_dtmf_rtp),
"SIP");
gtk_toggle_button_set_active(
priv->account->DTMFType() == DtmfType::OverRtp ?
GTK_TOGGLE_BUTTON(radiobutton_dtmf_rtp) : GTK_TOGGLE_BUTTON(radiobutton_dtmf_sip),
TRUE);
g_signal_connect(radiobutton_dtmf_rtp, "toggled", G_CALLBACK(dtmf_set_rtp), view);
gtk_box_pack_start(GTK_BOX(dtmf_box),
radiobutton_dtmf_rtp,
FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(dtmf_box),
radiobutton_dtmf_sip,
FALSE, TRUE, 0);
gtk_grid_attach(GTK_GRID(priv->grid_parameters), dtmf_box, 1, grid_row, 1, 1);
++grid_row;
/* update account parameters if model is updated */
priv->account_updated = QObject::connect(
priv->account,
&Account::changed,
[=] () {
if (strcmp(alias.constData(), "IP2IP") != 0) {
gtk_entry_set_text(GTK_ENTRY(entry_alias), priv->account->alias().toLocal8Bit().constData());
gtk_entry_set_text(GTK_ENTRY(entry_username), priv->account->username().toLocal8Bit().constData());
gtk_entry_set_text(GTK_ENTRY(entry_hostname), priv->account->hostname().toLocal8Bit().constData());
if (priv->account->protocol() != Account::Protocol::RING) {
gtk_entry_set_text(GTK_ENTRY(entry_password), priv->account->password().toLocal8Bit().constData());
gtk_entry_set_text(GTK_ENTRY(entry_proxy), priv->account->proxy().toLocal8Bit().constData());
gtk_entry_set_text(GTK_ENTRY(entry_voicemail), priv->account->mailbox().toLocal8Bit().constData());
}
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_autoanswer), priv->account->isAutoAnswer());
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_upnp), priv->account->isUpnpEnabled());
gtk_toggle_button_set_active(
priv->account->DTMFType() == DtmfType::OverRtp ?
GTK_TOGGLE_BUTTON(radiobutton_dtmf_rtp) : GTK_TOGGLE_BUTTON(radiobutton_dtmf_sip),
TRUE);
}
);
gtk_widget_show_all(priv->grid_parameters);
}
static void ugtk_download_form_init_page1 (UgtkDownloadForm* dform, UgtkProxyForm* proxy)
{
GtkWidget* widget;
GtkGrid* top_grid;
GtkGrid* grid;
GtkWidget* frame;
GtkBox* top_vbox;
GtkWidget* vbox;
GtkWidget* hbox;
dform->page1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
top_vbox = (GtkBox*) dform->page1;
gtk_container_set_border_width (GTK_CONTAINER (top_vbox), 2);
top_grid = (GtkGrid*) gtk_grid_new ();
gtk_box_pack_start (top_vbox, (GtkWidget*) top_grid, FALSE, FALSE, 0);
// URL - entry
widget = gtk_entry_new ();
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 20); // remove for GTK+ 3.12
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 1, "margin-right", 1, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
g_object_set (widget, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 0, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_uri_entry_changed), dform);
dform->uri_entry = widget;
// URL - label
widget = gtk_label_new_with_mnemonic (_("_URI:"));
gtk_label_set_mnemonic_widget (GTK_LABEL(widget), dform->uri_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
gtk_grid_attach (top_grid, widget, 0, 0, 1, 1);
dform->uri_label = widget;
// Mirrors - entry
widget = gtk_entry_new ();
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 20); // remove for GTK+ 3.12
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 1, "margin-right", 1, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
g_object_set (widget, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 1, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_uri_entry_changed), dform);
dform->mirrors_entry = widget;
// Mirrors - label
widget = gtk_label_new_with_mnemonic (_("Mirrors:"));
gtk_label_set_mnemonic_widget (GTK_LABEL(widget), dform->mirrors_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
gtk_grid_attach (top_grid, widget, 0, 1, 1, 1);
dform->mirrors_label = widget;
// File - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 2, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->file_entry = widget;
// File - label
widget = gtk_label_new_with_mnemonic (_("File:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->file_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 2, 1, 1);
dform->file_label = widget;
// Folder - combo entry + icon
dform->folder_combo = gtk_combo_box_text_new_with_entry ();
dform->folder_entry = gtk_bin_get_child (GTK_BIN (dform->folder_combo));
widget = dform->folder_entry;
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
#if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "folder");
#else
gtk_entry_set_icon_from_stock (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_DIRECTORY);
#endif
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, _("Select Folder"));
g_object_set (dform->folder_combo, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, dform->folder_combo, 1, 3, 1, 1);
g_signal_connect (widget, "icon-release",
G_CALLBACK (on_select_folder), dform);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
// Folder - label
widget = gtk_label_new_with_mnemonic (_("_Folder:"));
gtk_label_set_mnemonic_widget(GTK_LABEL (widget), dform->folder_combo);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 3, 1, 1);
// Referrer - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 4, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->referrer_entry = widget;
// Referrer - label
widget = gtk_label_new_with_mnemonic (_("Referrer:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->referrer_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 4, 1, 1);
// dform->referrer_label = widget;
// ----------------------------------------------------
// Connections
// HBox for Connections
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (top_vbox, hbox, FALSE, FALSE, 2);
// connections - label
// widget = gtk_label_new (_("connections"));
// gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
// dform->label_connections = widget;
// connections - spin button
widget = gtk_spin_button_new_with_range (1.0, 16.0, 1.0);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 3); // remove for GTK+ 3.12
gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
dform->spin_connections = widget;
// "Max Connections:" - title label
widget = gtk_label_new_with_mnemonic (_("_Max Connections:"));
gtk_label_set_mnemonic_widget ((GtkLabel*)widget, dform->spin_connections);
gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
dform->title_connections = widget;
// ----------------------------------------------------
// HBox for "Status" and "Login"
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (top_vbox, hbox, FALSE, FALSE, 2);
// ----------------------------------------------------
// frame for Status (start mode)
frame = gtk_frame_new (_("Status"));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
dform->radio_runnable = gtk_radio_button_new_with_mnemonic (NULL,
_("_Runnable"));
dform->radio_pause = gtk_radio_button_new_with_mnemonic_from_widget (
(GtkRadioButton*)dform->radio_runnable, _("P_ause"));
gtk_box_pack_start (GTK_BOX (vbox), dform->radio_runnable, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), dform->radio_pause, FALSE, FALSE, 0);
// ----------------------------------------------------
// frame for login
frame = gtk_frame_new (_("Login"));
grid = (GtkGrid*) gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (grid), 2);
gtk_container_add (GTK_CONTAINER (frame), (GtkWidget*) grid);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 2);
// User - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 0, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->username_entry = widget;
// User - label
widget = gtk_label_new (_("User:"******"margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
// dform->username_label = widget;
// Password - entry
widget = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 1, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->password_entry = widget;
// Password - label
widget = gtk_label_new (_("Password:"******"margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 1, 1, 1);
// dform->password_label = widget;
// ----------------------------------------------------
// proxy
// ug_proxy_widget_init (&dform->proxy_dform);
if (proxy) {
widget = proxy->self;
gtk_box_pack_start (top_vbox, widget, FALSE, FALSE, 2);
}
}
static void ugtk_download_form_init_page2 (UgtkDownloadForm* dform)
{
GtkWidget* widget;
GtkGrid* grid;
dform->page2 = gtk_grid_new ();
grid = (GtkGrid*) dform->page2;
gtk_container_set_border_width (GTK_CONTAINER (grid), 2);
// label - cookie file
widget = gtk_label_new (_("Cookie file:"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
dform->cookie_label = widget;
// entry - cookie file
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
#if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "text-x-generic");
#else
gtk_entry_set_icon_from_stock (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FILE);
#endif
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, _("Select Cookie File"));
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 0, 3, 1);
g_signal_connect (widget, "icon-release",
G_CALLBACK (on_select_cookie), dform);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->cookie_entry = widget;
// label - post file
widget = gtk_label_new (_("Post file:"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 1, 1, 1);
dform->post_label = widget;
// entry - post file
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
#if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "text-x-generic");
#else
gtk_entry_set_icon_from_stock (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FILE);
#endif
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, _("Select Post File"));
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 1, 3, 1);
g_signal_connect (widget, "icon-release",
G_CALLBACK (on_select_post), dform);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->post_entry = widget;
// label - user agent
widget = gtk_label_new (_("User Agent:"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 2, 1, 1);
dform->agent_label = widget;
// entry - user agent
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 2, 3, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->agent_entry = widget;
// Retry limit - label
widget = gtk_label_new_with_mnemonic (_("Retry _limit:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->spin_retry);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 3, 2, 1);
// Retry limit - spin button
widget = gtk_spin_button_new_with_range (0.0, 99.0, 1.0);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 2, 3, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_spin_changed), dform);
dform->spin_retry = widget;
// counts - label
widget = gtk_label_new (_("counts"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 3, 3, 1, 1);
// Retry delay - label
widget = gtk_label_new_with_mnemonic (_("Retry _delay:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->spin_delay);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 4, 2, 1);
// Retry delay - spin button
widget = gtk_spin_button_new_with_range (0.0, 600.0, 1.0);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 2, 4, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_spin_changed), dform);
dform->spin_delay = widget;
// seconds - label
widget = gtk_label_new (_("seconds"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 3, 4, 1, 1);
// label - Max upload speed
widget = gtk_label_new (_("Max upload speed:"));
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 5, 2, 1);
// spin - Max upload speed
widget = gtk_spin_button_new_with_range (0, 99999999, 1);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (widget), 8);
g_object_set (widget, "margin", 1, NULL);
gtk_grid_attach (grid, widget, 2, 5, 1, 1);
dform->spin_upload_speed = (GtkSpinButton*) widget;
// label - "KiB/s"
widget = gtk_label_new (_("KiB/s"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin", 2, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 3, 5, 1, 1);
// label - Max download speed
widget = gtk_label_new (_("Max download speed:"));
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 6, 2, 1);
// spin - Max download speed
widget = gtk_spin_button_new_with_range (0, 99999999, 1);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (widget), 8);
g_object_set (widget, "margin", 1, NULL);
gtk_grid_attach (grid, widget, 2, 6, 1, 1);
dform->spin_download_speed = (GtkSpinButton*) widget;
// label - "KiB/s"
widget = gtk_label_new (_("KiB/s"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin", 2, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 3, 6, 1, 1);
// Retrieve timestamp
widget = gtk_check_button_new_with_label (_("Retrieve timestamp"));
gtk_grid_attach (grid, widget, 0, 7, 3, 1);
dform->timestamp = (GtkToggleButton*) widget;
}
static void
presence_chooser_changed_cb (GtkComboBox *self, gpointer user_data)
{
EmpathyPresenceChooserPriv *priv = GET_PRIV (self);
GtkTreeIter iter;
char *icon_name;
TpConnectionPresenceType new_state;
gboolean customisable = TRUE;
PresenceChooserEntryType type = -1;
GtkWidget *entry;
GtkTreeModel *model;
if (priv->block_changed ||
!gtk_combo_box_get_active_iter (self, &iter)) {
return;
}
model = gtk_combo_box_get_model (self);
gtk_tree_model_get (model, &iter,
COL_STATE_ICON_NAME, &icon_name,
COL_STATE, &new_state,
COL_STATUS_CUSTOMISABLE, &customisable,
COL_TYPE, &type,
-1);
entry = gtk_bin_get_child (GTK_BIN (self));
/* some types of status aren't editable, set the editability of the
* entry appropriately. Unless we're just about to reset it anyway,
* in which case, don't fiddle with it */
if (type != ENTRY_TYPE_EDIT_CUSTOM) {
gtk_editable_set_editable (GTK_EDITABLE (entry), customisable);
priv->state = new_state;
}
if (type == ENTRY_TYPE_EDIT_CUSTOM) {
GtkWidget *window, *dialog;
presence_chooser_reset_status (EMPATHY_PRESENCE_CHOOSER (self));
/* attempt to get the toplevel for this widget */
window = gtk_widget_get_toplevel (GTK_WIDGET (self));
if (!GTK_WIDGET_TOPLEVEL (window) || !GTK_IS_WINDOW (window)) {
window = NULL;
}
dialog = empathy_status_preset_dialog_new (GTK_WINDOW (window));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
else if (type == ENTRY_TYPE_CUSTOM) {
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
icon_name);
/* preseed the status */
if (priv->previous_type == ENTRY_TYPE_BUILTIN) {
/* if their previous entry was a builtin, don't
* preseed */
gtk_entry_set_text (GTK_ENTRY (entry), "");
} else {
/* else preseed the text of their currently entered
* status message */
const char *status;
status = empathy_idle_get_status (priv->idle);
gtk_entry_set_text (GTK_ENTRY (entry), status);
}
/* grab the focus */
gtk_widget_grab_focus (entry);
} else {
char *status;
/* just in case we were setting a new status when
* things were changed */
presence_chooser_set_status_editing (
EMPATHY_PRESENCE_CHOOSER (self),
FALSE);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
icon_name);
gtk_tree_model_get (model, &iter,
COL_STATUS_TEXT, &status,
-1);
empathy_idle_set_presence (priv->idle, priv->state, status);
g_free (status);
}
if (type != ENTRY_TYPE_EDIT_CUSTOM) {
priv->previous_type = type;
}
g_free (icon_name);
}
static void pocketvox_setup_add_module(PocketvoxSetup *setup, gchar* key, gchar* value, gboolean isapps)
{
g_return_if_fail(NULL != setup);
setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
PocketvoxSetupPrivate *priv = setup->priv;
ModuleInfos *info = (ModuleInfos *)g_malloc0(sizeof(ModuleInfos));
GtkWidget* row = gtk_list_box_row_new();
gchar *name = g_strdup_printf("row_%d",current_line);
gtk_widget_set_name(row, name);
GtkWidget* grid = gtk_grid_new();
info->entry_id = gtk_entry_new();
if(key != NULL)
{
gtk_entry_set_text(GTK_ENTRY(info->entry_id), key);
}
gtk_entry_set_placeholder_text(GTK_ENTRY(info->entry_id), _("your-id"));
gtk_widget_set_tooltip_text(info->entry_id, _("Set the module's id"));
info->sw = gtk_switch_new();
gtk_widget_set_tooltip_text(info->sw, _("is this module associated to an desktop application ?"));
info->entry_path = gtk_entry_new();
gtk_entry_set_icon_from_icon_name (GTK_ENTRY(info->entry_path), GTK_ENTRY_ICON_SECONDARY, "gtk-search");
gtk_entry_set_placeholder_text(GTK_ENTRY(info->entry_path), _("your path"));
gtk_widget_set_tooltip_text(info->entry_path,_("Set the dictionnary's path"));
g_signal_connect(info->entry_path, "icon-press", G_CALLBACK(pocketvox_setup_search_dict), NULL);
//gtk_widget_set_hexpand(label_app, TRUE);
gtk_widget_set_hexpand(info->entry_path, TRUE);
gtk_widget_set_hexpand(info->entry_id, TRUE);
gtk_widget_set_hexpand(info->sw, FALSE);
g_object_set(G_OBJECT(info->sw),
"active", isapps,
NULL);
if(value != NULL)
{
gtk_entry_set_text(GTK_ENTRY(info->entry_path),
value);
}
gtk_grid_set_row_homogeneous(GTK_GRID(grid), FALSE);
gtk_grid_attach(GTK_GRID(grid), info->entry_id, 0, 0, 2, 1);
gtk_grid_attach(GTK_GRID(grid), info->entry_path, 2, 0, 2, 1);
gtk_grid_attach(GTK_GRID(grid), info->sw, 4, 0, 1, 1);
gtk_container_add(GTK_CONTAINER(row), grid);
gtk_widget_show_all(row);
gtk_list_box_prepend(GTK_LIST_BOX(priv->listBox), row);
g_hash_table_insert(priv->apps, g_strdup(name), info);
current_line ++;
}
static void * search_get_widget (void)
{
GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
entry = gtk_entry_new ();
gtk_entry_set_icon_from_icon_name ((GtkEntry *) entry, GTK_ENTRY_ICON_PRIMARY, "edit-find");
gtk_entry_set_placeholder_text ((GtkEntry *) entry, _("Search library"));
g_signal_connect (entry, "destroy", (GCallback) gtk_widget_destroyed, & entry);
gtk_box_pack_start ((GtkBox *) vbox, entry, FALSE, FALSE, 0);
help_label = gtk_label_new (_("To import your music library into "
"Audacious, choose a folder and then click the \"refresh\" icon."));
gtk_widget_set_size_request (help_label, 194, -1);
gtk_label_set_line_wrap ((GtkLabel *) help_label, TRUE);
g_signal_connect (help_label, "destroy", (GCallback) gtk_widget_destroyed, & help_label);
gtk_widget_set_no_show_all (help_label, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, help_label, TRUE, FALSE, 0);
wait_label = gtk_label_new (_("Please wait ..."));
g_signal_connect (wait_label, "destroy", (GCallback) gtk_widget_destroyed, & wait_label);
gtk_widget_set_no_show_all (wait_label, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, wait_label, TRUE, FALSE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
g_signal_connect (scrolled, "destroy", (GCallback) gtk_widget_destroyed, & scrolled);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scrolled,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_no_show_all (scrolled, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, scrolled, TRUE, TRUE, 0);
results_list = audgui_list_new (& list_callbacks, NULL, items ? index_count (items) : 0);
g_signal_connect (results_list, "destroy", (GCallback) gtk_widget_destroyed, & results_list);
gtk_tree_view_set_headers_visible ((GtkTreeView *) results_list, FALSE);
audgui_list_add_column (results_list, NULL, 0, G_TYPE_STRING, -1);
gtk_container_add ((GtkContainer *) scrolled, results_list);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_end ((GtkBox *) vbox, hbox, FALSE, FALSE, 0);
GtkWidget * chooser = gtk_file_chooser_button_new (_("Choose Folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_box_pack_start ((GtkBox *) hbox, chooser, TRUE, TRUE, 0);
char * path = get_path ();
gtk_file_chooser_set_filename ((GtkFileChooser *) chooser, path);
str_unref (path);
GtkWidget * button = gtk_button_new ();
gtk_container_add ((GtkContainer *) button, gtk_image_new_from_icon_name
("view-refresh", GTK_ICON_SIZE_BUTTON));
gtk_button_set_relief ((GtkButton *) button, GTK_RELIEF_NONE);
gtk_box_pack_start ((GtkBox *) hbox, button, FALSE, FALSE, 0);
g_signal_connect (entry, "changed", (GCallback) entry_cb, NULL);
g_signal_connect (entry, "activate", (GCallback) action_play, NULL);
g_signal_connect (button, "clicked", (GCallback) refresh_cb, chooser);
gtk_widget_show_all (vbox);
gtk_widget_show (results_list);
show_hide_widgets ();
return vbox;
}
static GtkWidget *cd_build_events_widget (void)
{
GtkWidget *pMainBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, MARGIN);
// category toolbar.
GtkWidget *pToolBar = gtk_toolbar_new ();
///gtk_toolbar_set_orientation (GTK_TOOLBAR (pToolBar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style (GTK_TOOLBAR (pToolBar), GTK_TOOLBAR_BOTH); // overwrite system preference (GTK_TOOLBAR_ICONS)
gtk_style_context_add_class (gtk_widget_get_style_context (pToolBar),
GTK_STYLE_CLASS_INLINE_TOOLBAR); // style: inline
GtkCssProvider *css = gtk_css_provider_new (); // but without border
gtk_css_provider_load_from_data (css, ".inline-toolbar.toolbar { "
"background: transparent; border-color: transparent; }", -1, NULL);
GtkStyleContext *ctx = gtk_widget_get_style_context (pToolBar);
gtk_style_context_add_provider (ctx, GTK_STYLE_PROVIDER (css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (pToolBar), FALSE); // force to display all the entries.
gtk_box_pack_start (GTK_BOX (pMainBox), pToolBar, TRUE, TRUE, MARGIN);
int i = 0;
GtkToolItem *group = _add_category_button (pToolBar, D_("All"), "stock_search", i++, NULL);
_add_category_button (pToolBar, D_("Applications"), "exec", i++, group);
_add_category_button (pToolBar, D_("Documents"), "document", i++, group);
///_add_category_button (pToolBar, D_("Folders"), "folder", i++, group);
_add_category_button (pToolBar, D_("Images"), "image", i++, group);
_add_category_button (pToolBar, D_("Audio"), "sound", i++, group);
_add_category_button (pToolBar, D_("Videos"), "video", i++, group);
_add_category_button (pToolBar, D_("Web"), "text-html", i++, group);
_add_category_button (pToolBar, D_("Others"), "unknown", i++, group);
_add_category_button (pToolBar, D_("Top Results"), "gtk-about", i, group);
// search entry.
GtkWidget *pFilterBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, CAIRO_DOCK_GUI_MARGIN);
gtk_box_pack_start (GTK_BOX (pMainBox), pFilterBox, FALSE, FALSE, MARGIN);
GtkWidget *pFilterLabel = gtk_label_new (D_("Look for events"));
gldi_dialog_set_widget_text_color (GTK_WIDGET (pFilterLabel));
gtk_box_pack_start (GTK_BOX (pFilterBox), pFilterLabel, FALSE, FALSE, MARGIN);
GtkWidget *pEntry = gtk_entry_new ();
// press any key:
g_signal_connect (pEntry, "key-release-event", G_CALLBACK (on_key_press_filter), NULL);
gtk_box_pack_start (GTK_BOX (pFilterBox), pEntry, TRUE, TRUE, MARGIN);
gtk_widget_set_tooltip_text (pEntry, D_("The default boolean operator is AND. Thus the query foo bar will be interpreted as foo AND bar. To exclude a term from the result set prepend it with a minus sign - eg foo -bar. Phrase queries can be done by double quoting the string \"foo is a bar\". You can truncate terms by appending a *. "));
gtk_entry_set_icon_activatable (GTK_ENTRY (pEntry), GTK_ENTRY_ICON_SECONDARY, TRUE);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (pEntry), GTK_ENTRY_ICON_SECONDARY, GLDI_ICON_NAME_CLEAR);
g_signal_connect (pEntry, "icon-press", G_CALLBACK (on_clear_filter), NULL);
myData.pEntry = pEntry;
gtk_widget_grab_focus (pEntry);
// model
GtkListStore *pModel = gtk_list_store_new (CD_MODEL_NB_COLUMNS,
G_TYPE_STRING, /* CD_MODEL_NAME */
G_TYPE_STRING, /* CD_MODEL_URI */
G_TYPE_STRING, /* CD_MODEL_PATH */
GDK_TYPE_PIXBUF, /* CD_MODEL_ICON */
G_TYPE_INT64, /* CD_MODEL_DATE */
G_TYPE_UINT); /* CD_MODEL_ID */
myData.pModel = pModel;
// tree-view
GtkWidget *pOneWidget = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (pOneWidget), GTK_TREE_MODEL (pModel));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pOneWidget), TRUE);
gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (pOneWidget), TRUE);
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pOneWidget));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
/**gtk_tree_selection_set_select_function (selection,
(GtkTreeSelectionFunc) _cairo_dock_select_one_item_in_tree,
NULL,
NULL);*/
g_signal_connect (G_OBJECT (pOneWidget), "button-release-event", G_CALLBACK (_on_click_module_tree_view), NULL); // pour le menu du clic droit
g_signal_connect (G_OBJECT (pOneWidget), "button-press-event", G_CALLBACK (_on_click_module_tree_view), NULL); // pour le menu du clic droit
g_object_set (G_OBJECT (pOneWidget), "tooltip-column", CD_MODEL_PATH, NULL);
GtkTreeViewColumn* col;
GtkCellRenderer *rend;
// icon
rend = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (pOneWidget), -1, NULL, rend, "pixbuf", CD_MODEL_ICON, NULL);
// file name
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (D_("File name"), rend, "text", CD_MODEL_NAME, NULL);
gtk_tree_view_column_set_min_width (col, 200);
gtk_tree_view_column_set_max_width (col, MAX (500, g_desktopGeometry.Xscreen.width / g_desktopGeometry.iNbScreens * .67)); // we don't know on which screen is place the container...
gtk_tree_view_column_set_sort_column_id (col, CD_MODEL_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);
// date
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (D_("Last access"), rend, "text", CD_MODEL_DATE, NULL);
gtk_tree_view_column_set_cell_data_func (col, rend, (GtkTreeCellDataFunc)_render_date, NULL, NULL);
gtk_tree_view_column_set_sort_column_id (col, CD_MODEL_DATE);
gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);
// barres de defilement
GtkAdjustment *adj = gtk_adjustment_new (0., 0., 100., 1, 10, 10);
gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (pOneWidget), GTK_ADJUSTMENT (adj));
GtkWidget *pScrolledWindow = gtk_scrolled_window_new (NULL, NULL);
g_object_set (pScrolledWindow, "height-request", 300, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pScrolledWindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
#if GTK_CHECK_VERSION (3, 8, 0)
gtk_container_add (GTK_CONTAINER (pScrolledWindow), pOneWidget);
#else
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (pScrolledWindow), pOneWidget);
#endif
gtk_box_pack_start (GTK_BOX (pMainBox), pScrolledWindow, FALSE, FALSE, MARGIN);
return pMainBox;
}
