GtkWidget *gtk_sms_qr_new(void)
{
GtkWidget *gtk_sms_label = gtk_label_new(NULL);
GtkWidget *gtk_sms_vertical = gtk_box_new(GTK_ORIENTATION_VERTICAL, 15);
GtkWidget *gtk_sms_scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_sms_entry_phone = gtk_entry_new();
gtk_sms_entry_text = gtk_entry_new();
gtk_sms_label_size = gtk_label_new("0 characters");
GtkWidget *gtk_sms_button_clear = gtk_button_new_with_label("Clear and reset");
GtkWidget *gtk_sms_horizontal_buttons = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
gtk_label_set_markup(GTK_LABEL(gtk_sms_label), "<span size=\"xx-large\">Generate from SMS</span>");
gtk_widget_set_halign(gtk_sms_label, GTK_ALIGN_START);
gtk_widget_set_halign(gtk_sms_label_size, GTK_ALIGN_START);
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_sms_entry_phone), "Recipient phone number");
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_sms_entry_text), "SMS Message");
gtk_container_set_border_width(GTK_CONTAINER(gtk_sms_vertical), 15);
gtk_box_pack_start(GTK_BOX(gtk_sms_vertical), gtk_sms_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_sms_vertical), gtk_sms_entry_phone, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_sms_vertical), gtk_sms_entry_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_sms_horizontal_buttons), gtk_sms_label_size, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(gtk_sms_horizontal_buttons), gtk_sms_button_clear, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_sms_vertical), gtk_sms_horizontal_buttons, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(gtk_sms_scrolled), gtk_sms_vertical);
g_signal_connect(G_OBJECT(gtk_sms_button_clear), "clicked", G_CALLBACK(cb_clicked_sms_clear), NULL);
g_signal_connect(G_OBJECT(gtk_sms_entry_text), "changed", G_CALLBACK(cb_changed_sms_entry), NULL);
return gtk_sms_scrolled;
}
int makeWindow(RuskWindow *rusk)
{
GtkWidget *box;
if((rusk->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL))) == NULL)
{
return -1;
}
gtk_container_set_border_width(GTK_CONTAINER(rusk->window), BORDER_WIDTH);
gtk_widget_override_background_color(GTK_WIDGET(rusk->window), GTK_STATE_FLAG_NORMAL, BORDER_COLOR_NORMAL);
box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(rusk->window), box);
rusk->addressbar = GTK_ENTRY(gtk_entry_new());
gtk_entry_set_placeholder_text(rusk->addressbar, "URI");
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(rusk->addressbar), FALSE, FALSE, 0);
rusk->globalSearch = GTK_ENTRY(gtk_search_entry_new());
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(rusk->globalSearch), FALSE, FALSE, 0);
rusk->insiteSearch = GTK_ENTRY(gtk_search_entry_new());
gtk_entry_set_placeholder_text(rusk->insiteSearch, "site search");
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(rusk->insiteSearch), FALSE, FALSE, 0);
rusk->progressbar = GTK_PROGRESS_BAR(gtk_progress_bar_new());
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(rusk->progressbar), FALSE, FALSE, 0);
rusk->webview = WEBKIT_WEB_VIEW(webkit_web_view_new_with_context(webkit_web_context_new_with_website_data_manager(webkit_website_data_manager_new(
"base-cache-directory", g_strdup_printf("%s/rusk", g_get_user_cache_dir()),
"disk-cache-directory", g_strdup_printf("%s/rusk", g_get_user_cache_dir()),
"base-data-directory", g_strdup_printf("%s/rusk/data", g_get_user_data_dir()),
"indexeddb-directory", g_strdup_printf("%s/rusk/indexed", g_get_user_data_dir()),
"local-storage-directory", g_strdup_printf("%s/rusk/local-storage", g_get_user_data_dir()),
"offline-application-cache-directory", g_strdup_printf("%s/rusk/offline-apps", g_get_user_data_dir()),
"websql-directory", g_strdup_printf("%s/rusk/websql", g_get_user_data_dir()),
NULL
))));
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(rusk->webview), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(rusk->window), "destroy", G_CALLBACK(closeRusk), rusk);
gtk_widget_show_all(GTK_WIDGET(rusk->window));
gtk_widget_set_visible(GTK_WIDGET(rusk->addressbar), FALSE);
gtk_widget_set_visible(GTK_WIDGET(rusk->globalSearch), FALSE);
gtk_widget_set_visible(GTK_WIDGET(rusk->progressbar), FALSE);
gtk_widget_set_visible(GTK_WIDGET(rusk->insiteSearch), FALSE);
g_signal_connect(G_OBJECT(rusk->window), "key-press-event", G_CALLBACK(onKeyPress), rusk);
g_signal_connect(G_OBJECT(rusk->insiteSearch), "search-changed", G_CALLBACK(onInSiteSearchInput), rusk);
g_signal_connect(G_OBJECT(rusk->addressbar), "key-release-event", G_CALLBACK(onAddressbarInput), rusk);
g_signal_connect(G_OBJECT(rusk->globalSearch), "activate", G_CALLBACK(onGlobalSearchActivate), rusk);
return 0;
}
static void
on_button_clicked_add (GtkButton *button,
NimfSettingsPageKey *page_key)
{
GtkWidget *dialog;
GtkWidget *entry;
GtkWidget *content_area;
GtkDialogFlags flags;
#if GTK_CHECK_VERSION (3, 12, 0)
flags = GTK_DIALOG_MODAL | GTK_DIALOG_USE_HEADER_BAR;
#else
flags = GTK_DIALOG_MODAL;
#endif
dialog = gtk_dialog_new_with_buttons (_("Press key combination"),
GTK_WINDOW (nimf_settings_window),
flags,
_("_OK"), GTK_RESPONSE_OK,
_("_Cancel"), GTK_RESPONSE_CANCEL,
NULL);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "nimf");
gtk_widget_set_size_request (GTK_WIDGET (dialog), 400, -1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
GTK_RESPONSE_OK, FALSE);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
entry = gtk_entry_new ();
gtk_entry_set_placeholder_text (GTK_ENTRY (entry),
_("Click here and then press key combination"));
gtk_box_pack_start (GTK_BOX (content_area), entry, TRUE, TRUE, 0);
g_signal_connect (entry, "key-press-event",
G_CALLBACK (on_key_press_event), dialog);
gtk_widget_show_all (content_area);
switch (gtk_dialog_run (GTK_DIALOG (dialog)))
{
case GTK_RESPONSE_OK:
{
GtkTreeModel *model;
const gchar *text;
GtkTreeIter iter;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (page_key->treeview));
text = gtk_entry_get_text (GTK_ENTRY (entry));
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, text, -1);
nimf_settings_page_key_update_gsettings_strv (page_key, model);
}
break;
default:
break;
}
gtk_widget_destroy (dialog);
}
///////////////////////////////////////////////////////////////////////////////
// Creation de la fenetre et de son contenu
///////////////////////////////////////////////////////////////////////////////
static void startApplication(GtkApplication *app,gpointer data) {
GtkWidget *window=gtk_application_window_new(app);
gtk_window_set_title(GTK_WINDOW(window),"Application GTK+3 v2");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window),400,100);
gtk_container_set_border_width(GTK_CONTAINER(window),10);
GtkWidget *grid=gtk_grid_new();
gtk_container_add(GTK_CONTAINER(window),grid);
gtk_grid_set_row_spacing(GTK_GRID(grid),2);
gtk_grid_set_column_spacing(GTK_GRID(grid),5);
gtk_widget_set_valign(grid,GTK_ALIGN_CENTER);
gtk_widget_set_halign(grid,GTK_ALIGN_CENTER);
int col=0,row=0;
GtkWidget *label_user=gtk_label_new("UserName");
gtk_grid_attach(GTK_GRID(grid),label_user,col,row,1,1);
col++;
GtkWidget *entry_user=gtk_entry_new();
gtk_entry_set_placeholder_text(GTK_ENTRY(entry_user),"UserName");
//gtk_entry_set_width_chars(GTK_ENTRY(entry_user),25);
gtk_grid_attach(GTK_GRID(grid),entry_user,col,row,1,1);
col=0;row++;
GtkWidget *label_pass=gtk_label_new("Password");
gtk_grid_attach(GTK_GRID(grid),label_pass,col,row,1,1);
col++;
GtkWidget *entry_pass=gtk_entry_new();
gtk_entry_set_placeholder_text(GTK_ENTRY(entry_pass),"Password");
//gtk_entry_set_max_length(GTK_ENTRY(entry_pass),8);
gtk_entry_set_visibility(GTK_ENTRY(entry_pass),FALSE);
//gtk_entry_set_invisible_char(GTK_ENTRY(entry_pass),42);
//gtk_entry_set_input_purpose(GTK_ENTRY(entry_pass),
//GTK_INPUT_PURPOSE_PASSWORD);
gtk_grid_attach(GTK_GRID(grid),entry_pass,col,row,1,1);
col=0;row++;
GtkWidget *btn=gtk_button_new_with_label("Authentication");
//gtk_widget_set_hexpand(btn,FALSE);
//gtk_widget_set_vexpand(btn,FALSE);
//gtk_widget_set_halign(btn,GTK_ALIGN_CENTER);
//gtk_widget_set_valign(btn,GTK_ALIGN_CENTER);
//gtk_widget_set_size_request(btn,220,50);
gtk_grid_attach(GTK_GRID(grid),btn,col,row,2,1);
gtk_widget_show_all(window);
}
static void
search_by_name (GtkWidget *item,
GtkEntry *entry)
{
gtk_entry_set_icon_tooltip_text (entry,
GTK_ENTRY_ICON_PRIMARY,
"Search by name\n"
"Click here to change the search type");
gtk_entry_set_placeholder_text (entry, "name");
}
static GtkWidget* parametrs_widget_new() {
GtkWidget *vbox;
GtkWidget *coordinate_label;
GtkWidget *coordinate_grid;
GtkWidget *draw_button_image;
GtkWidget *draw_button;
/* Создание виджетов окна параметров */
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
coordinate_label = gtk_label_new("Введите координаты");
coordinate_grid = gtk_grid_new();
entry[COORDINATE_X1] = gtk_entry_new();
entry[COORDINATE_Y1] = gtk_entry_new();
entry[COORDINATE_X2] = gtk_entry_new();
entry[COORDINATE_Y2] = gtk_entry_new();
draw_button_image = gtk_image_new_from_file(DRAW_BUTTON_IMAGE);
draw_button = gtk_button_new_with_label("Отрисовать");
/* Настройка виджетов окна параметров */
gtk_grid_set_row_spacing(GTK_GRID(coordinate_grid), 5);
gtk_grid_set_column_spacing(GTK_GRID(coordinate_grid), 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[COORDINATE_X1]), "x1");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[COORDINATE_Y1]), "y1");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[COORDINATE_X2]), "x2");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[COORDINATE_Y2]), "y2");
gtk_button_set_image(GTK_BUTTON(draw_button), draw_button_image);
/* Упаковка окна параметров */
gtk_grid_attach(GTK_GRID(coordinate_grid), entry[COORDINATE_X1], 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(coordinate_grid), entry[COORDINATE_Y1], 1, 0, 1, 1);
gtk_grid_attach(GTK_GRID(coordinate_grid), entry[COORDINATE_X2], 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(coordinate_grid), entry[COORDINATE_Y2], 1, 1, 1, 1);
gtk_box_pack_start(GTK_BOX(vbox), coordinate_label, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), coordinate_grid, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(vbox), draw_button, FALSE, TRUE, 0);
g_signal_connect(draw_button, "released", G_CALLBACK(draw_button_clicked), NULL);
g_signal_connect(drawing_area, "draw", G_CALLBACK(draw_callback), NULL);
return vbox;
}
static int placeholder_member(lua_State *L)
{
lua_entry entry;
luaA_to(L,lua_entry,&entry,1);
if(lua_gettop(L) > 2) {
const char * placeholder = luaL_checkstring(L,3);
gtk_entry_set_placeholder_text(GTK_ENTRY(entry->widget),placeholder);
return 0;
}
lua_pushstring(L,gtk_entry_get_placeholder_text(GTK_ENTRY(entry->widget)));
return 1;
}
bool wxTextEntry::SetHint(const wxString& hint)
{
#if GTK_CHECK_VERSION(3,2,0)
GtkEntry *entry = GetEntry();
if (entry && gtk_check_version(3,2,0) == NULL)
{
gtk_entry_set_placeholder_text(entry, wxGTK_CONV(hint));
return true;
}
#endif
return wxTextEntryBase::SetHint(hint);
}
GtkWidget *gtk_mail_qr_new(void)
{
GtkWidget *gtk_mail_label = gtk_label_new(NULL);
GtkWidget *gtk_mail_vertical = gtk_box_new(GTK_ORIENTATION_VERTICAL, 15);
GtkWidget *gtk_mail_scrolled = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *gtk_mail_button_clear = gtk_button_new_with_label("Clear and reset");
GtkWidget *gtk_mail_horizontal_buttons = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
gtk_mail_entry_to = gtk_entry_new();
gtk_mail_entry_subject = gtk_entry_new();
GtkWidget *gtk_mail_text_view_scrolled_frame = gtk_frame_new(NULL);
GtkWidget *gtk_mail_text_view_scrolled = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *gtk_mail_text_view = gtk_text_view_new();
gtk_mail_text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtk_mail_text_view));
gtk_label_set_markup(GTK_LABEL(gtk_mail_label), "<span size=\"xx-large\">Generate from e-mail</span>");
gtk_widget_set_halign(gtk_mail_label, GTK_ALIGN_START);
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_mail_entry_to), "Recipient e-mail address");
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_mail_entry_subject), "E-mail subject");
gtk_container_set_border_width(GTK_CONTAINER(gtk_mail_vertical), 15);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(gtk_mail_text_view), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(gtk_mail_text_view), 5);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(gtk_mail_text_view), 2);
gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(gtk_mail_text_view), 2);
gtk_widget_set_size_request(gtk_mail_text_view_scrolled, -1, 200);
gtk_text_buffer_set_text(gtk_mail_text_buffer, "E-mail message", -1);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_entry_to, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_entry_subject, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(gtk_mail_text_view_scrolled), gtk_mail_text_view);
gtk_container_add(GTK_CONTAINER(gtk_mail_text_view_scrolled_frame), gtk_mail_text_view_scrolled);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_text_view_scrolled_frame, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(gtk_mail_horizontal_buttons), gtk_mail_button_clear, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_mail_vertical), gtk_mail_horizontal_buttons, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(gtk_mail_scrolled), gtk_mail_vertical);
g_signal_connect(G_OBJECT(gtk_mail_button_clear), "clicked", G_CALLBACK(cb_clicked_mail_clear), NULL);
return gtk_mail_scrolled;
}
void globalSearchToggle(RuskWindow *rusk, const char *site)
{
if(!gtk_widget_get_visible(GTK_WIDGET(rusk->globalSearch)))
{
gtk_entry_set_placeholder_text(rusk->globalSearch, site);
gtk_widget_set_visible(GTK_WIDGET(rusk->globalSearch), TRUE);
gtk_window_set_focus(rusk->window, GTK_WIDGET(rusk->globalSearch));
}else
{
gtk_widget_set_visible(GTK_WIDGET(rusk->globalSearch), FALSE);
gtk_window_set_focus(rusk->window, GTK_WIDGET(rusk->webview));
}
}
/* ***************************
* ***** SETUP ENTRY BOX *****
* ***************************
*/
static void setup_entry(struct elyapp *app, char *tag)
{
TRACE(stdout, "Setting up %s entry box...", tag);
if ( app->text.invis != NULL ) {
gtk_entry_set_visibility(GTK_ENTRY(app->gui.widg),
FALSE);
gtk_entry_set_invisible_char(GTK_ENTRY(app->gui.widg),
*app->text.invis);
}
GtkEntryBuffer *buf = gtk_entry_buffer_new(0, -1);
gtk_entry_buffer_set_max_length(buf, app->text.maxchars);
gtk_entry_set_buffer(GTK_ENTRY(app->gui.widg), buf);
gtk_entry_set_placeholder_text(GTK_ENTRY(app->gui.widg), tag);
TRACE(stdout, "Done setting up %s entry box.", tag);
}
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 screenshot(GtkWidget *button, gpointer data)
{
t_env *rt;
GtkWidget *select_file;
(void)button;
rt = (t_env *)data;
create_data(rt);
rt->dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(rt->dialog), GTK_WIN_POS_MOUSE);
gtk_window_set_default_size(GTK_WINDOW(rt->dialog), 200, 50);
gtk_window_set_title(GTK_WINDOW(rt->dialog), "Save");
gtk_container_set_border_width(GTK_CONTAINER(rt->dialog), 10);
gtk_window_set_modal(GTK_WINDOW(rt->dialog), TRUE);
select_file = gtk_entry_new();
gtk_entry_set_placeholder_text(GTK_ENTRY(select_file),
"Choose a file name");
g_signal_connect(G_OBJECT(select_file), "key-press-event",
G_CALLBACK(inputs), rt);
gtk_container_add(GTK_CONTAINER(rt->dialog), select_file);
gtk_widget_show_all(rt->dialog);
}
GtkWidget *gtk_text_qr_new(void)
{
GtkWidget *gtk_text_button_clear = gtk_button_new_with_label("Clear and reset");
GtkWidget *gtk_text_label = gtk_label_new(NULL);
gtk_text_entry = gtk_entry_new();
GtkWidget *gtk_text_scrolled = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *gtk_text_vertical = gtk_box_new(GTK_ORIENTATION_VERTICAL, 15);
GtkWidget *gtk_text_horizontal_buttons = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
gtk_label_set_markup(GTK_LABEL(gtk_text_label), "<span size=\"xx-large\">Generate from text or URL</span>");
gtk_widget_set_halign(gtk_text_label, GTK_ALIGN_START);
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_text_entry), "Text or URL");
gtk_container_set_border_width(GTK_CONTAINER(gtk_text_vertical), 15);
gtk_box_pack_end(GTK_BOX(gtk_text_horizontal_buttons), gtk_text_button_clear, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_text_vertical), gtk_text_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_text_vertical), gtk_text_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_text_vertical), gtk_text_horizontal_buttons, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(gtk_text_scrolled), gtk_text_vertical);
g_signal_connect(G_OBJECT(gtk_text_button_clear), "clicked", G_CALLBACK(cb_clicked_text_clear), NULL);
return gtk_text_scrolled;
}
gboolean yatla_layout_load_layout (YatlaLayout* self, YatlaSidebar* sidebar, const gchar* list_name) {
gboolean result = FALSE;
Block4Data* _data4_;
YatlaSidebar* _tmp0_ = NULL;
YatlaSidebar* _tmp1_ = NULL;
const gchar* _tmp2_ = NULL;
gchar* _tmp3_ = NULL;
const gchar* _tmp4_ = NULL;
gchar* _tmp5_ = NULL;
GtkBox* _tmp6_ = NULL;
const gchar* _tmp7_ = NULL;
GtkLabel* _tmp8_ = NULL;
GtkLabel* _tmp9_ = NULL;
GtkLabel* _tmp10_ = NULL;
GtkLabel* _tmp11_ = NULL;
const gchar* _tmp12_ = NULL;
gchar* _tmp13_ = NULL;
gchar* _tmp14_ = NULL;
GtkBox* _tmp15_ = NULL;
GtkLabel* _tmp16_ = NULL;
GtkBox* _tmp17_ = NULL;
GtkEntry* _tmp18_ = NULL;
GtkEntry* _tmp19_ = NULL;
GtkEntry* _tmp20_ = NULL;
GtkBox* _tmp21_ = NULL;
GtkEntry* _tmp22_ = NULL;
GtkBox* _tmp23_ = NULL;
gint list_index = 0;
YatlaSidebar* _tmp24_ = NULL;
GList* _tmp25_ = NULL;
gint task_index = 0;
guint the_longest_task = 0U;
GtkBox* _tmp122_ = NULL;
GtkBox* _tmp123_ = NULL;
GtkBox* _tmp124_ = NULL;
guint _tmp125_ = 0U;
GeeTreeMap* _tmp126_ = NULL;
GeeCollection* _tmp127_ = NULL;
GeeCollection* _tmp128_ = NULL;
GeeCollection* _tmp129_ = NULL;
gint _tmp130_ = 0;
gint _tmp131_ = 0;
GtkEntry* _tmp132_ = NULL;
GeeMapIterator* map_iterator = NULL;
GeeTreeMap* _tmp133_ = NULL;
GeeMapIterator* _tmp134_ = NULL;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (sidebar != NULL, FALSE);
g_return_val_if_fail (list_name != NULL, FALSE);
_data4_ = g_slice_new0 (Block4Data);
_data4_->_ref_count_ = 1;
_data4_->self = g_object_ref (self);
_tmp0_ = sidebar;
_tmp1_ = _g_object_ref0 (_tmp0_);
_g_object_unref0 (_data4_->sidebar);
_data4_->sidebar = _tmp1_;
_tmp2_ = list_name;
_tmp3_ = g_strdup (_tmp2_);
_g_free0 (_data4_->list_name);
_data4_->list_name = _tmp3_;
_tmp4_ = _data4_->list_name;
_tmp5_ = g_strdup (_tmp4_);
_g_free0 (self->_name);
self->_name = _tmp5_;
_tmp6_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
g_object_ref_sink (_tmp6_);
_g_object_unref0 (self->_top_box1);
self->_top_box1 = _tmp6_;
_tmp7_ = _data4_->list_name;
_tmp8_ = (GtkLabel*) gtk_label_new (_tmp7_);
g_object_ref_sink (_tmp8_);
_g_object_unref0 (self->_list_name);
self->_list_name = _tmp8_;
_tmp9_ = self->_list_name;
gtk_label_set_use_markup (_tmp9_, TRUE);
_tmp10_ = self->_list_name;
_tmp11_ = self->_list_name;
_tmp12_ = gtk_label_get_text (_tmp11_);
_tmp13_ = g_strdup_printf ("<span font='14'><b>%s</b></span>", _tmp12_);
_tmp14_ = _tmp13_;
gtk_label_set_markup (_tmp10_, _tmp14_);
_g_free0 (_tmp14_);
_tmp15_ = self->_top_box1;
_tmp16_ = self->_list_name;
gtk_box_pack_start (_tmp15_, (GtkWidget*) _tmp16_, TRUE, TRUE, (guint) 0);
_tmp17_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
g_object_ref_sink (_tmp17_);
_g_object_unref0 (self->_top_box2);
self->_top_box2 = _tmp17_;
_tmp18_ = (GtkEntry*) gtk_entry_new ();
g_object_ref_sink (_tmp18_);
_g_object_unref0 (self->new_task_entry);
self->new_task_entry = _tmp18_;
_tmp19_ = self->new_task_entry;
gtk_entry_set_placeholder_text (_tmp19_, "Add new task");
_tmp20_ = self->new_task_entry;
gtk_entry_set_icon_from_stock (_tmp20_, GTK_ENTRY_ICON_SECONDARY, "gtk-edit");
_tmp21_ = self->_top_box2;
_tmp22_ = self->new_task_entry;
gtk_box_pack_start (_tmp21_, (GtkWidget*) _tmp22_, TRUE, TRUE, (guint) 0);
_tmp23_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
g_object_ref_sink (_tmp23_);
_g_object_unref0 (self->_tasks_box);
self->_tasks_box = _tmp23_;
list_index = 0;
_tmp24_ = _data4_->sidebar;
_tmp25_ = _tmp24_->sidebar_list;
{
GList* list_collection = NULL;
GList* list_it = NULL;
list_collection = _tmp25_;
for (list_it = list_collection; list_it != NULL; list_it = list_it->next) {
YatlaList* _tmp26_ = NULL;
YatlaList* list = NULL;
_tmp26_ = _g_object_ref0 ((YatlaList*) list_it->data);
list = _tmp26_;
{
YatlaList* _tmp27_ = NULL;
const gchar* _tmp28_ = NULL;
const gchar* _tmp29_ = NULL;
const gchar* _tmp30_ = NULL;
gint _tmp31_ = 0;
_tmp27_ = list;
_tmp28_ = yatla_list_get_name (_tmp27_);
_tmp29_ = _tmp28_;
_tmp30_ = _data4_->list_name;
if (g_strcmp0 (_tmp29_, _tmp30_) == 0) {
_g_object_unref0 (list);
break;
}
_tmp31_ = list_index;
list_index = _tmp31_ + 1;
_g_object_unref0 (list);
}
}
}
task_index = 0;
the_longest_task = (guint) 0;
while (TRUE) {
Block5Data* _data5_;
gint _tmp32_ = 0;
YatlaSidebar* _tmp33_ = NULL;
GList* _tmp34_ = NULL;
gint _tmp35_ = 0;
gconstpointer _tmp36_ = NULL;
guint _tmp37_ = 0U;
guint _tmp38_ = 0U;
gint task_id = 0;
YatlaSidebar* _tmp39_ = NULL;
GList* _tmp40_ = NULL;
gint _tmp41_ = 0;
gconstpointer _tmp42_ = NULL;
GList* _tmp43_ = NULL;
gint _tmp44_ = 0;
gconstpointer _tmp45_ = NULL;
gint _tmp46_ = 0;
gint _tmp47_ = 0;
gchar* task_name = NULL;
YatlaSidebar* _tmp48_ = NULL;
GList* _tmp49_ = NULL;
gint _tmp50_ = 0;
gconstpointer _tmp51_ = NULL;
GList* _tmp52_ = NULL;
gint _tmp53_ = 0;
gconstpointer _tmp54_ = NULL;
const gchar* _tmp55_ = NULL;
const gchar* _tmp56_ = NULL;
gchar* _tmp57_ = NULL;
YatlaSidebar* _tmp58_ = NULL;
GList* _tmp59_ = NULL;
gint _tmp60_ = 0;
gconstpointer _tmp61_ = NULL;
GList* _tmp62_ = NULL;
gint _tmp63_ = 0;
gconstpointer _tmp64_ = NULL;
const gchar* _tmp65_ = NULL;
const gchar* _tmp66_ = NULL;
gchar* _tmp67_ = NULL;
GDateTime* task_date = NULL;
YatlaSidebar* _tmp68_ = NULL;
GList* _tmp69_ = NULL;
gint _tmp70_ = 0;
gconstpointer _tmp71_ = NULL;
GList* _tmp72_ = NULL;
gint _tmp73_ = 0;
gconstpointer _tmp74_ = NULL;
GDateTime* _tmp75_ = NULL;
GDateTime* _tmp76_ = NULL;
gboolean task_is_done = FALSE;
YatlaSidebar* _tmp87_ = NULL;
GList* _tmp88_ = NULL;
gint _tmp89_ = 0;
gconstpointer _tmp90_ = NULL;
GList* _tmp91_ = NULL;
gint _tmp92_ = 0;
gconstpointer _tmp93_ = NULL;
gboolean _tmp94_ = FALSE;
gboolean _tmp95_ = FALSE;
YatlaTask* task = NULL;
const gchar* _tmp96_ = NULL;
const gchar* _tmp97_ = NULL;
GDateTime* _tmp98_ = NULL;
gboolean _tmp99_ = FALSE;
YatlaTask* _tmp100_ = NULL;
YatlaTask* _tmp101_ = NULL;
gint _tmp102_ = 0;
const gchar* _tmp103_ = NULL;
gint _tmp104_ = 0;
gint _tmp105_ = 0;
guint _tmp106_ = 0U;
GtkCheckButton* checkBox = NULL;
const gchar* _tmp110_ = NULL;
GtkCheckButton* _tmp111_ = NULL;
GtkCheckButton* _tmp112_ = NULL;
gboolean _tmp113_ = FALSE;
GtkCheckButton* _tmp114_ = NULL;
GtkCheckButton* _tmp115_ = NULL;
GeeTreeMap* _tmp116_ = NULL;
YatlaTask* _tmp117_ = NULL;
GtkCheckButton* _tmp118_ = NULL;
GtkBox* _tmp119_ = NULL;
GtkCheckButton* _tmp120_ = NULL;
gint _tmp121_ = 0;
_data5_ = g_slice_new0 (Block5Data);
_data5_->_ref_count_ = 1;
_data5_->_data4_ = block4_data_ref (_data4_);
_tmp32_ = task_index;
_tmp33_ = _data4_->sidebar;
_tmp34_ = _tmp33_->sidebar_list;
_tmp35_ = list_index;
_tmp36_ = g_list_nth_data (_tmp34_, (guint) _tmp35_);
_tmp37_ = yatla_list_get_size ((YatlaList*) _tmp36_);
_tmp38_ = _tmp37_;
if (!(((guint) _tmp32_) != _tmp38_)) {
block5_data_unref (_data5_);
_data5_ = NULL;
break;
}
_tmp39_ = _data4_->sidebar;
_tmp40_ = _tmp39_->sidebar_list;
_tmp41_ = list_index;
_tmp42_ = g_list_nth_data (_tmp40_, (guint) _tmp41_);
_tmp43_ = ((YatlaList*) _tmp42_)->tasks;
_tmp44_ = task_index;
_tmp45_ = g_list_nth_data (_tmp43_, (guint) _tmp44_);
_tmp46_ = yatla_task_get_id ((YatlaTask*) _tmp45_);
_tmp47_ = _tmp46_;
task_id = _tmp47_;
_tmp48_ = _data4_->sidebar;
_tmp49_ = _tmp48_->sidebar_list;
_tmp50_ = list_index;
_tmp51_ = g_list_nth_data (_tmp49_, (guint) _tmp50_);
_tmp52_ = ((YatlaList*) _tmp51_)->tasks;
_tmp53_ = task_index;
_tmp54_ = g_list_nth_data (_tmp52_, (guint) _tmp53_);
_tmp55_ = yatla_task_get_name ((YatlaTask*) _tmp54_);
_tmp56_ = _tmp55_;
_tmp57_ = g_strdup (_tmp56_);
task_name = _tmp57_;
_tmp58_ = _data4_->sidebar;
_tmp59_ = _tmp58_->sidebar_list;
_tmp60_ = list_index;
_tmp61_ = g_list_nth_data (_tmp59_, (guint) _tmp60_);
_tmp62_ = ((YatlaList*) _tmp61_)->tasks;
_tmp63_ = task_index;
_tmp64_ = g_list_nth_data (_tmp62_, (guint) _tmp63_);
_tmp65_ = yatla_task_get_note ((YatlaTask*) _tmp64_);
_tmp66_ = _tmp65_;
_tmp67_ = g_strdup (_tmp66_);
_data5_->task_note = _tmp67_;
_tmp68_ = _data4_->sidebar;
_tmp69_ = _tmp68_->sidebar_list;
_tmp70_ = list_index;
_tmp71_ = g_list_nth_data (_tmp69_, (guint) _tmp70_);
_tmp72_ = ((YatlaList*) _tmp71_)->tasks;
_tmp73_ = task_index;
_tmp74_ = g_list_nth_data (_tmp72_, (guint) _tmp73_);
_tmp75_ = yatla_task_get_date ((YatlaTask*) _tmp74_);
_tmp76_ = _tmp75_;
if (_tmp76_ != NULL) {
YatlaSidebar* _tmp77_ = NULL;
GList* _tmp78_ = NULL;
gint _tmp79_ = 0;
gconstpointer _tmp80_ = NULL;
GList* _tmp81_ = NULL;
gint _tmp82_ = 0;
gconstpointer _tmp83_ = NULL;
GDateTime* _tmp84_ = NULL;
GDateTime* _tmp85_ = NULL;
GDateTime* _tmp86_ = NULL;
_tmp77_ = _data4_->sidebar;
_tmp78_ = _tmp77_->sidebar_list;
_tmp79_ = list_index;
_tmp80_ = g_list_nth_data (_tmp78_, (guint) _tmp79_);
_tmp81_ = ((YatlaList*) _tmp80_)->tasks;
_tmp82_ = task_index;
_tmp83_ = g_list_nth_data (_tmp81_, (guint) _tmp82_);
_tmp84_ = yatla_task_get_date ((YatlaTask*) _tmp83_);
_tmp85_ = _tmp84_;
_tmp86_ = _g_date_time_ref0 (_tmp85_);
_g_date_time_unref0 (task_date);
task_date = _tmp86_;
} else {
_g_date_time_unref0 (task_date);
task_date = NULL;
}
_tmp87_ = _data4_->sidebar;
_tmp88_ = _tmp87_->sidebar_list;
_tmp89_ = list_index;
_tmp90_ = g_list_nth_data (_tmp88_, (guint) _tmp89_);
_tmp91_ = ((YatlaList*) _tmp90_)->tasks;
_tmp92_ = task_index;
_tmp93_ = g_list_nth_data (_tmp91_, (guint) _tmp92_);
_tmp94_ = yatla_task_get_is_done ((YatlaTask*) _tmp93_);
_tmp95_ = _tmp94_;
task_is_done = _tmp95_;
_tmp96_ = task_name;
_tmp97_ = _data5_->task_note;
_tmp98_ = task_date;
_tmp99_ = task_is_done;
_tmp100_ = yatla_task_new (_tmp96_, _tmp97_, _tmp98_, _tmp99_);
task = _tmp100_;
_tmp101_ = task;
_tmp102_ = task_id;
yatla_task_set_id (_tmp101_, _tmp102_);
_tmp103_ = task_name;
_tmp104_ = strlen (_tmp103_);
_tmp105_ = _tmp104_;
_tmp106_ = the_longest_task;
if (((guint) _tmp105_) > _tmp106_) {
const gchar* _tmp107_ = NULL;
gint _tmp108_ = 0;
gint _tmp109_ = 0;
_tmp107_ = task_name;
_tmp108_ = strlen (_tmp107_);
_tmp109_ = _tmp108_;
the_longest_task = (guint) _tmp109_;
}
_tmp110_ = task_name;
_tmp111_ = (GtkCheckButton*) gtk_check_button_new_with_label (_tmp110_);
g_object_ref_sink (_tmp111_);
checkBox = _tmp111_;
_tmp112_ = checkBox;
_tmp113_ = task_is_done;
gtk_toggle_button_set_active ((GtkToggleButton*) _tmp112_, _tmp113_);
_tmp114_ = checkBox;
gtk_widget_set_has_tooltip ((GtkWidget*) _tmp114_, TRUE);
_tmp115_ = checkBox;
g_signal_connect_data ((GtkWidget*) _tmp115_, "query-tooltip", (GCallback) ____lambda4__gtk_widget_query_tooltip, block5_data_ref (_data5_), (GClosureNotify) block5_data_unref, 0);
_tmp116_ = self->tasks;
_tmp117_ = task;
_tmp118_ = checkBox;
gee_abstract_map_set ((GeeAbstractMap*) _tmp116_, _tmp117_, _tmp118_);
_tmp119_ = self->_tasks_box;
_tmp120_ = checkBox;
gtk_box_pack_start (_tmp119_, (GtkWidget*) _tmp120_, TRUE, TRUE, (guint) 0);
_tmp121_ = task_index;
task_index = _tmp121_ + 1;
_g_object_unref0 (checkBox);
_g_object_unref0 (task);
_g_date_time_unref0 (task_date);
_g_free0 (task_name);
block5_data_unref (_data5_);
_data5_ = NULL;
}
_tmp122_ = self->_top_box1;
gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp122_, 25, 20);
_tmp123_ = self->_top_box2;
gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp123_, 20, 40);
_tmp124_ = self->_tasks_box;
gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp124_, 20, 100);
_tmp125_ = the_longest_task;
g_object_set ((GtkLayout*) self, "width", 65 + (_tmp125_ * 7), NULL);
_tmp126_ = self->tasks;
_tmp127_ = gee_abstract_map_get_values ((GeeMap*) _tmp126_);
_tmp128_ = _tmp127_;
_tmp129_ = _tmp128_;
_tmp130_ = gee_collection_get_size (_tmp129_);
_tmp131_ = _tmp130_;
g_object_set ((GtkLayout*) self, "height", (guint) (100 + (_tmp131_ * 30)), NULL);
_g_object_unref0 (_tmp129_);
gtk_widget_show_all ((GtkWidget*) self);
_tmp132_ = self->new_task_entry;
g_signal_connect_data (_tmp132_, "icon-press", (GCallback) ___lambda5__gtk_entry_icon_press, block4_data_ref (_data4_), (GClosureNotify) block4_data_unref, 0);
_tmp133_ = self->tasks;
_tmp134_ = gee_abstract_map_map_iterator ((GeeAbstractMap*) _tmp133_);
map_iterator = _tmp134_;
while (TRUE) {
Block6Data* _data6_;
GeeMapIterator* _tmp135_ = NULL;
gboolean _tmp136_ = FALSE;
GeeMapIterator* _tmp137_ = NULL;
gpointer _tmp138_ = NULL;
GeeMapIterator* _tmp139_ = NULL;
gpointer _tmp140_ = NULL;
GtkCheckButton* _tmp141_ = NULL;
_data6_ = g_slice_new0 (Block6Data);
_data6_->_ref_count_ = 1;
_data6_->_data4_ = block4_data_ref (_data4_);
_tmp135_ = map_iterator;
_tmp136_ = gee_map_iterator_next (_tmp135_);
if (!_tmp136_) {
block6_data_unref (_data6_);
_data6_ = NULL;
break;
}
_tmp137_ = map_iterator;
_tmp138_ = gee_map_iterator_get_value (_tmp137_);
_data6_->checkBox = (GtkCheckButton*) _tmp138_;
_tmp139_ = map_iterator;
_tmp140_ = gee_map_iterator_get_key (_tmp139_);
_data6_->task = (YatlaTask*) _tmp140_;
_tmp141_ = _data6_->checkBox;
g_signal_connect_data ((GObject*) _tmp141_, "notify::active", (GCallback) ____lambda11__g_object_notify, block6_data_ref (_data6_), (GClosureNotify) block6_data_unref, 0);
block6_data_unref (_data6_);
_data6_ = NULL;
}
result = TRUE;
_g_object_unref0 (map_iterator);
block4_data_unref (_data4_);
_data4_ = NULL;
return result;
}
static void
nemo_mime_application_chooser_build_ui (NemoMimeApplicationChooser *chooser)
{
GtkWidget *box, *button;
GAppInfo *info;
gtk_container_set_border_width (GTK_CONTAINER (chooser), 8);
gtk_box_set_spacing (GTK_BOX (chooser), 0);
gtk_box_set_homogeneous (GTK_BOX (chooser), FALSE);
chooser->details->label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (chooser->details->label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (chooser->details->label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (chooser->details->label),
PANGO_WRAP_WORD_CHAR);
gtk_box_pack_start (GTK_BOX (chooser), chooser->details->label,
FALSE, FALSE, 0);
gtk_widget_show (chooser->details->label);
chooser->details->open_with_widget = gtk_app_chooser_widget_new (chooser->details->content_type);
gtk_app_chooser_widget_set_show_default (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_app_chooser_widget_set_show_fallback (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_box_pack_start (GTK_BOX (chooser), chooser->details->open_with_widget,
TRUE, TRUE, 6);
gtk_widget_show (chooser->details->open_with_widget);
g_signal_connect (chooser->details->open_with_widget, "application-selected",
G_CALLBACK (application_selected_cb),
chooser);
g_signal_connect (chooser->details->open_with_widget, "populate-popup",
G_CALLBACK (populate_popup_cb),
chooser);
gtk_app_chooser_widget_set_show_other (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_app_chooser_widget_set_show_recommended (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
GtkWidget *custom_label = gtk_label_new (_("You can also type or select a custom executable file to use to open this file type. "
"You can use this command just once, or set it as default for all files of this type."));
gtk_misc_set_alignment (GTK_MISC (custom_label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (custom_label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (custom_label),
PANGO_WRAP_WORD_CHAR);
gtk_box_pack_start (GTK_BOX (chooser), custom_label, FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (custom_label));
GtkWidget *custom_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (chooser), custom_box, TRUE, TRUE, 0);
GtkWidget *entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (custom_box), entry, TRUE, TRUE, 0);
gtk_entry_set_placeholder_text (GTK_ENTRY (entry), _("Enter a custom command..."));
g_signal_connect (entry, "changed",
G_CALLBACK (custom_entry_changed_cb),
chooser);
chooser->details->custom_entry = entry;
button = gtk_file_chooser_button_new (_("Custom application"), GTK_FILE_CHOOSER_ACTION_OPEN);
g_signal_connect (button, "file-set",
G_CALLBACK (custom_app_set_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (custom_box), button, FALSE, FALSE, 6);
gtk_widget_show_all (custom_box);
chooser->details->custom_picker = button;
box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_set_spacing (GTK_BOX (box), 6);
gtk_button_box_set_layout (GTK_BUTTON_BOX (box), GTK_BUTTONBOX_CENTER);
gtk_box_pack_start (GTK_BOX (chooser), box, FALSE, FALSE, 6);
gtk_widget_show (box);
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_mime_type (filter, "application/*");
gtk_file_filter_set_name (filter, _("Executables"));
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (button), filter);
button = gtk_button_new_with_label (_("Add to list"));
g_signal_connect (button, "clicked",
G_CALLBACK (add_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
chooser->details->add_button = button;
button = gtk_button_new_with_label (_("Set as default"));
g_signal_connect (button, "clicked",
G_CALLBACK (set_as_default_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
chooser->details->set_as_default_button = button;
button = gtk_button_new_with_label (_("Reset to system defaults"));
g_signal_connect (button, "clicked",
G_CALLBACK (reset_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
/* initialize sensitivity */
info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (chooser->details->open_with_widget));
if (info != NULL) {
application_selected_cb (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
info, chooser);
g_object_unref (info);
}
}
static void
ephy_find_toolbar_init (EphyFindToolbar *toolbar)
{
GtkWidget *box;
GtkSizeGroup *size_group;
size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_style_context_add_class (gtk_widget_get_style_context (box),
GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box),
GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (toolbar), box);
toolbar->entry = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (toolbar->entry), 32);
gtk_entry_set_max_length (GTK_ENTRY (toolbar->entry), 512);
gtk_entry_set_placeholder_text (GTK_ENTRY (toolbar->entry), _("Type to search…"));
gtk_container_add (GTK_CONTAINER (box), toolbar->entry);
/* Prev */
toolbar->prev = gtk_button_new_from_icon_name ("go-up-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_tooltip_text (toolbar->prev,
_("Find previous occurrence of the search string"));
gtk_container_add (GTK_CONTAINER (box), toolbar->prev);
gtk_widget_show_all (toolbar->prev);
gtk_widget_set_sensitive (toolbar->prev, FALSE);
/* Next */
toolbar->next = gtk_button_new_from_icon_name ("go-down-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_tooltip_text (toolbar->next,
_("Find next occurrence of the search string"));
gtk_container_add (GTK_CONTAINER (box), toolbar->next);
gtk_widget_set_sensitive (toolbar->next, FALSE);
gtk_size_group_add_widget (size_group, toolbar->entry);
gtk_size_group_add_widget (size_group, toolbar->next);
gtk_size_group_add_widget (size_group, toolbar->prev);
g_object_unref (size_group);
/* connect signals */
g_signal_connect (toolbar->entry, "icon-release",
G_CALLBACK (search_entry_clear_cb), toolbar);
g_signal_connect (toolbar->entry, "key-press-event",
G_CALLBACK (entry_key_press_event_cb), toolbar);
g_signal_connect_after (toolbar->entry, "changed",
G_CALLBACK (search_entry_changed_cb), toolbar);
g_signal_connect (toolbar->entry, "activate",
G_CALLBACK (entry_activate_cb), toolbar);
g_signal_connect_swapped (toolbar->next, "clicked",
G_CALLBACK (ephy_find_toolbar_find_next), toolbar);
g_signal_connect_swapped (toolbar->prev, "clicked",
G_CALLBACK (ephy_find_toolbar_find_previous), toolbar);
gtk_search_bar_connect_entry (GTK_SEARCH_BAR (toolbar),
GTK_ENTRY (toolbar->entry));
search_entry_changed_cb (GTK_ENTRY (toolbar->entry), toolbar);
gtk_widget_show_all (GTK_WIDGET (toolbar));
}
/**
* Creates empty main application window
*/
GtkWidget
*create_mainwindow (ezeedo_wrapper_structure *ezeedo)
{
// define widgets
GtkWidget *window;
GtkWidget *headerbar;
GtkWidget *windowmenu_button;
GtkWidget *stack;
GtkWidget *stackswitcher;
GtkWidget *todo_stack;
GtkWidget *todo_paned;
GtkWidget *todolist_scrollbox;
GtkWidget *todolist_box;
GtkWidget *categories_scrollbox;
GtkWidget *categories_box;
GtkWidget *task_entry;
GtkWidget *done_stack;
GtkWidget *donelist_scrollbox;
GtkWidget *donelist_box;
GtkWidget *archive_button;
// define action
GSimpleAction *about_action;
// get window size and position from gsettings store
GSettings *settings;
gint width;
gint height;
gint x;
gint y;
gint sidebar_size;
settings = g_settings_new ("org.y20k.ezeedo");
width = g_settings_get_int (settings,
"main-window-width");
height = g_settings_get_int (settings,
"main-window-height");
x = g_settings_get_int (settings,
"main-window-position-y");
y = g_settings_get_int (settings,
"main-window-position-y");
sidebar_size = g_settings_get_int (settings,
"sidebar-size");
g_object_unref (settings);
// create main window with title and default size
window = gtk_application_window_new (ezeedo->application);
gtk_window_set_title (GTK_WINDOW (window),
"Ezeedo");
gtk_window_set_icon_name (GTK_WINDOW (window),
EZEEDOICON);
gtk_window_set_default_size (GTK_WINDOW (window),
width,
height);
gtk_window_move (GTK_WINDOW (window),
x,
y);
// create headerbar and stack switcher
headerbar = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(headerbar),
true);
stackswitcher = gtk_stack_switcher_new ();
// create stack for todo and done
stack = gtk_stack_new ();
// create stack for todolist
todo_stack = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create paned container for left and right columns of todo tab
todo_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position (GTK_PANED(todo_paned),
sidebar_size);
// create categories scrollbox and box for left pane
categories_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
categories_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create todolist scrollbox and box for right pane
todolist_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
todolist_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create task entry
task_entry = gtk_entry_new ();
gtk_widget_set_margin_start (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_end (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_top (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_bottom (GTK_WIDGET(task_entry),
10);
gtk_entry_set_placeholder_text (GTK_ENTRY(task_entry),
"Enter new task");
gtk_entry_set_max_length (GTK_ENTRY(task_entry),
TASKLENGTH);
gtk_widget_grab_focus (task_entry);
// create stack for donelist
done_stack = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create donelist scrollbox and box
donelist_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
donelist_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create archive button
archive_button = gtk_button_new_with_label ("Archive all done tasks");
gtk_widget_set_margin_start (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_end (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_top (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_bottom (GTK_WIDGET (archive_button),
10);
// add some widgets to ezeedo wrapper structure
ezeedo->window = window;
ezeedo->todo_paned = todo_paned;
ezeedo->categories_box = categories_box;
ezeedo->todolist_box = todolist_box;
ezeedo->donelist_box = donelist_box;
// create window menu
windowmenu_button = create_windowmenu (ezeedo);
// create about action and connect about action signal
about_action = g_simple_action_new ("about",
NULL);
g_action_map_add_action (G_ACTION_MAP (window),
G_ACTION (about_action));
g_signal_connect (about_action, "activate",
G_CALLBACK (show_about_window), window);
// detect entry signal
g_signal_connect (task_entry, "activate",
G_CALLBACK (add_task_entry), ezeedo);
// detect archive button pressed
g_signal_connect (archive_button, "clicked",
G_CALLBACK (display_info_dialog), "Task archival is not supported yet.");
// detect window close
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (close_window), ezeedo);
// construct headerbar for main window
gtk_window_set_titlebar (GTK_WINDOW(window),
headerbar);
gtk_header_bar_pack_start (GTK_HEADER_BAR(headerbar),
stackswitcher);
gtk_header_bar_pack_end (GTK_HEADER_BAR(headerbar),
windowmenu_button);
// add stack to main window
gtk_container_add (GTK_CONTAINER(window),
stack);
// set stack switcher and populate stack with todolist and donelist
gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER(stackswitcher),
GTK_STACK(stack));
gtk_stack_add_titled (GTK_STACK(stack),
todo_stack,
"To do",
"To do");
gtk_stack_add_titled (GTK_STACK(stack),
done_stack,
"Done",
"Done");
// construct main todo stack
gtk_container_add (GTK_CONTAINER(todo_stack),
todo_paned);
gtk_paned_add1 (GTK_PANED(todo_paned),
categories_scrollbox);
gtk_paned_add2 (GTK_PANED(todo_paned),
todolist_scrollbox);
// add box to scrollable box
gtk_container_add (GTK_CONTAINER(todolist_scrollbox),
todolist_box);
// add task entry to todo stack
gtk_container_add (GTK_CONTAINER(todo_stack),
task_entry);
// add box to scrollable box
gtk_container_add (GTK_CONTAINER(categories_scrollbox),
categories_box);
// construct main donelist stack
gtk_container_add (GTK_CONTAINER(done_stack),
donelist_scrollbox);
gtk_container_add (GTK_CONTAINER(donelist_scrollbox),
donelist_box);
return (window);
}
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);
}
void
Delete_side(GtkWidget *widget, GtkWidget *stack){
widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
static FZ_Delete field;
// widget = gtk_label_new ("Este assistente ira ajuda-lo a\nDeletar um Banco de Dados.");
GtkWidget *container_label,
*container_entry,
*label_all,
*button_refresh
;
/* Label's */
container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_halign(container_label, GTK_ALIGN_END);
gtk_container_add(GTK_CONTAINER(widget), container_label);
/* Banco de Dados */
label_all = gtk_label_new("Banco de Dados: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Senha Mestre */
label_all = gtk_label_new("Senha Master: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Button Refresh */
button_refresh = gtk_button_new_with_label("Atualizar");
gtk_box_pack_start(GTK_BOX(container_label), button_refresh, FALSE, FALSE, 0);
// Entry's
container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(widget), container_entry);
gtk_widget_set_hexpand(container_entry, TRUE);
/* Banco de Dados */
field.combo_db = gtk_combo_box_text_new ();
gtk_widget_set_tooltip_text(field.combo_db, "Banco de Dados.");
gtk_box_pack_start(GTK_BOX(container_entry), field.combo_db, FALSE, FALSE, 0);
/* Code Builder or password SuperUser */
field.entry_pwd=gtk_entry_new();
gtk_widget_set_tooltip_text(field.entry_pwd, "Digite a senha de Super Usuario.");
gtk_entry_set_visibility(GTK_ENTRY(field.entry_pwd), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_pwd), "Senha Mestre");
gtk_box_pack_start(GTK_BOX(container_entry), field.entry_pwd, FALSE, FALSE, 0);
/* Button Refresh */
field.button = gtk_button_new_with_label("Deletar");
gtk_box_pack_start(GTK_BOX(container_entry), field.button, FALSE, FALSE, 0);
gtk_stack_add_named (GTK_STACK (stack), widget, "Deletar");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Deletar", NULL);
//TODO Criar os sinais refresh e delete.
g_signal_connect (GTK_BUTTON (button_refresh),
"clicked",
G_CALLBACK (button_refresh_delete_clicked),
(gpointer) &field);
}
void _fcitx_main_window_add_addon_page(FcitxMainWindow* self)
{
/* load addon */
FcitxAddon* addon;
utarray_new(self->addons, &addonicd);
FcitxAddonsLoad(self->addons);
GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
/* advance check box */
self->advancecheckbox = gtk_check_button_new_with_label(_("Advance"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->advancecheckbox), FALSE);
g_signal_connect(G_OBJECT(self->advancecheckbox), "toggled", G_CALLBACK(_fcitx_main_window_checkbox_changed), self);
/* filter entry */
self->filterentry = gtk_entry_new();
gtk_entry_set_icon_from_stock (GTK_ENTRY (self->filterentry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_CLEAR);
g_object_set(G_OBJECT(self->filterentry), "margin", 5, NULL);
#if GTK_CHECK_VERSION(3,2,0)
gtk_entry_set_placeholder_text(GTK_ENTRY (self->filterentry), _("Search Addon"));
#endif
g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL);
gtk_box_pack_start(GTK_BOX(vbox), self->filterentry, FALSE, TRUE, 5);
/* list view */
self->addonstore = gtk_list_store_new(N_COLUMNS, G_TYPE_POINTER);
for (addon = (FcitxAddon *) utarray_front(self->addons);
addon != NULL;
addon = (FcitxAddon *) utarray_next(self->addons, addon)) {
GtkTreeIter iter;
gtk_list_store_append(self->addonstore, &iter);
gtk_list_store_set(self->addonstore, &iter, LIST_ADDON, addon, -1);
}
self->filtermodel = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->addonstore), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel),
(GtkTreeModelFilterVisibleFunc) _filter_addon_func,
self,
NULL);
self->addonview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->filtermodel));
/* add column check box */
self->togglecell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE);
self->checkboxcolumn = gtk_tree_view_column_new_with_attributes("Enable", self->togglecell, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), self->checkboxcolumn);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(self->checkboxcolumn),
self->togglecell,
_fcitx_main_window_enabled_data_func,
NULL,
NULL);
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE);
/* add column text */
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Name", renderer, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), column);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column),
renderer,
_fcitx_main_window_name_data_func,
NULL,
NULL);
/* add addon list to vbox */
GtkWidget* swin = gtk_scrolled_window_new(NULL, NULL);
g_object_set(swin, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
g_object_set(self->addonview, "headers-visible", FALSE, NULL);
gtk_container_add(GTK_CONTAINER(swin), self->addonview);
gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
g_object_set(G_OBJECT(swin), "margin-left", 5, "margin-right", 5, "shadow-type", GTK_SHADOW_IN, NULL);
g_signal_connect(G_OBJECT(self->togglecell), "toggled",
G_CALLBACK(_fcitx_main_window_toggled_cb), GTK_TREE_MODEL(self->addonstore));
gtk_box_pack_start(GTK_BOX(vbox), self->advancecheckbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(self->advancecheckbox), "margin-left", 5, "margin-right", 5, NULL);
/* configure button */
GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL);
self->button = gtk_button_new_with_label(_("Configure"));
gtk_widget_set_sensitive(self->button, FALSE);
gtk_button_set_image(GTK_BUTTON(self->button), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start(GTK_BOX(hbuttonbox), self->button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(self->button), "clicked", G_CALLBACK(_fcitx_main_window_configure_button_clicked), self);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->addonview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(_fcitx_main_window_addon_selection_changed), self);
g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_main_window_filtertext_changed), self);
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
_fcitx_main_window_add_page(self, _("Addon"), vbox, GTK_STOCK_ADD);
}
void
Create_side(GtkWidget *widget, GtkWidget *stack){
widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
//widget = gtk_label_new ("Este assistente ira ajuda-lo a Criar um Banco de Dados.");
static FZ_Create field;// caso não for static da pau
GtkWidget *container_all,
*container_label,
*container_entry,
*label_all
;
// Container all
container_all = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(widget), container_all);
// Label's
container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_halign(container_label, GTK_ALIGN_END);
gtk_container_add(GTK_CONTAINER(container_all), container_label);
/* nome do DB */
label_all = gtk_label_new ("Novo Banco de Dados: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Code Builder or password SuperUser */
label_all = gtk_label_new ("Senha Master: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* ROOT Password */
label_all = gtk_label_new ("Senha do Administrador: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
label_all = gtk_label_new ("Confirme a Senha do Administrador: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
// Entry's
container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(container_all), container_entry);
gtk_widget_set_hexpand(container_entry, TRUE);
/* nome do DB */
field.entry_db=gtk_entry_new();
gtk_widget_set_tooltip_text(field.entry_db, "Digite o Novo Nome do Banco de Dados.");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_db), "Banco de Dados");
gtk_box_pack_start(GTK_BOX(container_entry), field.entry_db, FALSE, FALSE, 0);
/* Code Builder or password SuperUser */
field.entry_pwd=gtk_entry_new();
gtk_widget_set_tooltip_text(field.entry_pwd, "Digite a senha de Super Usuario.");
gtk_entry_set_visibility(GTK_ENTRY(field.entry_pwd), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_pwd), "Senha Mestre");
gtk_box_pack_start(GTK_BOX(container_entry), field.entry_pwd, FALSE, FALSE, 0);
/* ROOT Password */
field.rootpwd = gtk_entry_new();
gtk_widget_set_tooltip_text(field.rootpwd, "Digite a senha de Adimistrador do Novo Banco de Dados (login:admin).");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.rootpwd), "Senha do Administrador");
gtk_entry_set_visibility(GTK_ENTRY(field.rootpwd), FALSE);
gtk_box_pack_start(GTK_BOX(container_entry), field.rootpwd, FALSE, FALSE, 0);
/* ROOT Password Reply */
field.rootpwd_reply = gtk_entry_new();
gtk_widget_set_tooltip_text(field.rootpwd_reply, "Digite a senha de Adimistrador do Novo Banco de Dados (login:admin).");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.rootpwd_reply), "Confirme a Senha");
gtk_entry_set_visibility(GTK_ENTRY(field.rootpwd_reply), FALSE);
gtk_box_pack_start(GTK_BOX(container_entry), field.rootpwd_reply, FALSE, FALSE, 0);
/* Demo info preload */
field.demo = gtk_check_button_new_with_label("Demostração?");
gtk_widget_set_halign(field.demo, GTK_ALIGN_CENTER);
gtk_widget_set_tooltip_text(field.demo, "Se na criação as informações de Demostração serão instaladas.");
gtk_container_add(GTK_CONTAINER(widget), field.demo);
/* Botão de Criar */
field.button = gtk_button_new_with_label ("Criar");
gtk_widget_set_tooltip_text(field.button, "Sera ativado quando as Informações estiverem corretas.");
gtk_widget_set_sensitive (field.button, FALSE);// disable button
g_signal_connect (GTK_BUTTON (field.button),
"clicked",
G_CALLBACK (button_create_clicked),
(gpointer) &field);
gtk_container_add( GTK_CONTAINER(widget) ,field.button );
gtk_stack_add_named (GTK_STACK (stack), widget, "Criar");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Criar", NULL);
/* Validate Focus */
g_signal_connect (GTK_ENTRY (field.entry_db),
"focus-out-event",
G_CALLBACK (validate_create_focus),
(gpointer) &field);
g_signal_connect (GTK_ENTRY (field.entry_pwd),
"focus-out-event",
G_CALLBACK (validate_create_focus),
(gpointer) &field);
g_signal_connect (GTK_ENTRY (field.rootpwd),
"focus-out-event",
G_CALLBACK (validate_create_focus),
(gpointer) &field);
g_signal_connect (GTK_ENTRY (field.rootpwd_reply),
"focus-out-event",
G_CALLBACK (validate_create_focus),
(gpointer) &field);
}
void
Restore_side(GtkWidget *widget, GtkWidget *stack){
//TODO create GUI
widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
static FZ_Restore field;
// widget = gtk_label_new ("Este assistente ira ajuda-lo a\nRestaurar um Backup de um Banco de Dados.");
GtkWidget *container_label,
*container_entry,
*label_all
;
/* Label's */
container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_halign(container_label, GTK_ALIGN_END);
gtk_container_add(GTK_CONTAINER(widget), container_label);
/* File */
label_all = gtk_label_new("Arquivo: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Password */
label_all = gtk_label_new("Senha Mestre: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* New DB */
label_all = gtk_label_new("Nova Base de Dados: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
// Entry's
container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(widget), container_entry);
gtk_widget_set_hexpand(container_entry, TRUE);
/* File */
field.chooser = gtk_file_chooser_button_new (_("Select a file"), GTK_FILE_CHOOSER_ACTION_OPEN);
field.filter = gtk_file_filter_new ();
gtk_file_filter_set_name (field.filter, _("SQL/Dump"));
gtk_file_filter_add_mime_type(field.filter, "application/sql");
//gtk_file_filter_add_mime_type(field.filter, "application/octet-stream");
gtk_file_filter_add_pattern (field.filter, "*.dump");
//gtk_file_filter_add_pattern (field.filter, "*.sql");
g_object_ref_sink (field.filter);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (field.chooser), FALSE);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(field.chooser), field.filter);
gtk_box_pack_start(GTK_BOX(container_entry), field.chooser, FALSE, FALSE, 0);
/* Code Builder or password SuperUser */
field.entry_pwd=gtk_entry_new();
gtk_widget_set_tooltip_text(field.entry_pwd, "Digite a senha de Super Usuario.");
gtk_entry_set_visibility(GTK_ENTRY(field.entry_pwd), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_pwd), "Senha Mestre");
gtk_box_pack_start(GTK_BOX(container_entry), field.entry_pwd, FALSE, FALSE, 0);
/* Code Builder or password SuperUser */
field.new_dbname=gtk_entry_new();
gtk_widget_set_tooltip_text(field.new_dbname, "Digite o nome do Novo banco de dados.");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.new_dbname), "Nome da Nova Base");
gtk_box_pack_start(GTK_BOX(container_entry), field.new_dbname, FALSE, FALSE, 0);
//TODO to continue...
gtk_stack_add_named (GTK_STACK (stack), widget, "Restaurar");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Restaurar", NULL);
}
static void
fcitx_im_dialog_init(FcitxImDialog* self)
{
gtk_window_set_title(GTK_WINDOW(self), _("Add input method"));
gtk_window_set_modal(GTK_WINDOW(self), TRUE);
gtk_dialog_add_buttons(GTK_DIALOG(self),
_("_Cancel"),
GTK_RESPONSE_CANCEL,
_("_OK"),
GTK_RESPONSE_OK,
NULL
);
g_signal_connect(self, "response",
G_CALLBACK(_fcitx_im_dialog_response_cb),
NULL);
self->langset = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
self->builder = gtk_builder_new();
gtk_builder_add_from_resource(self->builder, "/org/fcitx/fcitx-config-gtk3/im_dialog.ui", NULL);
const gchar* lang = _get_current_lang();
gchar* language = NULL, *territory = NULL;
gdm_parse_language_name(lang, &language, &territory, NULL, NULL);
if (!language || language[0] == '\0') {
self->language = g_strdup("C");
} else {
gboolean tisempty = (!territory || territory[0] == '\0');
self->language = g_strdup_printf("%s%s%s", language, tisempty ? "" : "_", tisempty ? "" : territory);
}
g_free(language);
g_free(territory);
#define _GET_OBJECT(NAME) \
self->NAME = (typeof(self->NAME)) gtk_builder_get_object(self->builder, #NAME);
_GET_OBJECT(availimstore)
_GET_OBJECT(availimview)
_GET_OBJECT(filterentry)
_GET_OBJECT(filtermodel)
_GET_OBJECT(onlycurlangcheckbox)
_GET_OBJECT(sortmodel)
gtk_entry_set_placeholder_text(GTK_ENTRY(self->filterentry), _("Search Input Method"));
gtk_widget_set_size_request(GTK_WIDGET(self), 400, 300);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel),
(GtkTreeModelFilterVisibleFunc) _fcitx_im_dialog_filter_func,
self ,
NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(self->sortmodel), IM_LIST_IM, _fcitx_im_dialog_sort_func, self, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(self->sortmodel), IM_LIST_IM, GTK_SORT_ASCENDING);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self->availimview), FALSE);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->availimview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(_fcitx_im_dialog_im_selection_changed), self);
g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_im_dialog_filtertext_changed), self);
g_signal_connect(G_OBJECT(self->onlycurlangcheckbox), "toggled", G_CALLBACK(_fcitx_im_dialog_onlycurlangcheckbox_toggled), self);
g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL);
}
static GtkWidget* parametrs_widget_new() {
GtkWidget *vbox;
GtkWidget *function_name_label;
GtkWidget *interval_label;
GtkWidget *interval_hbox;
GtkWidget *parametrs_label;
GtkWidget *draw_button_image;
GtkWidget *draw_button;
GtkWidget *separator_0;
GtkWidget *separator_1;
GtkWidget *separator_2;
GtkWidget *parametrs_grid;
/* Создание виджетов окна параметров */
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
function_name_label = gtk_label_new(FUNCTION_NAME);
separator_0 = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
interval_label = gtk_label_new("Выберите интервал");
interval_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
entry[LEFT_BOUND] = gtk_entry_new();
entry[RIGHT_BOUND] = gtk_entry_new();
separator_1 = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
parametrs_label = gtk_label_new("Введите параметры");
parametrs_grid = gtk_grid_new();
entry[PARAMETR_A] = gtk_entry_new();
entry[PARAMETR_B] = gtk_entry_new();
entry[PARAMETR_C] = gtk_entry_new();
entry[PARAMETR_D] = gtk_entry_new();
separator_2 = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
draw_button_image = gtk_image_new_from_file(DRAW_BUTTON_IMAGE);
draw_button = gtk_button_new_with_label("Отрисовать");
/* Настройка виджетов окна параметров */
gtk_label_set_use_markup(GTK_LABEL(function_name_label), TRUE);
gtk_grid_set_row_spacing(GTK_GRID(parametrs_grid), 5);
gtk_grid_set_column_spacing(GTK_GRID(parametrs_grid), 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[LEFT_BOUND]), "α");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[RIGHT_BOUND]), "β");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[PARAMETR_A]), "a");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[PARAMETR_B]), "b");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[PARAMETR_C]), "c");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry[PARAMETR_D]), "d");
gtk_button_set_image(GTK_BUTTON(draw_button), draw_button_image);
/* Упаковка окна параметров */
gtk_box_pack_start(GTK_BOX(vbox), function_name_label, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), separator_0, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(interval_hbox), entry[LEFT_BOUND], FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(interval_hbox), entry[RIGHT_BOUND], FALSE, TRUE, 0);
gtk_grid_attach(GTK_GRID(parametrs_grid), entry[PARAMETR_A], 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(parametrs_grid), entry[PARAMETR_B], 1, 0, 1, 1);
gtk_grid_attach(GTK_GRID(parametrs_grid), entry[PARAMETR_C], 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(parametrs_grid), entry[PARAMETR_D], 1, 1, 1, 1);
gtk_box_pack_start(GTK_BOX(vbox), interval_label, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), interval_hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), separator_1, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(vbox), parametrs_label, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), parametrs_grid, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(vbox), separator_2, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(vbox), draw_button, FALSE, TRUE, 0);
g_signal_connect(draw_button, "released", G_CALLBACK(draw_button_clicked), NULL);
g_signal_connect(drawing_area, "draw", G_CALLBACK(draw_callback), NULL);
return vbox;
}
/*!
* \fn G_MODULE_EXPORT void preparePageAssistantNewCsu(GtkAssistant *assistant,GtkWidget *widget, gpointer data)
* Prepare the new pages
* \param[in] assistant the GtkAssistant
* \param[in] widget the widget which send the signal
* \param[in] data the globalData
*/
G_MODULE_EXPORT void preparePageAssistantNewCsu(GtkAssistant *assistant,GtkWidget *widget, gpointer data)
{
globalData *user_data = (globalData*) data;
gint page = gtk_assistant_get_current_page(assistant);
gint nb_ligne=0;
gint i;
if (page == 1)
{
/* Calculate the number of line which already exist */
GtkGrid *grid = GTK_GRID(gtk_bin_get_child(GTK_BIN(gtk_bin_get_child(GTK_BIN(widget)))));
while(gtk_grid_get_child_at(grid,0,nb_ligne) != 0)
nb_ligne++;
/* Add the missing lines */
for (i=nb_ligne ; i<user_data->ptr_csu_struct_tmp->nb_player ; i++)
{
gtk_grid_attach(grid,gtk_label_new(g_strdup_printf(_("Name of the %dth player"),i+1)),0,i,1,1);
gtk_grid_attach(grid,gtk_entry_new(),1,i,1,1);
gtk_entry_set_max_length(GTK_ENTRY(gtk_grid_get_child_at(GTK_GRID(grid),1,i)),SIZE_MAX_NAME);
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_grid_get_child_at(GTK_GRID(grid),1,i)),g_strdup_printf(_("Type here the name of the %dth player"),i+1));
gtk_entry_set_alignment(GTK_ENTRY(gtk_grid_get_child_at(GTK_GRID(grid),1,i)),0.5);
g_signal_connect(gtk_grid_get_child_at(GTK_GRID(grid),1,i),"changed", G_CALLBACK(validAssistantNewCsuTwo),user_data);
}
/* Remove the unwanted lines */
for (i = nb_ligne ; i > user_data->ptr_csu_struct_tmp->nb_player ; i--)
{
gtk_widget_destroy(gtk_grid_get_child_at(grid,0,i-1));
gtk_widget_destroy(gtk_grid_get_child_at(grid,1,i-1));
}
validAssistantNewCsuTwo(NULL,user_data);
gtk_widget_show_all(GTK_WIDGET(grid));
}
if (page == 2)
{
GtkGrid *grid = GTK_GRID(widget);
/* If there is no distributor valid the page 3 */
if (user_data->ptr_csu_struct_tmp->config.use_distributor == 0)
{
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(gtk_grid_get_child_at(grid,1,0)));
gtk_assistant_set_page_complete(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),GTK_WIDGET(grid),TRUE);
}
/* Otherwise Create a combo box to choose the distributor */
else
{
gint index = gtk_combo_box_get_active(GTK_COMBO_BOX(gtk_grid_get_child_at(grid,1,0)));
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(gtk_grid_get_child_at(grid,1,0)));
for (i = 0 ; i<user_data->ptr_csu_struct_tmp->nb_player ; i++)
gtk_combo_box_text_insert(GTK_COMBO_BOX_TEXT(gtk_grid_get_child_at(grid,1,0)),i,NULL,user_data->ptr_csu_struct_tmp->player_names[i]);
/* If the last distributor still exist, choose it */
if (index <= user_data->ptr_csu_struct_tmp->nb_player)
gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_grid_get_child_at(grid,1,0)),index);
validAssistantNewCsuThree(NULL,user_data);
}
}
if (page == 0)
validAssistantNewCsuOne(NULL,user_data);
}
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 ++;
}
void
Advanced_side(GtkWidget *widget, GtkWidget *stack){
widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
static FZ_Advanced field;
// widget = gtk_label_new ("Isto ira configurar as info de conexão.");
GtkWidget *container_label,
*container_entry,
*label_all,
*button_refresh,
*container_all
;
GtkAdjustment *adjustment;
/* Create an adjustment representing an adjustable bounded value */
//adjustment = gtk_adjustment_new (5432, 0, G_MAXDOUBLE, 1, 0, 0);
adjustment = gtk_adjustment_new (5432, 0, 100000, 1, 0, 0);
container_all = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(widget), container_all);
//
// Label's
//
container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_halign(container_label, GTK_ALIGN_END);
gtk_container_add(GTK_CONTAINER(container_all), container_label);
/* Host Server IP */
label_all = gtk_label_new("IP: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Host Server Port */
label_all = gtk_label_new("Porta: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Host Server User */
label_all = gtk_label_new("Usuario: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Host Server PassWord */
label_all = gtk_label_new("Senha: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
//
// Entry's
//
container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(container_all), container_entry);
gtk_widget_set_hexpand(container_entry, TRUE);
/* Host Server IP */
field.Host = gtk_entry_new ();
gtk_widget_set_tooltip_text(field.Host, "IP do Servidor do banco de dados...\nEX:localhost");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.Host), "EX: localhost");
gtk_box_pack_start(GTK_BOX(container_entry), field.Host, FALSE, FALSE, 0);
/* Host Server Porta */
//field.Port = gtk_entry_new ();
field.Port = gtk_spin_button_new (adjustment, 1, 0);
gtk_widget_set_tooltip_text(field.Port, "Porta do Servidor do banco de dados...\nEX: 5432");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.Port), "EX: 5432");
gtk_box_pack_start(GTK_BOX(container_entry), field.Port, FALSE, FALSE, 0);
/* Host Server User */
field.Login = gtk_entry_new ();
gtk_widget_set_tooltip_text(field.Login, "Usuario do banco de dados...");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.Login), "Usuario");
gtk_box_pack_start(GTK_BOX(container_entry), field.Login, FALSE, FALSE, 0);
/* Host Server PassWord */
field.PassWord = gtk_entry_new ();
gtk_widget_set_tooltip_text(field.PassWord, "Senha do Usuario do banco de dados...");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.PassWord), "Senha");
gtk_entry_set_visibility(GTK_ENTRY(field.PassWord), FALSE);
gtk_box_pack_start(GTK_BOX(container_entry), field.PassWord, FALSE, FALSE, 0);
/* Buttons */
//container_button_all = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
//gtk_container_add(GTK_CONTAINER(container_all), container_button_all);
field.button_load = gtk_button_new_with_label("Ler");
gtk_box_pack_start(GTK_BOX(widget), field.button_load, FALSE, FALSE, 0);
field.button_save = gtk_button_new_with_label("Salvar");
gtk_box_pack_start(GTK_BOX(widget), field.button_save, FALSE, FALSE, 0);
gtk_stack_add_named (GTK_STACK (stack), widget, "Avançado");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Avançado", NULL);
/* Sinais */
g_signal_connect (GTK_BUTTON (field.button_load),
"clicked",
G_CALLBACK (button_load_conf_clicked),
(gpointer) &field);
g_signal_connect (GTK_BUTTON (field.button_save),
"clicked",
G_CALLBACK (button_save_conf_clicked),
(gpointer) &field);
}
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);
}
static void
ring_main_window_init(RingMainWindow *win)
{
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
gtk_widget_init_template(GTK_WIDGET(win));
/* set window icon */
GError *error = NULL;
GdkPixbuf* icon = gdk_pixbuf_new_from_resource("/cx/ring/RingGnome/ring-symbol-blue", &error);
if (icon == NULL) {
g_debug("Could not load icon: %s", error->message);
g_clear_error(&error);
} else
gtk_window_set_icon(GTK_WINDOW(win), icon);
/* set menu icon */
GdkPixbuf* image_ring = gdk_pixbuf_new_from_resource_at_scale("/cx/ring/RingGnome/ring-symbol-blue",
-1, 24, TRUE, &error);
if (image_ring == NULL) {
g_debug("Could not load icon: %s", error->message);
g_clear_error(&error);
} else
gtk_image_set_from_pixbuf(GTK_IMAGE(priv->image_ring), image_ring);
/* ring menu */
GtkBuilder *builder = gtk_builder_new_from_resource("/cx/ring/RingGnome/ringgearsmenu.ui");
GMenuModel *menu = G_MENU_MODEL(gtk_builder_get_object(builder, "menu"));
gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(priv->ring_menu), menu);
g_object_unref(builder);
/* settings icon */
gtk_image_set_from_icon_name(GTK_IMAGE(priv->image_settings), "emblem-system-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
/* connect settings button signal */
g_signal_connect(priv->ring_settings, "clicked", G_CALLBACK(settings_clicked), win);
/* add the call view to the main stack */
gtk_stack_add_named(GTK_STACK(priv->stack_main_view),
priv->vbox_call_view,
CALL_VIEW_NAME);
if (has_ring_account()) {
/* user has ring account, so show the call view right away */
gtk_stack_set_visible_child(GTK_STACK(priv->stack_main_view), priv->vbox_call_view);
} else {
/* user has to create the ring account */
show_account_creation(win);
}
/* init the settings views */
priv->account_settings_view = account_view_new();
gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->account_settings_view, ACCOUNT_SETTINGS_VIEW_NAME);
priv->media_settings_view = media_settings_view_new();
gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->media_settings_view, MEDIA_SETTINGS_VIEW_NAME);
priv->general_settings_view = general_settings_view_new();
gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->general_settings_view, GENERAL_SETTINGS_VIEW_NAME);
/* make the setting we will show first the active one */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->radiobutton_general_settings), TRUE);
priv->last_settings_view = priv->general_settings_view;
/* connect the settings button signals to switch settings views */
g_signal_connect(priv->radiobutton_media_settings, "toggled", G_CALLBACK(show_media_settings), win);
g_signal_connect(priv->radiobutton_account_settings, "toggled", G_CALLBACK(show_account_settings), win);
g_signal_connect(priv->radiobutton_general_settings, "toggled", G_CALLBACK(show_general_settings), win);
/* populate the notebook */
auto smart_view = recent_contacts_view_new();
gtk_container_add(GTK_CONTAINER(priv->scrolled_window_smartview), smart_view);
auto contacts_view = contacts_view_new();
gtk_container_add(GTK_CONTAINER(priv->scrolled_window_contacts), contacts_view);
auto history_view = history_view_new();
gtk_container_add(GTK_CONTAINER(priv->scrolled_window_history), history_view);
/* welcome/default view */
priv->welcome_view = ring_welcome_view_new();
g_object_ref(priv->welcome_view);
// gtk_stack_add_named(GTK_STACK(priv->stack_call_view), welcome_view, DEFAULT_VIEW_NAME);
gtk_container_add(GTK_CONTAINER(priv->frame_call), priv->welcome_view);
gtk_widget_show(priv->welcome_view);
/* call/chat selection */
QObject::connect(
RecentModel::instance().selectionModel(),
&QItemSelectionModel::currentChanged,
[win](const QModelIndex current, G_GNUC_UNUSED const QModelIndex & previous) {
if (auto call = RecentModel::instance().getActiveCall(current)) {
/* if the call is on hold, we want to put it off hold automatically
* when switching to it */
if (call->state() == Call::State::HOLD)
call << Call::Action::HOLD;
}
selection_changed(current, win);
}
);
/* connect to dataChanged of the RecentModel to see if we need to change the view */
QObject::connect(
&RecentModel::instance(),
&RecentModel::dataChanged,
[win](const QModelIndex & topLeft, G_GNUC_UNUSED const QModelIndex & bottomRight, G_GNUC_UNUSED const QVector<int> & roles) {
/* it is possible for dataChanged to be emitted inside of a dataChanged handler or
* some other signal; since the connection is via a lambda, Qt would cause the
* handler to be called directly. This is not behaviour we usually want, so we call our
* function via g_idle so that it gets called after the initial handler is done.
*/
if (topLeft == RecentModel::instance().selectionModel()->currentIndex())
g_idle_add((GSourceFunc)selected_item_changed, win);
}
);
g_signal_connect(priv->button_placecall, "clicked", G_CALLBACK(search_entry_placecall), win);
g_signal_connect(priv->search_entry, "activate", G_CALLBACK(search_entry_placecall), win);
/* autocompletion */
priv->q_completion_model = new NumberCompletionModel();
/* autocompletion renderers */
GtkCellArea *completion_area = gtk_cell_area_box_new();
/* photo renderer */
GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area),
renderer,
TRUE, /* expand */
TRUE, /* align */
TRUE); /* fixed size */
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area),
renderer,
(GtkCellLayoutDataFunc)autocompletion_photo_render,
NULL, NULL);
/* name renderer */
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area),
renderer,
TRUE, /* expand */
TRUE, /* align */
TRUE); /* fixed size */
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area),
renderer,
(GtkCellLayoutDataFunc)autocompletion_name_render,
NULL, NULL);
/* number renderer */
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area),
renderer,
TRUE, /* expand */
TRUE, /* align */
TRUE); /* fixed size */
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area),
renderer,
(GtkCellLayoutDataFunc)autocompletion_number_render,
NULL, NULL);
/* account renderer */
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area),
renderer,
TRUE, /* expand */
TRUE, /* align */
TRUE); /* fixed size */
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area),
renderer,
(GtkCellLayoutDataFunc)autocompletion_account_render,
NULL, NULL);
GtkEntryCompletion *entry_completion = gtk_entry_completion_new_with_area(completion_area);
GtkQTreeModel *completion_model = gtk_q_tree_model_new(
(QAbstractItemModel *)priv->q_completion_model,
1,
Qt::DisplayRole, G_TYPE_STRING);
gtk_entry_completion_set_model(entry_completion, GTK_TREE_MODEL(completion_model));
gtk_entry_set_completion(GTK_ENTRY(priv->search_entry), entry_completion);
gtk_entry_completion_set_match_func(
entry_completion,
(GtkEntryCompletionMatchFunc) completion_match_func,
NULL,
NULL);
/* connect signal to when text is entered in the entry */
g_signal_connect(priv->search_entry, "changed", G_CALLBACK(search_entry_text_changed), win);
g_signal_connect(entry_completion, "match-selected", G_CALLBACK(select_autocompletion), win);
/* connect to incoming call and focus */
QObject::connect(
&CallModel::instance(),
&CallModel::incomingCall,
[=](Call* call) {
CallModel::instance().selectionModel()->setCurrentIndex(
CallModel::instance().getIndex(call), QItemSelectionModel::ClearAndSelect);
}
);
/* react to digit key press events */
g_signal_connect(win, "key-press-event", G_CALLBACK(dtmf_pressed), NULL);
/* set the search entry placeholder text */
gtk_entry_set_placeholder_text(GTK_ENTRY(priv->search_entry),
C_("Please try to make the translation 50 chars or less so that it fits into the layout", "Search contacts or enter number"));
}
