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")); }