/** * empathy_irc_network_dialog_show: * @network: the #EmpathyIrcNetwork to configure * @parent: the parent of this dialog * * Display a dialog to configure a given #EmpathyIrcNetwork. * This function is a singleton so if a configuration dialog already * exists we use this one to edit the network. * * Returns: The displayed #GtkDialog */ GtkWidget * empathy_irc_network_dialog_show (EmpathyIrcNetwork *network, GtkWidget *parent) { static EmpathyIrcNetworkDialog *dialog = NULL; GladeXML *glade; GtkListStore *store; GtkCellRenderer *renderer; GtkAdjustment *adjustment; GtkTreeSelection *selection; GtkTreeViewColumn *column; gchar *filename; g_return_val_if_fail (network != NULL, NULL); if (dialog != NULL) { change_network (dialog, network); gtk_window_present (GTK_WINDOW (dialog->dialog)); return dialog->dialog; } dialog = g_slice_new0 (EmpathyIrcNetworkDialog); dialog->network = network; g_object_ref (dialog->network); filename = empathy_file_lookup ("empathy-account-widget-irc.glade", "libempathy-gtk"); glade = empathy_glade_get_file (filename, "irc_network_dialog", NULL, "irc_network_dialog", &dialog->dialog, "button_close", &dialog->button_close, "entry_network", &dialog->entry_network, "combobox_charset", &dialog->combobox_charset, "treeview_servers", &dialog->treeview_servers, "button_add", &dialog->button_add, "button_remove", &dialog->button_remove, "button_up", &dialog->button_up, "button_down", &dialog->button_down, NULL); g_free (filename); store = gtk_list_store_new (4, G_TYPE_OBJECT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_BOOLEAN); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview_servers), GTK_TREE_MODEL (store)); g_object_unref (store); /* address */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (irc_network_dialog_address_edited_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("Server"), renderer, "text", COL_ADR, NULL); /* port */ adjustment = (GtkAdjustment *) gtk_adjustment_new (6667, 1, G_MAXUINT16, 1, 10, 0); renderer = gtk_cell_renderer_spin_new (); g_object_set (renderer, "editable", TRUE, "adjustment", adjustment, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (irc_network_dialog_port_edited_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("Port"), renderer, "text", COL_PORT, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->treeview_servers), 1); gtk_tree_view_column_set_expand (column, TRUE); /* SSL */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "activatable", TRUE, NULL); g_signal_connect (renderer, "toggled", G_CALLBACK (irc_network_dialog_ssl_toggled_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("SSL"), renderer, "active", COL_SSL, NULL); selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (dialog->treeview_servers)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* charset */ totem_subtitle_encoding_init (GTK_COMBO_BOX (dialog->combobox_charset)); irc_network_dialog_setup (dialog); empathy_glade_connect (glade, dialog, "irc_network_dialog", "destroy", irc_network_dialog_destroy_cb, "button_close", "clicked", irc_network_dialog_close_clicked_cb, "entry_network", "focus-out-event", irc_network_dialog_network_focus_cb, "button_add", "clicked", irc_network_dialog_button_add_clicked_cb, "button_remove", "clicked", irc_network_dialog_button_remove_clicked_cb, "button_up", "clicked", irc_network_dialog_button_up_clicked_cb, "button_down", "clicked", irc_network_dialog_button_down_clicked_cb, "combobox_charset", "changed", irc_network_dialog_combobox_charset_changed_cb, NULL); g_object_unref (glade); g_object_add_weak_pointer (G_OBJECT (dialog->dialog), (gpointer) &dialog); g_signal_connect (selection, "changed", G_CALLBACK (irc_network_dialog_selection_changed_cb), dialog); gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog), GTK_WINDOW (parent)); gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE); irc_network_dialog_network_update_buttons (dialog); return dialog->dialog; }
void preferences_dialog_show(GtkWindow *parent){ if(prefs){ window_present(GTK_WINDOW (prefs->dialog), TRUE); return; } prefs=g_new0(PreferencesDialog, 1); /* Get widgets */ GtkBuilder *ui=gtkbuilder_get_file( GTK_BUILDER_UI_FILENAME, "preferences_dialog", &prefs->dialog, "preferences_notebook", &prefs->notebook, "compact_entire_view_check_button", &prefs->compact_entire_view_check_button, "uberchick_tree_view_concatenated_update_check_button", &prefs->concatenated_updates_check_button, "update_viewer_use_dialog_toggle_button", &prefs->use_dialog_toggle_button, "update_viewer_compact_view_toggle_button", &prefs->compact_view_toggle_button, "general_look_and_feel_disable_system_bell_check_button", &prefs->disable_system_bell, "titles_only_checkbutton", &prefs->titles_only_checkbutton, "expand_urls_selected_only_checkbutton", &prefs->expand_urls_selected_only_checkbutton, "expand_users_checkbutton", &prefs->expand_users_checkbutton, "expand_urls_disabled_checkbutton", &prefs->expand_urls_disabled_checkbutton, "autoload_addition_timeline_combo_box", &prefs->combo_default_timeline, "refresh_timeline_initial_interval_combo_box", &prefs->combo_reload, "autoload_best_friends_updates_check_button", &prefs->autoload_best_friends_updates_check_button, "autoload_dms_check_button", &prefs->autoload_dms_check_button, "autoload_replies_check_button", &prefs->autoload_replies_check_button, "autoload_homepage_check_button", &prefs->autoload_homepage_check_button, "notify_dms_check_button", &prefs->notify_dms_check_button, "notify_at_mentions_check_button", &prefs->notify_at_mentions_check_button, "notify_following_updates_check_button", &prefs->notify_following_updates_check_button, "notify_best_friends_updates_check_button", &prefs->notify_best_friends_updates_check_button, "notify_all_new_updates_check_button", &prefs->notify_all_new_updates, "notify_beep_updates_check_button", &prefs->notify_beep_updates_check_button, "disable_update_length_alert_check_button", &prefs->disable_update_length_alert_check_button, "updates_composition_swap_octothorpe_and_exclaimation", &prefs->swap_octothorpe_and_exclaimation, "replace_me_with_combo_box", &prefs->replace_me_with_combo_box, "updates_add_profile_link_checkbutton", &prefs->updates_add_profile_link_checkbutton, "post_reply_to_service_only_checkbutton", &prefs->post_reply_to_service_only_checkbutton, "previous_updates_uniq_check_button", &prefs->previous_updates_uniq_check_button, "previous_updates_maximum_combo_box", &prefs->previous_updates_maximum_combo_box, "search_history_uniq_check_button", &prefs->search_history_uniq_check_button, "search_history_maximum_combo_box", &prefs->search_history_maximum_combo_box, NULL ); gchar *window_title=g_strdup_printf("%s - %s", _(GETTEXT_PACKAGE), _("Preferences")); gtk_window_set_title(GTK_WINDOW(prefs->dialog), window_title); uber_free(window_title); /* Connect the signals */ gtkbuilder_connect( ui, prefs, "preferences_dialog", "destroy", preferences_destroy_cb, "preferences_dialog", "response", preferences_response_cb, NULL ); g_signal_connect((GtkToggleButton *)prefs->use_dialog_toggle_button, "toggled", (GCallback)main_window_update_viewer_set_embed, NULL); g_signal_connect_after((GtkToggleButton *)prefs->compact_view_toggle_button, "toggled", (GCallback)update_viewer_compact_view_toggled, NULL); g_signal_connect_after((GtkToggleButton *)prefs->concatenated_updates_check_button, "toggled", (GCallback)main_window_concatenate_timeline_columns, NULL); g_signal_connect_after((GtkToggleButton *)prefs->compact_entire_view_check_button, "toggled", (GCallback)main_window_compact_ui, NULL); uber_object_unref(ui); g_object_add_weak_pointer(G_OBJECT (prefs->dialog), (gpointer) &prefs); gtk_window_set_transient_for(GTK_WINDOW (prefs->dialog), parent); preferences_timeline_setup(prefs); preferences_replace_with_setup(prefs); preferences_max_int_combo_box_setup(prefs, prefs->combo_reload, 60, "Minutes"); preferences_max_int_combo_box_setup(prefs, prefs->previous_updates_maximum_combo_box, 0, "Updates"); preferences_max_int_combo_box_setup(prefs, prefs->search_history_maximum_combo_box, 0, "Searches"); preferences_setup_widgets(prefs); gtk_widget_show(GTK_WIDGET(prefs->dialog)); }/*preferences_dialog_show(parent);*/
void prefswindow_open_full(const gchar *title, GSList *prefs_pages, gpointer data, GDestroyNotify func, gint *save_width, gint *save_height, gboolean preload_pages, PrefsOpenCallbackFunc open_cb, PrefsCloseCallbackFunc close_cb) { PrefsWindow *prefswindow; gint x = gdk_screen_width(); gint y = gdk_screen_height(); static GdkGeometry geometry; GtkAdjustment *adj; prefswindow = g_new0(PrefsWindow, 1); prefswindow->data = data; prefswindow->func = func; prefswindow->prefs_pages = g_slist_copy(prefs_pages); prefswindow->save_width = save_width; prefswindow->save_height = save_height; prefswindow->open_cb = open_cb; prefswindow->close_cb = close_cb; prefswindow->window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefswindow"); gtk_window_set_title(GTK_WINDOW(prefswindow->window), title); gtk_window_set_position (GTK_WINDOW(prefswindow->window), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (prefswindow->window), TRUE); gtk_window_set_resizable (GTK_WINDOW(prefswindow->window), TRUE); gtk_window_set_transient_for (GTK_WINDOW(prefswindow->window), GTK_WINDOW(mainwindow_get_mainwindow()->window)); gtk_container_set_border_width(GTK_CONTAINER(prefswindow->window), 4); prefswindow->vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(prefswindow->vbox); prefswindow->paned = gtk_hpaned_new(); gtk_widget_show(prefswindow->paned); gtk_container_add(GTK_CONTAINER(prefswindow->window), prefswindow->vbox); gtk_box_pack_start(GTK_BOX(prefswindow->vbox), prefswindow->paned, TRUE, TRUE, 0); prefswindow->scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(prefswindow->scrolledwindow1); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(prefswindow->scrolledwindow1), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(prefswindow->scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_paned_add1(GTK_PANED(prefswindow->paned), prefswindow->scrolledwindow1); prefswindow->tree_view = prefswindow_tree_view_create(prefswindow); gtk_widget_show(prefswindow->tree_view); gtk_container_add(GTK_CONTAINER(prefswindow->scrolledwindow1), prefswindow->tree_view); prefswindow->vbox2 = gtk_vbox_new(FALSE, 2); gtk_widget_show(prefswindow->vbox2); gtk_paned_add2(GTK_PANED(prefswindow->paned), prefswindow->vbox2); prefswindow->table2 = gtk_table_new(1, 2, FALSE); gtk_widget_show(prefswindow->table2); gtk_container_add(GTK_CONTAINER(prefswindow->vbox2), prefswindow->table2); prefswindow->labelframe = gtk_frame_new(NULL); gtk_widget_show(prefswindow->labelframe); gtk_frame_set_shadow_type(GTK_FRAME(prefswindow->labelframe), GTK_SHADOW_OUT); gtk_table_attach(GTK_TABLE(prefswindow->table2), prefswindow->labelframe, 0, 1, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1); prefswindow->pagelabel = gtk_label_new(""); gtk_widget_show(prefswindow->pagelabel); gtk_label_set_justify(GTK_LABEL(prefswindow->pagelabel), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(prefswindow->pagelabel), 0, 0.0); gtk_container_add(GTK_CONTAINER(prefswindow->labelframe), prefswindow->pagelabel); prefswindow->notebook = gtk_notebook_new(); gtk_widget_show(prefswindow->notebook); gtk_notebook_set_scrollable(GTK_NOTEBOOK(prefswindow->notebook), TRUE); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(prefswindow->notebook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(prefswindow->notebook), FALSE); gtk_table_attach(GTK_TABLE(prefswindow->table2), prefswindow->notebook, 0, 1, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 4); prefswindow->empty_page = gtk_label_new(""); gtk_widget_show(prefswindow->empty_page); gtk_container_add(GTK_CONTAINER(prefswindow->notebook), prefswindow->empty_page); prefswindow_build_tree(prefswindow->tree_view, prefs_pages, prefswindow, preload_pages); if (open_cb) open_cb(GTK_WINDOW(prefswindow->window)); gtk_widget_grab_focus(prefswindow->tree_view); #ifndef GENERIC_UMPC gtkut_stock_button_set_create(&prefswindow->confirm_area, &prefswindow->apply_btn, GTK_STOCK_APPLY, &prefswindow->cancel_btn, GTK_STOCK_CANCEL, &prefswindow->ok_btn, GTK_STOCK_OK); #else gtkut_stock_button_set_create(&prefswindow->confirm_area, &prefswindow->apply_btn, GTK_STOCK_APPLY, &prefswindow->ok_btn, GTK_STOCK_CLOSE, NULL, NULL); #endif gtk_widget_show_all(prefswindow->confirm_area); gtk_widget_show(prefswindow->vbox); gtk_widget_show(prefswindow->scrolledwindow1); gtk_box_pack_start(GTK_BOX(prefswindow->vbox), prefswindow->confirm_area, FALSE, FALSE, 0); #ifndef GENERIC_UMPC g_signal_connect(G_OBJECT(prefswindow->ok_btn), "clicked", G_CALLBACK(ok_button_clicked), prefswindow); g_signal_connect(G_OBJECT(prefswindow->cancel_btn), "clicked", G_CALLBACK(cancel_button_clicked), prefswindow); g_signal_connect(G_OBJECT(prefswindow->apply_btn), "clicked", G_CALLBACK(apply_button_clicked), prefswindow); #else g_signal_connect(G_OBJECT(prefswindow->ok_btn), "clicked", G_CALLBACK(ok_button_clicked), prefswindow); g_signal_connect(G_OBJECT(prefswindow->apply_btn), "clicked", G_CALLBACK(apply_button_clicked), prefswindow); #endif g_signal_connect(G_OBJECT(prefswindow->window), "delete_event", G_CALLBACK(window_closed), prefswindow); g_signal_connect(G_OBJECT(prefswindow->window), "key_press_event", G_CALLBACK(prefswindow_key_pressed), &(prefswindow->window)); /* connect to callback only if we have non-NULL pointers to store size to */ if (prefswindow->save_width && prefswindow->save_height) { g_signal_connect(G_OBJECT(prefswindow->window), "size_allocate", G_CALLBACK(prefs_size_allocate_cb), prefswindow); } MANAGE_WINDOW_SIGNALS_CONNECT(prefswindow->window); if (!geometry.min_height) { if (x < 800 && y < 600) { geometry.min_width = 600; geometry.min_height = 440; } else { geometry.min_width = 700; geometry.min_height = 550; } } gtk_window_set_geometry_hints(GTK_WINDOW(prefswindow->window), NULL, &geometry, GDK_HINT_MIN_SIZE); if (prefswindow->save_width && prefswindow->save_height) { gtk_widget_set_size_request(prefswindow->window, *(prefswindow->save_width), *(prefswindow->save_height)); } #ifdef GENERIC_UMPC prefs_show_sections(prefswindow); #endif gtk_widget_show(prefswindow->window); adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(prefswindow->scrolledwindow1)); gtk_adjustment_set_value(adj, gtk_adjustment_get_lower(adj)); gtk_adjustment_changed(adj); }
GtkWidget* remmina_chat_window_new(GtkWindow* parent, const gchar* chat_with) { RemminaChatWindow* window; gchar buf[100]; GtkWidget* table; GtkWidget* scrolledwindow; GtkWidget* widget; GtkWidget* image; GtkTextBuffer* buffer; window = REMMINA_CHAT_WINDOW(g_object_new(REMMINA_TYPE_CHAT_WINDOW, NULL)); if (parent) { gtk_window_set_transient_for(GTK_WINDOW(window), parent); } /* Title */ g_snprintf(buf, sizeof(buf), _("Chat with %s"), chat_with); gtk_window_set_title(GTK_WINDOW(window), buf); gtk_window_set_default_size(GTK_WINDOW(window), 450, 300); /* Main container */ table = gtk_table_new(3, 2, FALSE); gtk_widget_show(table); gtk_table_set_row_spacings(GTK_TABLE(table), 4); gtk_table_set_col_spacings(GTK_TABLE(table), 4); gtk_container_set_border_width(GTK_CONTAINER(table), 8); gtk_container_add(GTK_CONTAINER(window), table); /* Chat history */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_table_attach_defaults(GTK_TABLE(table), scrolledwindow, 0, 2, 0, 1); widget = gtk_text_view_new(); gtk_widget_show(widget); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD_CHAR); gtk_text_view_set_editable(GTK_TEXT_VIEW(widget), FALSE); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)); gtk_text_buffer_create_tag(buffer, "sender-foreground", "foreground", "blue", NULL); gtk_text_buffer_create_tag(buffer, "receiver-foreground", "foreground", "red", NULL); window->history_text = widget; /* Chat message to be sent */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_table_attach(GTK_TABLE(table), scrolledwindow, 0, 1, 1, 3, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); widget = gtk_text_view_new(); gtk_widget_show(widget); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD_CHAR); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); g_signal_connect(G_OBJECT(widget), "key-press-event", G_CALLBACK(remmina_chat_window_send_text_on_key), window); window->send_text = widget; /* Send button */ image = gtk_image_new_from_icon_name("document-send", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image); widget = gtk_button_new_with_mnemonic(_("_Send")); gtk_widget_show(widget); gtk_button_set_image(GTK_BUTTON(widget), image); gtk_table_attach(GTK_TABLE(table), widget, 1, 2, 1, 2, 0, 0, 0, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_chat_window_send), window); /* Clear button */ image = gtk_image_new_from_stock(GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON); gtk_widget_show(image); widget = gtk_button_new_with_mnemonic(_("_Clear")); gtk_widget_show(widget); gtk_button_set_image(GTK_BUTTON(widget), image); gtk_table_attach(GTK_TABLE(table), widget, 1, 2, 2, 3, 0, 0, 0, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_chat_window_clear_send_text), window); gtk_widget_grab_focus(window->send_text); return GTK_WIDGET(window); }
int l_uosgrnu_p(class l_uosgrnu_rek *rek_poi,GtkWidget *wpredok) { class l_uosgrnu_p_data data; char strsql[512]; data.rk=rek_poi; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Поиск")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_uosgrnu_p_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); GtkWidget *label=gtk_label_new(gettext("Код")); data.entry[E_KOD] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(l_uosgrnu_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk->kod.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD); label=gtk_label_new(gettext("Наименование")); data.entry[E_NAIM] = gtk_entry_new_with_max_length (80); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(l_uosgrnu_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk->naim.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM); GtkTooltips *tooltips[KOL_PFK]; sprintf(strsql,"F2 %s",gettext("Поиск")); data.knopka[PFK2]=gtk_button_new_with_label(strsql); tooltips[PFK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[PFK2],data.knopka[PFK2],gettext("Начать поиск нужных записей"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[PFK2]),"clicked",GTK_SIGNAL_FUNC(l_uosgrnu_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK2]),(gpointer)PFK2); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[PFK4]=gtk_button_new_with_label(strsql); tooltips[PFK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[PFK4],data.knopka[PFK4],gettext("Очистить меню от введеноой информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[PFK4]),"clicked",GTK_SIGNAL_FUNC(l_uosgrnu_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK4]),(gpointer)PFK4); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[PFK10]=gtk_button_new_with_label(strsql); tooltips[PFK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[PFK10],data.knopka[PFK10],gettext("Поиск не выполнять"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[PFK10]),"clicked",GTK_SIGNAL_FUNC(l_uosgrnu_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK10]),(gpointer)PFK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK2], TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK4], TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); return(data.voz); }
static void hildon_font_selection_dialog_show_preview (HildonFontSelectionDialog *fontsel) { HildonFontSelectionDialogPrivate *priv = HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE (fontsel); gint size; gboolean family_set, size_set; PangoAttribute *attr; PangoAttrList *list; GtkWidget *preview_dialog; GtkWidget *preview_label; gchar *str = NULL; gboolean position_set = FALSE; gint position = 0; gboolean show_ref = FALSE; g_assert (priv); g_object_get (G_OBJECT (fontsel), "position-set", &position_set, NULL); if (position_set) { g_object_get (G_OBJECT (fontsel), "position", &position, NULL); if (position == 1 || position == -1) show_ref = TRUE; } /* preview dialog init */ preview_dialog = gtk_dialog_new_with_buttons (_("ecdg_ti_preview_font"), NULL, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR, _("ecdg_bd_font_dialog_ok"), GTK_RESPONSE_ACCEPT, NULL); str = (show_ref) ? g_strconcat (_("ecdg_fi_preview_font_preview_reference"), priv->preview_text, 0) : g_strdup (priv->preview_text); preview_label = gtk_label_new (str); gtk_label_set_line_wrap (GTK_LABEL(preview_label), TRUE); if (str) g_free (str); str = NULL; /* set keypress handler (ESC hardkey) */ g_signal_connect (G_OBJECT (preview_dialog), "key-press-event", G_CALLBACK(hildon_font_selection_dialog_preview_key_press), NULL); /* Set the font */ list = (show_ref) ? hildon_font_selection_dialog_create_attrlist (fontsel, strlen (_("ecdg_fi_preview_font_preview_reference")), strlen (priv->preview_text)) : hildon_font_selection_dialog_create_attrlist (fontsel, 0, strlen(priv->preview_text)); g_object_get (G_OBJECT (fontsel), "family", &str, "family-set", &family_set, "size", &size, "size-set", &size_set, NULL); /* A smallish hack to add scrollbar when font size is really big */ if (size_set && size > 24) { GtkScrolledWindow *scrolled = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL)); gtk_scrolled_window_set_policy (scrolled, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport (scrolled, GTK_WIDGET (preview_label)); gtk_container_add (GTK_CONTAINER (GTK_DIALOG(preview_dialog)->vbox), GTK_WIDGET (scrolled)); gtk_widget_set_size_request (GTK_WIDGET (scrolled), -1, 400); } else gtk_container_add (GTK_CONTAINER (GTK_DIALOG(preview_dialog)->vbox), GTK_WIDGET (preview_label)); /* make reference text to have the same fontface and size */ if (family_set) { attr = pango_attr_family_new (str); add_preview_text_attr (list, attr, 0, strlen (_("ecdg_fi_preview_font_preview_reference"))); } if (str != NULL) g_free (str); str = NULL; /* size */ if (size_set) { attr = pango_attr_size_new (size * PANGO_SCALE); add_preview_text_attr (list, attr, 0, strlen (_("ecdg_fi_preview_font_preview_reference"))); } gtk_label_set_attributes (GTK_LABEL (preview_label), list); pango_attr_list_unref (list); /*And show the dialog*/ gtk_window_set_transient_for (GTK_WINDOW (preview_dialog), GTK_WINDOW (fontsel)); gtk_widget_show_all (preview_dialog); gtk_dialog_set_default_response (GTK_DIALOG (preview_dialog), GTK_RESPONSE_OK); GtkBox *action_area = (GtkBox *) GTK_DIALOG (preview_dialog)->action_area; GtkWidget *button = ((GtkBoxChild *) ((GSList *) action_area->children)->data)->widget; gtk_widget_grab_focus (button); gtk_dialog_run (GTK_DIALOG (preview_dialog)); gtk_widget_destroy (preview_dialog); }
GtkWindow * gw_msg_box_create ( GtkWindow *window, gchar *title, gchar *subject) { /*static */GtkWidget *w = NULL; GtkWidget *vbox,*label,*button,*hbox; GtkAccelGroup *accel; guint button_key; gchar *text_utf8 = NULL; #ifdef GW_DEBUG_GUI_COMPONENT g_print ( "*** GW - %s (%d) :: %s() : title=%s subject=%s\n", __FILE__, __LINE__, __PRETTY_FUNCTION__, title, subject); #endif if ( !w ) { #ifdef GW_DEBUG_GUI_COMPONENT g_print ( "*** GW - %s (%d) :: %s() new dialog window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__); #endif accel = gtk_accel_group_new ( ); w = gtk_window_new ( GTK_WINDOW_DIALOG); gtk_window_set_policy ( GTK_WINDOW ( w), FALSE, FALSE, TRUE); g_strdup_to_gtk_text ( title, text_utf8); gtk_window_set_title ( GTK_WINDOW ( w), text_utf8); g_free ( text_utf8); gtk_container_border_width ( GTK_CONTAINER ( w), 10); gtk_window_set_modal ( GTK_WINDOW ( w),TRUE); gtk_window_set_transient_for ( GTK_WINDOW ( w), window); gtk_window_set_position ( GTK_WINDOW ( w), GTK_WIN_POS_CENTER); #ifdef HAVE_GTK12 gtk_signal_connect ( GTK_OBJECT ( w), "destroy", GTK_SIGNAL_FUNC ( gtk_widget_destroyed), &w); #endif vbox = gtk_vbox_new ( TRUE, 10); gtk_container_add ( GTK_CONTAINER ( w), vbox); gtk_container_set_border_width ( GTK_CONTAINER ( vbox), 10); g_strdup_to_gtk_text ( subject, text_utf8); label = gtk_label_new ( text_utf8); gtk_label_set_text ( GTK_LABEL ( label), text_utf8); g_free ( text_utf8); gtk_box_pack_start ( GTK_BOX ( vbox), label, FALSE, FALSE, 0); /* The Ok button area */ hbox = gtk_hbutton_box_new ( ); gtk_button_box_set_layout ( GTK_BUTTON_BOX ( hbox), GTK_BUTTONBOX_EDGE); gtk_button_box_set_spacing ( GTK_BUTTON_BOX ( hbox), 5); gtk_box_pack_end ( GTK_BOX ( vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ( ""); g_strdup_to_gtk_text ( _( "_OK"), text_utf8); button_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( button)->child), text_utf8); g_free ( text_utf8); gtk_widget_add_accelerator ( button, "clicked", accel, button_key, GDK_MOD1_MASK, 0); gtk_object_set_user_data ( GTK_OBJECT ( button), w); gtk_box_pack_start ( GTK_BOX ( hbox), button, TRUE, FALSE, 0); gtk_signal_connect_object ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( gtk_widget_destroy), GTK_OBJECT ( w)); GTK_WIDGET_SET_FLAGS ( button, GTK_CAN_FOCUS); gtk_widget_grab_focus ( button); gtk_window_add_accel_group ( GTK_WINDOW ( w), accel); } if ( !GTK_WIDGET_VISIBLE ( w)) { gtk_widget_show_all ( w); } else { gtk_widget_destroy ( w); } return GTK_WINDOW ( w); }
osso_return_t execute(osso_context_t *osso, gpointer data, gboolean user_activated) { /* Create needed variables */ GtkWidget *dialog; GtkObject *adj[NUM_BANDS]; struct label_band *lband[NUM_BANDS]; struct dialog_and_sliders *dialog_slid; GtkWidget *slider_band[NUM_BANDS]; GtkWidget *single_slider_container[NUM_BANDS]; gulong update_label_signal[NUM_BANDS]; gulong update_band_signal[NUM_BANDS]; GtkWidget *sliders_container; gint i; GtkWidget *toolbar; GtkToolItem *toolitem_open; GtkToolItem *toolitem_save_as; GtkToolItem *toolitem_delete; GtkWidget *content_area; guint update_slider_signal; dialog = gtk_dialog_new(); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(data)); gtk_window_set_title(GTK_WINDOW(dialog), "MAFW Equalizer"); gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400); sliders_container = gtk_hbox_new(TRUE, 10); toolbar = gtk_toolbar_new(); /* Create the bands */ for (i = 0; i < NUM_BANDS; i++) { slider_band[i] = hildon_gtk_vscale_new(); adj[i] = gtk_adjustment_new(EQ_GAIN_MIN, EQ_GAIN_MIN, EQ_GAIN_MAX, 1, 10, 0); gtk_range_set_adjustment(GTK_RANGE(slider_band[i]), GTK_ADJUSTMENT(adj[i])); gtk_range_set_inverted(GTK_RANGE(slider_band[i]), TRUE); gtk_range_set_update_policy(GTK_RANGE(slider_band[i]), GTK_UPDATE_DELAYED); gtk_range_set_show_fill_level(GTK_RANGE(slider_band[i]), FALSE); single_slider_container[i] = gtk_hbox_new(TRUE, 0); lband[i] = g_new0(struct label_band, 1); lband[i]->label = gtk_label_new(NULL); lband[i]->id = i; gtk_label_set_angle(GTK_LABEL(lband[i]->label), 90); gtk_misc_set_alignment(GTK_MISC(lband[i]->label), 0, 0.9); gtk_box_pack_start(GTK_BOX(single_slider_container[i]), lband[i]->label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(single_slider_container[i]), slider_band[i], TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(sliders_container), single_slider_container[i], TRUE, TRUE, 10); update_label_signal[i] = g_signal_connect(slider_band[i], "value-changed", G_CALLBACK(update_label_cb), lband[i]); gtk_range_set_value(GTK_RANGE(slider_band[i]), get_band_value(i)); update_band_signal[i] = g_signal_connect(slider_band[i], "value-changed", G_CALLBACK(update_band_cb), GINT_TO_POINTER(i)); } /* Listen for changes in gconf */ if (!confclient) { confclient = gconf_client_get_default(); } gconf_client_add_dir(confclient, GCONF_MAFW_GST_EQ_RENDERER, GCONF_CLIENT_PRELOAD_ONELEVEL, NULL); update_slider_signal = gconf_client_notify_add( confclient, GCONF_MAFW_GST_EQ_RENDERER, (GConfClientNotifyFunc) update_slider_cb, slider_band, NULL, NULL); /* Create the toolbuttons */ toolitem_open = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); toolitem_save_as = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE_AS); toolitem_delete = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_open, -1); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_save_as, -1); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_delete, -1); g_signal_connect(toolitem_open, "clicked", G_CALLBACK(open_button_cb), dialog); g_signal_connect(toolitem_delete, "clicked", G_CALLBACK(delete_button_cb), dialog); dialog_slid = g_new0(struct dialog_and_sliders, 1); dialog_slid->dialog = dialog; dialog_slid->slider_band = slider_band; g_signal_connect(toolitem_save_as, "clicked", G_CALLBACK(save_as_button_cb), dialog_slid); content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_box_pack_start(GTK_BOX(content_area), sliders_container, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX(content_area), toolbar, FALSE, FALSE, 1); /* Run the dialog */ gtk_widget_show_all(GTK_WIDGET(dialog)); gtk_dialog_run(GTK_DIALOG(dialog)); /* Free everything */ gconf_client_notify_remove(confclient, update_slider_signal); for (i = 0; i < NUM_BANDS; i++) { g_signal_handler_disconnect(slider_band[i], update_label_signal[i]); g_signal_handler_disconnect(slider_band[i], update_band_signal[i]); g_free(lband[i]); } g_free(dialog_slid); gtk_widget_destroy(GTK_WIDGET(dialog)); return OSSO_OK; }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GdkPixbuf *icon; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new(); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); header_eventbox_style_set(header_eventbox); header_label_style_set(header_label); g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL); g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0); /* set image */ icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO); gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon); gtk_window_set_icon(GTK_WINDOW(dialog), icon); g_object_unref(icon); /* free our reference */ /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN); license_textview = gtk_text_view_new(); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
/*! * \fn G_MODULE_EXPORT void openAssistantNewCsu(GtkWidget *widget, gpointer data) * Open the assistant for a new csu file * \param[in] widget the widget which send the signal * \param[in] data the globalData */ G_MODULE_EXPORT void openAssistantNewCsu(GtkWidget *widget, gpointer data) { globalData *user_data = (globalData*) data; char home_path[SIZE_MAX_FILE_NAME]=""; gchar system_path[SIZE_MAX_FILE_NAME]=""; list_game_config *ptr_list_config; gint i; #ifndef PORTABLE readHomePathSlash(home_path); readSystemPath(system_path); #else readHomePath(system_path); #endif // PORTABLE /* creating of the assistant */ user_data->ptr_new_csu_file_assistant = gtk_assistant_new(); /* Set the assistant windows */ gtk_window_set_transient_for(GTK_WINDOW(user_data->ptr_new_csu_file_assistant),GTK_WINDOW(user_data->ptr_main_window)); gtk_window_set_gravity(GTK_WINDOW(user_data->ptr_new_csu_file_assistant),GDK_GRAVITY_CENTER); gtk_window_set_position(GTK_WINDOW(user_data->ptr_new_csu_file_assistant),GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal(GTK_WINDOW(user_data->ptr_new_csu_file_assistant),TRUE); gtk_window_set_type_hint(GTK_WINDOW(user_data->ptr_new_csu_file_assistant),GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_resize(GTK_WINDOW(user_data->ptr_new_csu_file_assistant),700,400); gtk_window_set_title(GTK_WINDOW(user_data->ptr_new_csu_file_assistant),_("New csu file assistant")); /*Set the signal of the assistant */ g_signal_connect(user_data->ptr_new_csu_file_assistant,"delete-event", G_CALLBACK(deleteEventAssistantNewCsu),user_data); g_signal_connect(user_data->ptr_new_csu_file_assistant,"cancel", G_CALLBACK(deleteAssistantNewCsu),user_data); g_signal_connect(user_data->ptr_new_csu_file_assistant,"prepare", G_CALLBACK(preparePageAssistantNewCsu),user_data); g_signal_connect(user_data->ptr_new_csu_file_assistant,"close", G_CALLBACK(endAssistantNewCsu),user_data); /* Set the first page */ GtkWidget *grid_1 = getWidgetFromBuilder(user_data->ptr_builder,"grid_new_csu_file_assistant_1"); gtk_assistant_append_page(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),grid_1); gtk_assistant_set_page_type(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),grid_1,GTK_ASSISTANT_PAGE_INTRO); gtk_assistant_set_page_title(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),grid_1,_("General information")); /* Configure the file chooser */ gtk_entry_set_max_length(GTK_ENTRY(gtk_grid_get_child_at(GTK_GRID(grid_1),1,0)),SIZE_MAX_FILE_NAME/8); gtk_file_chooser_set_current_folder_file(GTK_FILE_CHOOSER(gtk_grid_get_child_at(GTK_GRID(grid_1),1,1)),g_file_new_for_path(g_locale_to_utf8(system_path,-1,NULL,NULL,NULL)),NULL); /* Set the combo box of the game configuration */ GtkWidget *combo_config = gtk_combo_box_text_new(); ptr_list_config = readConfigListFile(home_path); for (i=0 ; i<ptr_list_config->nb_config ; i++) gtk_combo_box_text_insert(GTK_COMBO_BOX_TEXT(combo_config),i,NULL,ptr_list_config->name_game_config[i]); gtk_combo_box_text_insert(GTK_COMBO_BOX_TEXT(combo_config),ptr_list_config->nb_config,NULL,_("Add a new game configuration")); gtk_combo_box_text_insert(GTK_COMBO_BOX_TEXT(combo_config),ptr_list_config->nb_config +1,NULL,_("Use an other game configuration")); gtk_grid_attach(GTK_GRID(grid_1),combo_config,1,3,1,1); g_signal_connect(combo_config,"changed", G_CALLBACK(chooseGameConfigurationNewAssistant),user_data); closeListGameConfig(ptr_list_config); /* Set the second page */ GtkWidget *scrolled_window_name = getWidgetFromBuilder(user_data->ptr_builder,"scrolled_window_new_csu_file_assistant_2"); gtk_assistant_append_page(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),scrolled_window_name); gtk_assistant_set_page_type(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),scrolled_window_name,GTK_ASSISTANT_PAGE_CONTENT); gtk_assistant_set_page_title(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),scrolled_window_name,_("Player's names")); /* Set the grid */ GtkWidget *grid_name = gtk_grid_new(); gtk_grid_set_column_spacing(GTK_GRID(grid_name),10); gtk_grid_set_row_spacing(GTK_GRID(grid_name),10); gtk_grid_set_column_homogeneous(GTK_GRID(grid_name),TRUE); #if GTK_MINOR_VERSION >= 12 gtk_widget_set_margin_end(grid_name,10); gtk_widget_set_margin_start(grid_name,10); #else gtk_widget_set_margin_right(grid_name,10); gtk_widget_set_margin_left(grid_name,10); #endif // GTK_MINOR_VERSION gtk_widget_set_margin_top(grid_name,10); gtk_widget_set_margin_bottom(grid_name,10); gtk_container_add(GTK_CONTAINER(gtk_bin_get_child(GTK_BIN(scrolled_window_name))),grid_name); /* Set the third page */ GtkWidget *grid_3 = getWidgetFromBuilder(user_data->ptr_builder,"grid_new_csu_file_assistant_3"); gtk_assistant_append_page(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),grid_3); gtk_assistant_set_page_type(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),grid_3,GTK_ASSISTANT_PAGE_CONFIRM); gtk_assistant_set_page_title(GTK_ASSISTANT(user_data->ptr_new_csu_file_assistant),grid_3,_("Distributor and validation")); GtkWidget *combo_distributor = gtk_combo_box_text_new(); gtk_grid_attach(GTK_GRID(grid_3),combo_distributor,1,0,1,1); g_signal_connect(combo_distributor,"changed", G_CALLBACK(validAssistantNewCsuThree),user_data); cleanAssistantNewCsu(user_data); gtk_widget_show_all(user_data->ptr_new_csu_file_assistant); }
/*! \brief Creates the lookuptables configurator window (MS1 FW's only) \param widget is unused \param data is unused \returns TRUE on success */ G_MODULE_EXPORT gboolean lookuptables_configurator(GtkWidget *widget, gpointer data) { static gboolean ltc_created = FALSE; static GtkWidget * lookuptables_config_window = NULL; GtkListStore *store = NULL; GtkTreeStore *combostore = NULL; GtkTreeIter iter; GtkTreeIter per_iter; GtkTreeIter sys_iter; GtkCellRenderer *renderer = NULL; GtkTreeViewColumn *column = NULL; GtkWidget * vbox = NULL; GtkWidget * tree = NULL; GtkWidget * frame = NULL; GtkWidget * label = NULL; ListElement *element = NULL; ConfigFile *cfgfile = NULL; GArray *classes = NULL; GList *p_list = NULL; GList *s_list = NULL; gchar * tmpbuf = NULL; gchar ** vector = NULL; gchar ** tmpvector = NULL; Firmware_Details *firmware = NULL; ENTER(); firmware = (Firmware_Details *)DATA_GET(global_data,"firmware"); if ((ltc_created) && (ltc_visible)) { EXIT(); return TRUE; } if ((ltc_created) && (!ltc_visible)) { gtk_widget_show_all(lookuptables_config_window); EXIT(); return TRUE; } else /* i.e. NOT created, build it */ { lookuptables_config_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(lookuptables_config_window),_("MegaTunix LookupTables")); gtk_window_set_default_size(GTK_WINDOW(lookuptables_config_window),300,200); vbox = gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(lookuptables_config_window),vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox),5); g_signal_connect(G_OBJECT(lookuptables_config_window),"delete_event", G_CALLBACK(lookuptables_configurator_hide),NULL); ltc_created = TRUE; ltc_visible = TRUE; frame = gtk_frame_new("MegaTunix LookupTables"); gtk_box_pack_start (GTK_BOX(vbox),frame,TRUE,TRUE,5); vbox = gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(frame),vbox); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label),_(" Click on the <i>LookupTable Filename</i> and press <b><u> Enter </u></b> to change ")); gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,5); store = gtk_list_store_new(N_COLS, /* total cols */ G_TYPE_STRING, /* int name */ G_TYPE_STRING, /* filename combo*/ G_TYPE_BOOLEAN,/* View/Edit */ G_TYPE_BOOLEAN); /* change */ combostore = gtk_tree_store_new(1,G_TYPE_STRING);/* lookuptable filename */ gtk_tree_store_append(combostore,&per_iter,NULL); gtk_tree_store_append(combostore,&sys_iter,NULL); gtk_tree_store_set(combostore,&per_iter, 0,"Personal", -1); gtk_tree_store_set(combostore,&sys_iter, 0,"System", -1); vector = get_files((const gchar *)DATA_GET(global_data,"project_name"),LOOKUPTABLES_DATA_DIR,"inc",&classes); for (guint i=0;i<g_strv_length(vector);i++) { tmpvector = g_strsplit(vector[i],PSEP,-1); if (g_array_index(classes,FileClass,i) == PERSONAL) { element = (ListElement *)g_new0(ListElement, 1); element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]); p_list = g_list_append(p_list,element); } if (g_array_index(classes,FileClass,i) == SYSTEM) { element = (ListElement *)g_new0(ListElement, 1); element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]); s_list = g_list_append(s_list,element); } g_strfreev(tmpvector); } g_strfreev(vector); g_array_free(classes,TRUE); p_list = g_list_sort(p_list,list_sort); s_list = g_list_sort(s_list,list_sort); for (guint i=0;i<g_list_length(p_list);i++) { gtk_tree_store_append(combostore,&iter,&per_iter); element = (ListElement *)g_list_nth_data(p_list,i); gtk_tree_store_set(combostore,&iter, 0,element->name, -1); } for (guint i=0;i<g_list_length(s_list);i++) { gtk_tree_store_append(combostore,&iter,&sys_iter); element = (ListElement *)g_list_nth_data(s_list,i); gtk_tree_store_set(combostore,&iter, 0,element->name, -1); } g_list_foreach(p_list,free_element,NULL); g_list_foreach(s_list,free_element,NULL); g_list_free(p_list); g_list_free(s_list); cfgfile = cfg_open_file(firmware->profile_filename); if (!cfgfile) { EXIT(); return FALSE; } cfg_read_string(cfgfile,"lookuptables","tables",&tmpbuf); vector = g_strsplit(tmpbuf,",",-1); g_free(tmpbuf); for (guint i=0;i<g_strv_length(vector);i++) { cfg_read_string(cfgfile,"lookuptables",vector[i],&tmpbuf); gtk_list_store_append(store,&iter); gtk_list_store_set(store,&iter, INTERNAL_NAME_COL,vector[i], FILENAME_COL,tmpbuf, VIEW_EDIT_COL,FALSE, -1); g_free(tmpbuf); } g_strfreev(vector); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree),TRUE); gtk_box_pack_start(GTK_BOX(vbox),tree,TRUE,TRUE,0); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Internal Table Name",renderer,"text",INTERNAL_NAME_COL,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column); renderer = gtk_cell_renderer_combo_new(); g_object_set(G_OBJECT(renderer),"has-entry",FALSE,"editable",TRUE,"model",combostore,"text-column",0,"style",PANGO_STYLE_ITALIC,NULL); g_signal_connect(G_OBJECT(renderer),"changed", G_CALLBACK(lookuptable_changed),store); // g_signal_connect(G_OBJECT(renderer),"editing-started", G_CALLBACK(editing_started),store); column = gtk_tree_view_column_new_with_attributes("LookupTable Filename",renderer,"text",FILENAME_COL,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column); /* renderer = gtk_cell_renderer_toggle_new(); column = gtk_tree_view_column_new_with_attributes("View/Edit",renderer,"active",VIEW_EDIT_COL,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column); */ gtk_window_set_transient_for(GTK_WINDOW(lookuptables_config_window),GTK_WINDOW(lookup_widget("main_window"))); gtk_widget_show_all (lookuptables_config_window); gtk_tree_view_columns_autosize( GTK_TREE_VIEW(tree)); gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree),GTK_TREE_VIEW_GRID_LINES_BOTH); // g_signal_connect(G_OBJECT(tree),"row-activated", G_CALLBACK(row_activated),NULL); } EXIT(); return TRUE; }
static void spell_cb (GtkAction *action, PlumaSpellPlugin *plugin) { PlumaSpellPluginPrivate *data; PlumaWindow *window; PlumaView *view; PlumaDocument *doc; PlumaSpellChecker *spell; GtkWidget *dlg; GtkTextIter start, end; gchar *word; gchar *data_dir; pluma_debug (DEBUG_PLUGINS); data = plugin->priv; window = PLUMA_WINDOW (data->window); view = pluma_window_get_active_view (window); g_return_if_fail (view != NULL); doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view))); g_return_if_fail (doc != NULL); spell = get_spell_checker_from_document (doc); g_return_if_fail (spell != NULL); if (gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)) <= 0) { GtkWidget *statusbar; statusbar = pluma_window_get_statusbar (window); pluma_statusbar_flash_message (PLUMA_STATUSBAR (statusbar), data->message_cid, _("The document is empty.")); return; } if (!gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc), &start, &end)) { /* no selection, get the whole doc */ gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc), &start, &end); } set_check_range (doc, &start, &end); word = get_next_misspelled_word (view); if (word == NULL) { GtkWidget *statusbar; statusbar = pluma_window_get_statusbar (window); pluma_statusbar_flash_message (PLUMA_STATUSBAR (statusbar), data->message_cid, _("No misspelled words")); return; } data_dir = peas_extension_base_get_data_dir (PEAS_EXTENSION_BASE (plugin)); dlg = pluma_spell_checker_dialog_new_from_spell_checker (spell, data_dir); g_free (data_dir); gtk_window_set_modal (GTK_WINDOW (dlg), TRUE); gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (window)); g_signal_connect (dlg, "ignore", G_CALLBACK (ignore_cb), view); g_signal_connect (dlg, "ignore_all", G_CALLBACK (ignore_cb), view); g_signal_connect (dlg, "change", G_CALLBACK (change_cb), view); g_signal_connect (dlg, "change_all", G_CALLBACK (change_all_cb), view); g_signal_connect (dlg, "add_word_to_personal", G_CALLBACK (add_word_cb), view); pluma_spell_checker_dialog_set_misspelled_word (PLUMA_SPELL_CHECKER_DIALOG (dlg), word, -1); g_free (word); gtk_widget_show (dlg); }
static void gdu_format_volume_dialog_show_internal (UDisksClient *client, GtkWindow *parent_window, gint parent_xid, UDisksObject *object) { GduApplication *app = GDU_APPLICATION (g_application_get_default ()); FormatVolumeData *data; gint response; data = g_new0 (FormatVolumeData, 1); data->parent_window = (parent_window != NULL) ? g_object_ref (parent_window) : NULL; data->object = g_object_ref (object); data->block = udisks_object_get_block (object); g_assert (data->block != NULL); data->drive = udisks_client_get_drive_for_block (client, data->block); data->dialog = GTK_WIDGET (gdu_application_new_widget (app, "format-volume-dialog.ui", "format-volume-dialog", &data->builder)); data->contents_box = GTK_WIDGET (gtk_builder_get_object (data->builder, "contents-box")); data->create_filesystem_widget = gdu_create_filesystem_widget_new (app, data->drive, NULL); /* additional_fstypes */ gtk_box_pack_start (GTK_BOX (data->contents_box), data->create_filesystem_widget, TRUE, TRUE, 0); g_signal_connect (data->create_filesystem_widget, "notify::has-info", G_CALLBACK (format_volume_property_changed), data); if (parent_window != NULL) { gtk_window_set_transient_for (GTK_WINDOW (data->dialog), parent_window); } else if (parent_xid != -1) { GdkWindow *foreign_window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), parent_xid); if (!gtk_widget_get_realized (data->dialog)) gtk_widget_realize (data->dialog); gdk_window_set_transient_for (gtk_widget_get_window (data->dialog), foreign_window); } gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK); format_volume_update (data); gtk_widget_show_all (data->dialog); gtk_widget_grab_focus (gdu_create_filesystem_widget_get_name_entry (GDU_CREATE_FILESYSTEM_WIDGET (data->create_filesystem_widget))); response = gtk_dialog_run (GTK_DIALOG (data->dialog)); if (response == GTK_RESPONSE_OK) { const gchar *primary_message; const gchar *erase_type; GString *str; GList *objects = NULL; gtk_widget_hide (data->dialog); erase_type = gdu_create_filesystem_widget_get_erase (GDU_CREATE_FILESYSTEM_WIDGET (data->create_filesystem_widget)); primary_message = _("Are you sure you want to format the volume?"); if (erase_type == NULL || g_strcmp0 (erase_type, "") == 0) { /* Translators: warning used for quick format of the volume*/ str = g_string_new (_("All data on the volume will be lost but may still be recoverable by data recovery services")); g_string_append (str, "\n\n"); g_string_append (str, _("<b>Tip</b>: If you are planning to recycle, sell or give away your old computer or disk, you should use a more thorough erase type to keep your private information from falling into the wrong hands")); } else { /* Translators: warning used when overwriting data of the volume */ str = g_string_new (_("All data on the volume will be overwritten and will likely not be recoverable by data recovery services")); } objects = g_list_append (NULL, object); if (!gdu_utils_show_confirmation (GTK_WINDOW (data->parent_window), primary_message, str->str, _("_Format"), NULL, NULL, client, objects)) { g_list_free (objects); g_string_free (str, TRUE); goto out; } g_list_free (objects); g_string_free (str, TRUE); /* ensure the volume is unused (e.g. unmounted) before formatting it... */ gdu_utils_ensure_unused (client, GTK_WINDOW (data->parent_window), data->object, (GAsyncReadyCallback) ensure_unused_cb, NULL, /* GCancellable */ data); return; } out: format_volume_data_free (data); }
static GtkamCamera * gtkam_chooser_get_camera (GtkamChooser *chooser) { GtkWidget *dialog, *status; GPPortInfo info; Camera *camera; CameraAbilities abilities; const gchar *model, *port, *speed; gchar *port_path, *right, *tmp; int m, p, r; gboolean multi; GtkamCamera *c; model = gtk_entry_get_text (chooser->priv->entry_model); port = gtk_entry_get_text (chooser->priv->entry_port); speed = gtk_entry_get_text (chooser->priv->entry_speed); multi = GTK_TOGGLE_BUTTON (chooser->priv->check_multi)->active; if (!port || !*port) port_path = g_strdup (_("None")); else { port_path = g_strdup (port); right = strrchr (port_path, ')'); *right = '\0'; tmp = g_strdup (strrchr (port_path, '(') + 1); g_free (port_path); port_path = tmp; } gp_camera_new (&camera); #ifdef HAVE_GP_CAMERA_SET_TIMEOUT_FUNCS gp_camera_set_timeout_funcs (camera, start_timeout_func, stop_timeout_func, NULL); #endif /* Model? */ m = gp_abilities_list_lookup_model (chooser->priv->al, model); gp_abilities_list_get_abilities (chooser->priv->al, m, &abilities); gp_camera_set_abilities (camera, abilities); /* Port? */ if (strcmp (port_path, _("None"))) { p = gp_port_info_list_lookup_path (chooser->priv->il, port_path); gp_port_info_list_get_info (chooser->priv->il, p, &info); gp_camera_set_port_info (camera, info); } /* Speed? */ if (strcmp (speed, _("Best"))) gp_camera_set_port_speed (camera, atoi (speed)); /* * Initialize the camera to check if it is really there. Exit * afterwards because other applications could need the camera, too. */ status = gtkam_status_new (_("Initializing camera...")); gtkam_dialog_add_status (GTKAM_DIALOG (chooser), status); r = gp_camera_init (camera, GTKAM_STATUS (status)->context->context); if (multi) gp_camera_exit (camera, NULL); switch (r) { case GP_OK: break; case GP_ERROR_CANCEL: g_free (port_path); break; default: g_free (port_path); dialog = gtkam_error_new (r, GTKAM_STATUS (status)->context, NULL, _("Could not initialize camera.")); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (chooser)); gtk_widget_show (dialog); gp_camera_unref (camera); camera = NULL; } gtk_object_destroy (GTK_OBJECT (status)); c = gtkam_camera_new (camera, multi); gp_camera_unref (camera); return (c); }
int imp_kr_r(class imp_kr_rek *rek, GtkWidget *wpredok) { char strsql[512]; iceb_u_spisok repl_s; class imp_kr_r_data data; data.rk=rek; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1); sprintf(strsql,"%s %s",name_system,gettext("Импорт документов")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(imp_kr_r_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox=gtk_vbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(data.window), vbox); data.label=gtk_label_new(gettext("Ждите !!!")); gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0); GtkWidget *label=gtk_label_new(gettext("Импорт документов")); gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0); data.view=gtk_text_view_new(); gtk_widget_set_usize(GTK_WIDGET(data.view),450,300); gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста //PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 12"); PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno()); gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango); pango_font_description_free(font_pango); data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view)); GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL); //gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(sw),data.view); data.bar=gtk_progress_bar_new(); gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS); gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT); gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka=gtk_button_new_with_label(strsql); GtkTooltips *tooltops=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(imp_kr_r_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0); gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2); gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна gtk_widget_show_all(data.window); //gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна //gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна gtk_idle_add((GtkFunction)imp_kr_r1,&data); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
static void dlg_photo_importer (GthBrowser *browser, GFile *source, DlgImporterSourceType selector_type) { DialogData *data; GtkCellRenderer *renderer; GthFileDataSort *sort_type; GList *tests, *scan; char *general_filter; int i, active_filter; int i_general; if (gth_browser_get_dialog (browser, "photo_importer") != NULL) { gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "photo_importer"))); return; } data = g_new0 (DialogData, 1); data->browser = browser; data->builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/photo_importer/data/ui/photo-importer.ui"); data->settings = g_settings_new (GTHUMB_PHOTO_IMPORTER_SCHEMA); data->selector_type = selector_type; data->source = _g_object_ref (source); data->cancellable = g_cancellable_new (); data->vfs_source = g_object_new (GTH_TYPE_FILE_SOURCE_VFS, NULL); gth_file_source_monitor_entry_points (GTH_FILE_SOURCE (data->vfs_source)); /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "photo_importer_dialog"); _gtk_window_resize_to_fit_screen_height (data->dialog, 580); gth_browser_set_dialog (browser, "photo_importer", data->dialog); g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) { gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Removable Device")); data->device_list_store = gtk_list_store_new (SOURCE_LIST_COLUMNS, G_TYPE_OBJECT, G_TYPE_ICON, G_TYPE_STRING); data->device_chooser = gtk_combo_box_new_with_model (GTK_TREE_MODEL (data->device_list_store)); gtk_widget_show (data->device_chooser); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->device_chooser, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->device_chooser); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser), renderer, "gicon", SOURCE_LIST_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser), renderer, "text", SOURCE_LIST_COLUMN_NAME, NULL); g_object_unref (data->device_list_store); } else { if (data->source == NULL) { if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser))) data->source = _g_object_ref (gth_browser_get_location (browser)); if (data->source == NULL) data->source = g_file_new_for_uri (get_home_uri ()); } gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Folder")); data->folder_chooser = gtk_file_chooser_button_new (_("Choose a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->folder_chooser); gtk_file_chooser_set_file (GTK_FILE_CHOOSER (data->folder_chooser), data->source, NULL); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->folder_chooser), FALSE); gtk_widget_show (data->folder_chooser); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->folder_chooser, TRUE, TRUE, 0); } data->file_list = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NORMAL, FALSE); sort_type = gth_main_get_sort_type ("file::mtime"); gth_file_list_set_sort_func (GTH_FILE_LIST (data->file_list), sort_type->cmp_func, FALSE); gth_file_list_enable_thumbs (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_thumb_size (GTH_FILE_LIST (data->file_list), 128); gth_file_list_set_caption (GTH_FILE_LIST (data->file_list), "standard::display-name,gth::file::display-size"); gtk_widget_show (data->file_list); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("filelist_box")), data->file_list, TRUE, TRUE, 0); tests = gth_main_get_registered_objects_id (GTH_TYPE_TEST); general_filter = "file::type::is_media"; /* default value */ active_filter = 0; data->filter_combobox = gtk_combo_box_text_new (); for (i = 0, i_general = -1, scan = tests; scan; scan = scan->next, i++) { const char *registered_test_id = scan->data; GthTest *test; if (strncmp (registered_test_id, "file::type::", 12) != 0) continue; i_general += 1; test = gth_main_get_registered_object (GTH_TYPE_TEST, registered_test_id); if (strcmp (registered_test_id, general_filter) == 0) { active_filter = i_general; gth_file_list_set_filter (GTH_FILE_LIST (data->file_list), test); } data->general_tests = g_list_prepend (data->general_tests, g_strdup (gth_test_get_id (test))); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->filter_combobox), gth_test_get_display_name (test)); g_object_unref (test); } data->general_tests = g_list_reverse (data->general_tests); gtk_combo_box_set_active (GTK_COMBO_BOX (data->filter_combobox), active_filter); gtk_widget_show (data->filter_combobox); gtk_container_add (GTK_CONTAINER (GET_WIDGET ("filter_box")), data->filter_combobox); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("filter_label")), data->filter_combobox); gtk_label_set_use_underline (GTK_LABEL (GET_WIDGET ("filter_label")), TRUE); _g_string_list_free (tests); data->tags_entry = gth_tags_entry_new (GTH_TAGS_ENTRY_MODE_POPUP); gtk_widget_show (data->tags_entry); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("tags_entry_box")), data->tags_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("tags_label")), data->tags_entry); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("delete_checkbutton")), g_settings_get_boolean (data->settings, PREF_PHOTO_IMPORTER_DELETE_FROM_DEVICE)); data->preferences_dialog = gth_import_preferences_dialog_new (); gtk_window_set_transient_for (GTK_WINDOW (data->preferences_dialog), GTK_WINDOW (data->dialog)); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("destination_button_box")), gth_import_destination_button_new (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog)), TRUE, TRUE, 0); gtk_widget_show_all (GET_WIDGET ("destination_button_box")); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "delete-event", G_CALLBACK (dialog_delete_event_cb), data); g_signal_connect (GET_WIDGET ("ok_button"), "clicked", G_CALLBACK (ok_clicked_cb), data); g_signal_connect (GET_WIDGET ("cancel_button"), "clicked", G_CALLBACK (close_dialog), data); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) g_signal_connect (data->device_chooser, "changed", G_CALLBACK (device_chooser_changed_cb), data); else g_signal_connect (data->folder_chooser, "selection-changed", G_CALLBACK (folder_chooser_file_set_cb), data); g_signal_connect (data->filter_combobox, "changed", G_CALLBACK (filter_combobox_changed_cb), data); g_signal_connect (gth_file_view_get_model (GTH_FILE_VIEW (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)))), "visibility_changed", G_CALLBACK (file_store_changed_cb), data); g_signal_connect (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)), "file-selection-changed", G_CALLBACK (file_view_selection_changed_cb), data); data->entry_points_changed_id = g_signal_connect (gth_main_get_default_monitor (), "entry-points-changed", G_CALLBACK (entry_points_changed_cb), data); g_signal_connect_after (GET_WIDGET ("event_entry"), "changed", G_CALLBACK (event_entry_changed_cb), data); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser)); gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE); gtk_widget_show (data->dialog); gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog), gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("event_entry")))); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) update_device_source_list (data); else load_file_list (data); }
/** popup a calendar next to the entry * * \param entry the date entry * * \return a GtkWindow wich contains the calendar * */ GtkWidget *gsb_calendar_entry_popup ( GtkWidget *entry ) { GtkWidget *popup, *pVBox, *pCalendar, *button, *frame; GtkRequisition *popup_size; gint x, y; gint screen_width = gdk_screen_width ( ); GDate * date; /* make the popup */ popup = gtk_window_new ( GTK_WINDOW_TOPLEVEL ); gtk_window_set_modal ( GTK_WINDOW ( popup ), TRUE ); gtk_window_set_transient_for ( GTK_WINDOW ( popup ), GTK_WINDOW ( run.window ) ); gtk_window_set_decorated ( GTK_WINDOW ( popup ), FALSE ); g_signal_connect_swapped ( G_OBJECT ( popup ), "destroy", G_CALLBACK ( gdk_pointer_ungrab ), GDK_CURRENT_TIME ); /* set the decoration */ frame = gtk_frame_new ( NULL ); gtk_container_add ( GTK_CONTAINER ( popup ), frame ); gtk_widget_show ( frame ); pVBox = gtk_vbox_new ( FALSE, 5 ); gtk_container_set_border_width ( GTK_CONTAINER ( pVBox ), 5 ); gtk_container_add ( GTK_CONTAINER ( frame ), pVBox ); gtk_widget_show ( pVBox ); /* get the date */ date = gsb_calendar_entry_get_date (entry); if (!date) date = gdate_today (); /* set the calendar */ pCalendar = gtk_calendar_new(); gtk_calendar_select_month ( GTK_CALENDAR ( pCalendar ), g_date_get_month ( date ) - 1, g_date_get_year ( date ) ); gtk_calendar_select_day ( GTK_CALENDAR ( pCalendar ), g_date_get_day ( date ) ); g_signal_connect ( G_OBJECT ( pCalendar ), "day_selected_double_click", G_CALLBACK ( gsb_calendar_entry_select_date ), entry ); g_signal_connect ( G_OBJECT ( pCalendar ), "key-press-event", G_CALLBACK ( gsb_calendar_entry_calendar_key_press ), entry ); gtk_box_pack_start ( GTK_BOX ( pVBox ), pCalendar, TRUE, TRUE, 0 ); gtk_widget_show ( pCalendar ); /* cancel button */ button = gtk_button_new_with_label ( _("Cancel") ); g_signal_connect_swapped ( G_OBJECT ( button ), "clicked", G_CALLBACK ( gtk_widget_destroy ), G_OBJECT ( popup )); gtk_box_pack_start ( GTK_BOX ( pVBox ), button, TRUE, TRUE, 0 ); gtk_widget_show ( button ); /* set the position */ gdk_window_get_origin ( GTK_WIDGET ( entry ) -> window, &x, &y ); /* on récupère la taille de la popup */ popup_size = g_malloc0 ( sizeof ( GtkRequisition )); gtk_widget_size_request ( GTK_WIDGET ( popup ), popup_size ); /* pour la soustraire à la position de l'entrée date */ y -= popup_size -> height; /* on décale le popup si on est trop près de bord droit de l'écran */ if ( x > ( screen_width - popup_size -> width ) ) x = screen_width - popup_size -> width - 10; /* si une des coordonnées est négative, alors la fonction gtk_window_move échoue et affiche la popup en 0,0 */ if ( x < 0 ) x = 0 ; if ( y < 0 ) y = 0 ; gtk_window_move ( GTK_WINDOW ( popup ), x, y ); gtk_widget_show ( popup ); gtk_widget_grab_focus ( GTK_WIDGET ( pCalendar ) ); return ( popup ); }
static void _admin_front_end(GtkTreeModel *model, GtkTreeIter *iter, char *type, char *node_list) { uint16_t state = (uint16_t) NO_VAL; update_front_end_msg_t front_end_update_msg; char *new_type = NULL, *reason = NULL; char tmp_char[100]; char *lower; int rc; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkWidget *popup = gtk_dialog_new_with_buttons( type, GTK_WINDOW(main_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); gtk_window_set_transient_for(GTK_WINDOW(popup), NULL); label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_YES, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (!strncasecmp("Drain", type, 5)) { new_type = "DRAIN"; reason = "\n\nPlease enter reason."; state = NODE_STATE_DRAIN; entry = create_entry(); } else if (!strncasecmp("Resume", type, 6)) { new_type = "RESUME"; reason = ""; state = NODE_RESUME; } snprintf(tmp_char, sizeof(tmp_char), "Are you sure you want to set state of front end node %s " "to %s?%s", node_list, new_type, reason); label = gtk_label_new(tmp_char); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), label, FALSE, FALSE, 0); if (entry) gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), entry, TRUE, TRUE, 0); gtk_widget_show_all(popup); rc = gtk_dialog_run (GTK_DIALOG(popup)); slurm_init_update_front_end_msg(&front_end_update_msg); if (rc == GTK_RESPONSE_OK) { front_end_update_msg.name = node_list; front_end_update_msg.node_state = state; if (entry) { front_end_update_msg.reason = xstrdup( gtk_entry_get_text(GTK_ENTRY(entry))); if (!front_end_update_msg.reason || !strlen(front_end_update_msg.reason)) { lower = g_strdup_printf( "You need a reason to do that."); display_edit_note(lower); g_free(lower); goto end_it; } rc = uid_from_string(getlogin(), &front_end_update_msg.reason_uid); if (rc < 0) front_end_update_msg.reason_uid = getuid(); } rc = slurm_update_front_end(&front_end_update_msg); if (rc == SLURM_SUCCESS) { lower = g_strdup_printf( "Nodes %s updated successfully.", node_list); display_edit_note(lower); g_free(lower); } else { lower = g_strdup_printf( "Problem updating nodes %s: %s", node_list, slurm_strerror(rc)); display_edit_note(lower); g_free(lower); } } end_it: global_entry_changed = 0; xfree(front_end_update_msg.reason); gtk_widget_destroy(popup); if (got_edit_signal) { type = got_edit_signal; got_edit_signal = NULL; _admin_front_end(model, iter, type, node_list); xfree(type); } return; }
SelectBooksDialog::SelectBooksDialog(bool showportions, GtkWindow *parent) /* This dialog selects books. This function takes the book from the project that is now open, and the language of that project. It then loads the books. bookset: Indicator for the caller's relevant books. */ { // Initialize variables. extern Settings *settings; myproject = settings->genconfig.project_get(); ProjectConfiguration *projectconfig = settings->projectconfig(myproject); mylanguage = projectconfig->language_get(); myselectables = project_get_books(myproject); myshowportions = showportions; // Build dialog. Shortcuts shortcuts(0); selectbooksdialog = gtk_dialog_new(); ustring title(_("Select books")); if (showportions) { title.append(_(" and portions")); } gtk_window_set_title(GTK_WINDOW(selectbooksdialog), title.c_str()); gtk_window_set_transient_for(GTK_WINDOW(selectbooksdialog), parent); gtk_window_set_position(GTK_WINDOW(selectbooksdialog), GTK_WIN_POS_CENTER_ALWAYS); // was GTK_WIN_POS_CENTER_ON_PARENT gtk_window_set_modal(GTK_WINDOW(selectbooksdialog), TRUE); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(selectbooksdialog)); gtk_widget_show(dialog_vbox1); vbox1 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0); hbox11 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox11); gtk_box_pack_start(GTK_BOX(vbox1), hbox11, TRUE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox2); gtk_box_pack_start(GTK_BOX(hbox11), vbox2, TRUE, TRUE, 0); labelbooks = gtk_label_new(_("Books")); gtk_widget_show(labelbooks); gtk_box_pack_start(GTK_BOX(vbox2), labelbooks, FALSE, FALSE, 0); shortcuts.label(labelbooks); scrolledwindowbooks = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindowbooks); gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindowbooks, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindowbooks), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindowbooks), GTK_SHADOW_IN); treeviewbooks = gtk_tree_view_new(); gtk_widget_show(treeviewbooks); gtk_container_add(GTK_CONTAINER(scrolledwindowbooks), treeviewbooks); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeviewbooks), FALSE); vbox3 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox3); gtk_box_pack_start(GTK_BOX(hbox11), vbox3, TRUE, TRUE, 0); if (myshowportions) { labelportions = gtk_label_new(_("Portions")); gtk_widget_show(labelportions); gtk_box_pack_start(GTK_BOX(vbox3), labelportions, FALSE, FALSE, 0); shortcuts.label(labelportions); scrolledwindowportions = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindowportions); gtk_box_pack_start(GTK_BOX(vbox3), scrolledwindowportions, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindowportions), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindowportions), GTK_SHADOW_IN); treeviewportions = gtk_tree_view_new(); gtk_widget_show(treeviewportions); gtk_container_add(GTK_CONTAINER(scrolledwindowportions), treeviewportions); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeviewportions), FALSE); } table1 = gtk_table_new(2, 3, FALSE); gtk_widget_show(table1); gtk_box_pack_start(GTK_BOX(vbox1), table1, FALSE, FALSE, 0); nobutton = gtk_button_new(); gtk_widget_show(nobutton); gtk_table_attach(GTK_TABLE(table1), nobutton, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment1 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment1); gtk_container_add(GTK_CONTAINER(nobutton), alignment1); hbox4 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox4); gtk_container_add(GTK_CONTAINER(alignment1), hbox4); image1 = gtk_image_new_from_stock("gtk-clear", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image1); gtk_box_pack_start(GTK_BOX(hbox4), image1, FALSE, FALSE, 0); label6 = gtk_label_new_with_mnemonic(_("No books")); gtk_widget_show(label6); gtk_box_pack_start(GTK_BOX(hbox4), label6, FALSE, FALSE, 0); shortcuts.label(label6); otbutton = gtk_button_new(); gtk_widget_show(otbutton); gtk_table_attach(GTK_TABLE(table1), otbutton, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment2 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment2); gtk_container_add(GTK_CONTAINER(otbutton), alignment2); hbox5 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox5); gtk_container_add(GTK_CONTAINER(alignment2), hbox5); image2 = gtk_image_new_from_stock("gtk-goto-first", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image2); gtk_box_pack_start(GTK_BOX(hbox5), image2, FALSE, FALSE, 0); label7 = gtk_label_new_with_mnemonic(_("Old Testament")); gtk_widget_show(label7); gtk_box_pack_start(GTK_BOX(hbox5), label7, FALSE, FALSE, 0); shortcuts.label(label7); ntbutton = gtk_button_new(); gtk_widget_show(ntbutton); gtk_table_attach(GTK_TABLE(table1), ntbutton, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment3 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment3); gtk_container_add(GTK_CONTAINER(ntbutton), alignment3); hbox6 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox6); gtk_container_add(GTK_CONTAINER(alignment3), hbox6); image3 = gtk_image_new_from_stock("gtk-goto-last", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image3); gtk_box_pack_start(GTK_BOX(hbox6), image3, FALSE, FALSE, 0); label8 = gtk_label_new_with_mnemonic(_("New Testament")); gtk_widget_show(label8); gtk_box_pack_start(GTK_BOX(hbox6), label8, FALSE, FALSE, 0); shortcuts.label(label8); otherbutton = gtk_button_new(); gtk_widget_show(otherbutton); gtk_table_attach(GTK_TABLE(table1), otherbutton, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment6 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment6); gtk_container_add(GTK_CONTAINER(otherbutton), alignment6); hbox9 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox9); gtk_container_add(GTK_CONTAINER(alignment6), hbox9); image6 = gtk_image_new_from_stock("gtk-dialog-warning", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image6); gtk_box_pack_start(GTK_BOX(hbox9), image6, FALSE, FALSE, 0); label11 = gtk_label_new_with_mnemonic(_("Other books")); gtk_widget_show(label11); gtk_box_pack_start(GTK_BOX(hbox9), label11, FALSE, FALSE, 0); shortcuts.label(label11); allbutton = gtk_button_new(); gtk_widget_show(allbutton); gtk_table_attach(GTK_TABLE(table1), allbutton, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment4 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment4); gtk_container_add(GTK_CONTAINER(allbutton), alignment4); hbox7 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox7); gtk_container_add(GTK_CONTAINER(alignment4), hbox7); image4 = gtk_image_new_from_stock("gtk-add", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image4); gtk_box_pack_start(GTK_BOX(hbox7), image4, FALSE, FALSE, 0); label9 = gtk_label_new_with_mnemonic(_("All books")); gtk_widget_show(label9); gtk_box_pack_start(GTK_BOX(hbox7), label9, FALSE, FALSE, 0); shortcuts.label(label9); currentbutton = gtk_button_new(); gtk_widget_show(currentbutton); gtk_table_attach(GTK_TABLE(table1), currentbutton, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment5 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment5); gtk_container_add(GTK_CONTAINER(currentbutton), alignment5); hbox8 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox8); gtk_container_add(GTK_CONTAINER(alignment5), hbox8); image5 = gtk_image_new_from_stock("gtk-properties", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image5); gtk_box_pack_start(GTK_BOX(hbox8), image5, FALSE, FALSE, 0); label10 = gtk_label_new_with_mnemonic(_("Current book")); gtk_widget_show(label10); gtk_box_pack_start(GTK_BOX(hbox8), label10, FALSE, FALSE, 0); shortcuts.label(label10); dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(selectbooksdialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); const gchar *helpfile; if (showportions) { helpfile = "file/print/portion"; } else { helpfile = "file/print/selection"; } new InDialogHelp(selectbooksdialog, NULL, &shortcuts, helpfile); cancelbutton = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton); gtk_dialog_add_action_widget(GTK_DIALOG(selectbooksdialog), cancelbutton, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton), true); shortcuts.stockbutton(cancelbutton); okbutton = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton); gtk_dialog_add_action_widget(GTK_DIALOG(selectbooksdialog), okbutton, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton), true); shortcuts.stockbutton(okbutton); shortcuts.process(); g_signal_connect((gpointer) treeviewbooks, "key_press_event", G_CALLBACK(on_treeviewbooks_key_press_event), gpointer(this)); if (myshowportions) { g_signal_connect((gpointer) treeviewportions, "row_activated", G_CALLBACK(on_treeviewportions_row_activated), gpointer(this)); } g_signal_connect((gpointer) nobutton, "clicked", G_CALLBACK(on_nobutton_clicked), gpointer(this)); g_signal_connect((gpointer) otbutton, "clicked", G_CALLBACK(on_otbutton_clicked), gpointer(this)); g_signal_connect((gpointer) ntbutton, "clicked", G_CALLBACK(on_ntbutton_clicked), gpointer(this)); g_signal_connect((gpointer) otherbutton, "clicked", G_CALLBACK(on_otherbutton_clicked), gpointer(this)); g_signal_connect((gpointer) allbutton, "clicked", G_CALLBACK(on_allbutton_clicked), gpointer(this)); g_signal_connect((gpointer) currentbutton, "clicked", G_CALLBACK(on_currentbutton_clicked), gpointer(this)); g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); gtk_widget_grab_focus(treeviewbooks); gtk_widget_grab_default(okbutton); gtk_label_set_mnemonic_widget(GTK_LABEL(labelbooks), treeviewbooks); if (myshowportions) gtk_label_set_mnemonic_widget(GTK_LABEL(labelportions), treeviewportions); // Storage, renderer, column and selection for books. { storebooks = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeviewbooks), GTK_TREE_MODEL(storebooks)); g_object_unref(storebooks); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); columnbooks = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeviewbooks), columnbooks); selectbooks = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviewbooks)); gtk_tree_selection_set_mode(selectbooks, GTK_SELECTION_MULTIPLE); } // Storage, renderer, column and selection for portions. if (myshowportions) { storeportions = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeviewportions), GTK_TREE_MODEL(storeportions)); g_object_unref(storeportions); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); columnportions = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeviewportions), columnportions); selectportions = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviewportions)); gtk_tree_selection_set_mode(selectportions, GTK_SELECTION_SINGLE); } // Load content. myselectables = project_get_books(myproject); loadbooks(); if (myshowportions) loadportions(); // Update gui. update_gui_event_id = 0; if (myshowportions) { update_gui_event_id = g_timeout_add_full(G_PRIORITY_DEFAULT, 100, GSourceFunc(on_update_gui_timeout), gpointer(this), NULL); } new DialogAutoScaler (selectbooksdialog, G_MAXINT); }
static GtkWidget * vnr_crop_build_dialog (VnrCrop *crop) { GtkBuilder *builder; GtkWidget *window; GdkPixbuf *original; GdkPixbuf *preview; GError *error = NULL; builder = gtk_builder_new (); gtk_builder_add_from_file (builder, CROP_UI_PATH, &error); if (error != NULL) { g_warning ("%s\n", error->message); g_object_unref(builder); return NULL; } window = GTK_WIDGET (gtk_builder_get_object (builder, "crop-dialog")); gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(crop->vnr_win)); original = uni_image_view_get_pixbuf(UNI_IMAGE_VIEW(crop->vnr_win->view)); gdouble width, height; width = crop->vnr_win->current_image_width; height = crop->vnr_win->current_image_height; vnr_tools_fit_to_size_double(&height, &width, 400,400); crop->width = width; crop->height = height; crop->zoom = ( width/crop->vnr_win->current_image_width + height/crop->vnr_win->current_image_height )/2; preview = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (original), gdk_pixbuf_get_has_alpha (original), gdk_pixbuf_get_bits_per_sample (original), width, height); uni_pixbuf_scale_blend(original, preview, 0, 0, width, height, 0, 0, crop->zoom, GDK_INTERP_BILINEAR, 0, 0); crop->preview_pixbuf = preview; crop->image = GTK_WIDGET (gtk_builder_get_object (builder, "main-image")); gtk_widget_set_size_request(crop->image, width, height); crop->spin_x = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "spin-x")); gtk_spin_button_set_range (crop->spin_x, 0, crop->vnr_win->current_image_width - 1); gtk_spin_button_set_increments (crop->spin_x, 1, 10); crop->spin_y = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "spin-y")); gtk_spin_button_set_range (crop->spin_y, 0, crop->vnr_win->current_image_height - 1); gtk_spin_button_set_increments (crop->spin_y, 1, 10); crop->spin_width = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "spin-width")); gtk_spin_button_set_range (crop->spin_width, 1, crop->vnr_win->current_image_width); gtk_spin_button_set_increments (crop->spin_width, 1, 10); gtk_spin_button_set_value (crop->spin_width, crop->vnr_win->current_image_width); crop->spin_height = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "spin-height")); gtk_spin_button_set_range (crop->spin_height, 1, crop->vnr_win->current_image_height); gtk_spin_button_set_increments (crop->spin_height, 1, 10); gtk_spin_button_set_value (crop->spin_height, crop->vnr_win->current_image_height); gtk_widget_set_events (crop->image, GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_MOTION_MASK); g_signal_connect (crop->image, "expose-event", G_CALLBACK (drawable_expose_cb), crop); g_signal_connect (crop->image, "button-press-event", G_CALLBACK (drawable_button_press_cb), crop); g_signal_connect (crop->image, "button-release-event", G_CALLBACK (drawable_button_release_cb), crop); g_signal_connect (crop->image, "motion-notify-event", G_CALLBACK (drawable_motion_cb), crop); g_signal_connect (crop->spin_width, "value-changed", G_CALLBACK (spin_width_cb), crop); g_signal_connect (crop->spin_x, "value-changed", G_CALLBACK (spin_x_cb), crop); g_signal_connect (crop->spin_height, "value-changed", G_CALLBACK (spin_height_cb), crop); g_signal_connect (crop->spin_y, "value-changed", G_CALLBACK (spin_y_cb), crop); g_object_unref(builder); return window; }
int l_xrnngvn_v(class iceb_u_str *kod_gr,GtkWidget *wpredok) { class l_xrnngvn_v_data data; char strsql[512]; iceb_u_str kikz; data.kod_gr.new_plus(kod_gr->ravno()); data.rk.clear_data(); if(data.kod_gr.getdlinna() > 1) { data.rk.kod.new_plus(data.kod_gr.ravno()); sprintf(strsql,"select * from Reegrup2 where kod='%s'",data.kod_gr.ravno()); SQL_str row; SQLCURSOR cur; if(iceb_sql_readkey(strsql,&row,&cur,wpredok) < 1) { iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok); return(1); } data.rk.naim.new_plus(row[1]); kikz.plus(iceb_kikz(row[2],row[3],wpredok)); } data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); GtkWidget *label=NULL; if(data.kod_gr.getdlinna() <= 1) { sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи")); label=gtk_label_new(gettext("Ввод новой записи")); } else { sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи")); iceb_u_str repl; repl.plus(gettext("Корректировка записи")); repl.ps_plus(kikz.ravno()); label=gtk_label_new(repl.ravno_toutf()); } gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_xrnngvn_v_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox = gtk_vbox_new (FALSE,1); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE,1); GtkWidget *hboxknop = gtk_hbox_new (FALSE,1); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); label=gtk_label_new(gettext("Код")); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE,1); data.entry[E_KOD] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE,1); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(l_xrnngvn_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD); label=gtk_label_new(gettext("Наименование")); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE,1); data.entry[E_NAIM] = gtk_entry_new_with_max_length (100); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE,1); gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(l_xrnngvn_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM); GtkTooltips *tooltips[KOL_FK]; sprintf(strsql,"F2 %s",gettext("Запись")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Запись введеной в меню информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(l_xrnngvn_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE,1); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы с меню без записи введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(l_xrnngvn_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE,1); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(data.voz == 0) kod_gr->new_plus(data.rk.kod.ravno()); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
CheckbuttonDialog::CheckbuttonDialog(const ustring & title, const ustring & info, const vector < ustring > &labels, ustring bitpattern, GtkWindow *transient_parent) { Shortcuts shortcuts(0); checkbuttondialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(checkbuttondialog), transient_parent); gtk_window_set_title(GTK_WINDOW(checkbuttondialog), title.c_str()); //gtk_window_set_position(GTK_WINDOW(checkbuttondialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal(GTK_WINDOW(checkbuttondialog), TRUE); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(checkbuttondialog)); gtk_widget_show(dialog_vbox1); label = gtk_label_new(info.c_str()); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(dialog_vbox1), label, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); for (unsigned int i = 0; i < labels.size(); i++) { GtkWidget *checkbutton; checkbutton = gtk_check_button_new_with_mnemonic(labels[i].c_str()); gtk_widget_show(checkbutton); gtk_box_pack_start(GTK_BOX(dialog_vbox1), checkbutton, FALSE, FALSE, 0); checkbuttons.push_back(checkbutton); shortcuts.button(checkbutton); if (bitpattern_take(bitpattern)) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true); } } dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(checkbuttondialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); new InDialogHelp(checkbuttondialog, NULL, &shortcuts, NULL); cancelbutton = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton); gtk_dialog_add_action_widget(GTK_DIALOG(checkbuttondialog), cancelbutton, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton), true); okbutton = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton); gtk_dialog_add_action_widget(GTK_DIALOG(checkbuttondialog), okbutton, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton), true); shortcuts.stockbutton(cancelbutton); shortcuts.stockbutton(okbutton); shortcuts.process(); g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); gtk_widget_grab_default(okbutton); gtk_widget_grab_focus(okbutton); }
void cir_gtk_help_about(GtkWidget *widget, gpointer data) { gtk_window_set_transient_for(GTK_WINDOW(data), GTK_WINDOW(mainwindow)); gtk_dialog_run(data); gtk_widget_hide(data); }
void lzaktaxiv(class lzaktaxi_data *gl_data) { class lzaktaxiv_data v_data; v_data.zap_zaktaxi.clear_data(); char strsql[300]; SQL_str row; short d,m,g; time_t vrem; struct tm *bf; int i=0; v_data.metkavz=gl_data->metkavz; v_data.metkarr=gl_data->metkarr; v_data.metkazapisi=gl_data->metkazapisi; time(&v_data.vremnz); //v_data->zap_zaktaxi.clear_data(); v_data.zap_zaktaxi.suma.new_plus("1"); if(gl_data->metkazapisi == 1) { if(gl_data->metkavz == 0) return; v_data.vrem.new_plus(gl_data->rowv[16]); v_data.datz.new_plus(gl_data->rowv[8]); v_data.vremz.new_plus(gl_data->rowv[9]); SQLCURSOR cur; if(gl_data->rowv[0][0] != '\0') { sprintf(strsql,"select naik from Taxikzz where kod=%s",gl_data->rowv[0]); if(iceb_sql_readkey(strsql,&row,&cur,gl_data->window) == 1) { sprintf(strsql,"%s %s",gl_data->rowv[0],row[0]); v_data.zap_zaktaxi.kodzav.new_plus(strsql); } } v_data.zap_zaktaxi.kodk.new_plus(gl_data->rowv[1]); if(gl_data->rowv[2][0] != '\0') { sprintf(strsql,"select fio,gosn from Taxivod where kod='%s'",gl_data->rowv[2]); if(sql_readkey(&bd,strsql,&row,&cur) == 1) { sprintf(strsql,"%s %s %s",gl_data->rowv[2],row[0],row[1]); v_data.zap_zaktaxi.kv.new_plus(strsql); } } v_data.zap_zaktaxi.fio.new_plus(gl_data->rowv[3]); v_data.zap_zaktaxi.telef.new_plus(gl_data->rowv[4]); v_data.zap_zaktaxi.kolp.new_plus(gl_data->rowv[5]); v_data.zap_zaktaxi.datvz.new_plus(iceb_u_datzap(gl_data->rowv[6])); v_data.zap_zaktaxi.vremvz.new_plus(gl_data->rowv[7]); v_data.zap_zaktaxi.adreso.new_plus(gl_data->rowv[10]); v_data.zap_zaktaxi.adresk.new_plus(gl_data->rowv[11]); v_data.zap_zaktaxi.koment.new_plus(gl_data->rowv[12]); v_data.zap_zaktaxi.suma.new_plus(gl_data->rowv[13]); } v_data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); //gtk_window_set_position( GTK_WINDOW(v_data.window),ICEB_POS_CENTER); //gtk_widget_set_usize(GTK_WIDGET(v_data.window), 600,180); //if(v_data.metkazapisi == 1) gdk_window_set_cursor(gl_data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(v_data.window),GTK_WINDOW(gl_data->window)); gtk_window_set_modal( GTK_WINDOW(v_data.window) ,TRUE ); if(gl_data->metkazapisi == 0) sprintf(strsql,"%s %s",NAME_SYSTEM,iceb_u_toutf("Ввод новой записи")); if(gl_data->metkazapisi == 1) sprintf(strsql,"%s %s",NAME_SYSTEM,iceb_u_toutf("Корректировка записи")); gtk_window_set_title(GTK_WINDOW(v_data.window),strsql); gtk_signal_connect(GTK_OBJECT(v_data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(v_data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(v_data.window),"key_press_event",GTK_SIGNAL_FUNC(vzaktaxi_key_press),&v_data); //gtk_signal_connect_after(GTK_OBJECT(v_data.window),"key_release_event",GTK_SIGNAL_FUNC(obr_klav_plansh_o),gl_data); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox = gtk_hbox_new (FALSE, 0); GtkWidget *hbox1 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox2 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox3 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox4 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox5 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox6 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox7 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox8 = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (v_data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), hbox1); //Адрес подачи gtk_container_add (GTK_CONTAINER (vbox), hbox2); //Адрес поездки gtk_container_add (GTK_CONTAINER (vbox), hbox3); //Код водителя gtk_container_add (GTK_CONTAINER (vbox), hbox5); //Код завершения gtk_container_add (GTK_CONTAINER (vbox), hbox); //Телефон, код клиента gtk_container_add (GTK_CONTAINER (vbox), hbox4); //Коментарий gtk_container_add (GTK_CONTAINER (vbox), hbox6); //Сумма, количество пассажиров gtk_container_add (GTK_CONTAINER (vbox), hbox7); //Фамилия клиента gtk_container_add (GTK_CONTAINER (vbox), hbox8); //Дата , время выполнения заказа gtk_container_add (GTK_CONTAINER (vbox), hboxknop); GtkWidget *label=gtk_label_new(iceb_u_toutf("Телефон")); v_data.entry[E_TELEF] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), v_data.entry[E_TELEF], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_TELEF]), "activate",GTK_SIGNAL_FUNC(get_telef),&v_data); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_TELEF]),v_data.zap_zaktaxi.telef.ravno_toutf()); //gtk_widget_set_usize(v_data.entry[E_TELEF],100,20); label=gtk_label_new(iceb_u_toutf("Код клиента")); v_data.entry[E_KODKL] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), v_data.entry[E_KODKL], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_KODKL]), "activate",GTK_SIGNAL_FUNC(kodkl_get),&v_data); //gtk_widget_set_usize(v_data.entry[E_KODKL],60,20); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_KODKL]),v_data.zap_zaktaxi.kodk.ravno_toutf()); label=gtk_label_new(iceb_u_toutf("Адрес подачи")); v_data.entry[E_ADRES_POD] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox1), v_data.entry[E_ADRES_POD], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_ADRES_POD]), "activate",GTK_SIGNAL_FUNC(iceb_get_text_str),&v_data.zap_zaktaxi.adreso); //gtk_widget_set_usize(v_data.entry[E_ADRES_POD],200,20); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_ADRES_POD]),v_data.zap_zaktaxi.adreso.ravno_toutf()); label=gtk_label_new(iceb_u_toutf("Адрес поездки")); v_data.entry[E_ADRES_POEZ] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox2), v_data.entry[E_ADRES_POEZ], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_ADRES_POEZ]), "activate",GTK_SIGNAL_FUNC(iceb_get_text_str),&v_data.zap_zaktaxi.adresk); //gtk_widget_set_usize(v_data.entry[E_ADRES_POEZ],200,20); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_ADRES_POEZ]),v_data.zap_zaktaxi.adresk.ravno_toutf()); label=gtk_label_new(iceb_u_toutf("Код водителя")); gtk_box_pack_start (GTK_BOX (hbox3), label, FALSE, FALSE, 0); //Создаем выбор водителя GList *glist=NULL; SQLCURSOR cur; sprintf(strsql,"select kod,fio,gosn from Taxivod where sm=0 order by fio asc"); int kolstr=0; if((kolstr=cur.make_cursor(&bd,strsql)) < 0) iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,NULL); iceb_u_spisok VOD; while(cur.read_cursor(&row) != 0) { sprintf(strsql,"%s %s %s",row[0],row[1],row[2]); VOD.plus(iceb_u_toutf(strsql)); } if(kolstr == 0) VOD.plus(iceb_u_toutf("Не введен список водителей !!!")); v_data.windowvoditel=gtk_combo_new(); for(i=0 ; i < kolstr; i++) glist=g_list_append(glist,(void*)VOD.ravno(i)); gtk_combo_set_popdown_strings(GTK_COMBO(v_data.windowvoditel),glist); gtk_combo_disable_activate(GTK_COMBO(v_data.windowvoditel)); gtk_box_pack_start (GTK_BOX (hbox3), v_data.windowvoditel, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (GTK_COMBO(v_data.windowvoditel)->entry), "activate",GTK_SIGNAL_FUNC(voditel_get),&v_data); gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(v_data.windowvoditel)->entry),v_data.zap_zaktaxi.kv.ravno_toutf()); label=gtk_label_new(iceb_u_toutf("Коментарий")); v_data.entry[E_KOMENT] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox4), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox4), v_data.entry[E_KOMENT], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_KOMENT]), "activate",GTK_SIGNAL_FUNC(iceb_get_text_str),&v_data.zap_zaktaxi.koment); //gtk_widget_set_usize(v_data.entry[E_KOMENT],200,20); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_KOMENT]),v_data.zap_zaktaxi.koment.ravno_toutf()); label=gtk_label_new(iceb_u_toutf("Код завершения")); gtk_box_pack_start (GTK_BOX (hbox5), label, FALSE, FALSE, 0); //Создаем меню кодов завершения glist=NULL; sprintf(strsql,"select kod,naik from Taxikzz order by kod asc"); kolstr=0; if((kolstr=cur.make_cursor(&bd,strsql)) < 0) iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,NULL); iceb_u_spisok KZV; while(cur.read_cursor(&row) != 0) { sprintf(strsql,"%s %s",row[0],row[1]); KZV.plus(iceb_u_toutf(strsql)); } if(kolstr == 0) KZV.plus(iceb_u_toutf("Не введен список кодов завершения !!!")); v_data.windowkodzav=gtk_combo_new(); for(i=0 ; i < kolstr; i++) glist=g_list_append(glist,(void*)KZV.ravno(i)); gtk_combo_set_popdown_strings(GTK_COMBO(v_data.windowkodzav),glist); gtk_combo_disable_activate(GTK_COMBO(v_data.windowkodzav)); gtk_box_pack_start (GTK_BOX (hbox5), v_data.windowkodzav, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (GTK_COMBO(v_data.windowkodzav)->entry), "activate",GTK_SIGNAL_FUNC(kodzav_get),&v_data); //Если не выводить то в меню будет первая строка из списка //if(gl_data->metkazapisi == 1) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(v_data.windowkodzav)->entry),v_data.zap_zaktaxi.kodzav.ravno_toutf()); label=gtk_label_new(iceb_u_toutf("Сумма")); v_data.entry[E_SUMA] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox6), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox6), v_data.entry[E_SUMA], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_SUMA]), "activate",GTK_SIGNAL_FUNC(iceb_get_text_str),&v_data.zap_zaktaxi.suma); //gtk_widget_set_usize(v_data.entry[E_SUMA],40,20); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_SUMA]),v_data.zap_zaktaxi.suma.ravno_toutf()); double suma=0.; if(v_data.zap_zaktaxi.kodk.getdlinna() > 1) suma=taxi_saldo(v_data.zap_zaktaxi.kodk.ravno()); sprintf(strsql,"Сальдо: %.2f ",suma); v_data.label_saldo=gtk_label_new(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox6), v_data.label_saldo, FALSE, FALSE, 0); label=gtk_label_new(iceb_u_toutf("Количество пассажиров")); v_data.entry[E_KOLIH_PAS] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox6), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox6), v_data.entry[E_KOLIH_PAS], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_KOLIH_PAS]), "activate",GTK_SIGNAL_FUNC(iceb_get_text_str),&v_data.zap_zaktaxi.kolp); //gtk_widget_set_usize(v_data.entry[E_KOLIH_PAS],40,20); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_KOLIH_PAS]),v_data.zap_zaktaxi.kolp.ravno_toutf()); /********************************/ label=gtk_label_new(iceb_u_toutf("ФИО")); v_data.entry[E_FIO] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox7), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox7), v_data.entry[E_FIO], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_FIO]), "activate",GTK_SIGNAL_FUNC(iceb_get_text_str),&v_data.zap_zaktaxi.fio); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_FIO]),v_data.zap_zaktaxi.fio.ravno_toutf()); //gtk_widget_set_usize(v_data.entry[E_FIO],200,20); label=gtk_label_new(iceb_u_toutf("Дата вып.заказа")); v_data.entry[E_DATA_ZAK] = gtk_entry_new_with_max_length (11); gtk_box_pack_start (GTK_BOX (hbox8), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox8), v_data.entry[E_DATA_ZAK], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_DATA_ZAK]), "activate",GTK_SIGNAL_FUNC(iceb_get_text_str),&v_data.zap_zaktaxi.datvz); time(&vrem); bf=localtime(&vrem); if(gl_data->metkazapisi == 1) { gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_DATA_ZAK]),v_data.zap_zaktaxi.datvz.ravno()); // strcpy(strsql,v_data.zap_zaktaxi.datvz.ravno()); } /****** if(gl_data->metkazapisi == 0) { sprintf(strsql,"%02d.%02d.%04d",bf->tm_mday,bf->tm_mon+1,bf->tm_year+1900); v_data.zap_zaktaxi.datvz.new_plus(strsql); } *********/ //gtk_widget_set_usize(v_data.entry[E_DATA_ZAK],68,20); //gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_DATA_ZAK]),strsql); label=gtk_label_new(iceb_u_toutf("Время вып.заказа")); v_data.entry[E_VREM_ZAK] = gtk_entry_new_with_max_length (9); gtk_box_pack_start (GTK_BOX (hbox8), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox8), v_data.entry[E_VREM_ZAK], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (v_data.entry[E_VREM_ZAK]), "activate",GTK_SIGNAL_FUNC(iceb_get_text_str),&v_data.zap_zaktaxi.vremvz); if(gl_data->metkazapisi == 1) { iceb_u_rstime(&d,&m,&g,v_data.zap_zaktaxi.vremvz.ravno()); if(d != 0) sprintf(strsql,"%02d:%02d",d,m); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_VREM_ZAK]),strsql); } /************* if(gl_data->metkazapisi == 0) { sprintf(strsql,"%02d:%02d",bf->tm_hour,bf->tm_min); v_data.zap_zaktaxi.vremvz.new_plus(strsql); } //gtk_widget_set_usize(v_data.entry[E_VREM_ZAK],68,20); gtk_entry_set_text(GTK_ENTRY(v_data.entry[E_VREM_ZAK]),strsql); **************/ sprintf(strsql,"F2 %s",gettext("Запись")); v_data.knopka[FK2]=gtk_button_new_with_label(strsql); GtkTooltips *tooltips0=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips0,v_data.knopka[FK2],gettext("Запись введеной в меню информации"),NULL); gtk_signal_connect(GTK_OBJECT(v_data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(vzaktaxi_knopka),&v_data); gtk_object_set_user_data(GTK_OBJECT(v_data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), v_data.knopka[FK2], TRUE, TRUE, 0); if(gl_data->metkazapisi == 0) { sprintf(strsql,"F4 %s",gettext("Очистить")); v_data.knopka[FK4]=gtk_button_new_with_label(strsql); // GtkTooltips *tooltips2=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips0,v_data.knopka[FK4],gettext("Очистить меню от введеноой информации. Установить текущее время и дату"),NULL); gtk_signal_connect(GTK_OBJECT(v_data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(vzaktaxi_knopka),&v_data); gtk_object_set_user_data(GTK_OBJECT(v_data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), v_data.knopka[FK4], TRUE, TRUE, 0); } sprintf(strsql,"F10 %s",gettext("Выход")); v_data.knopka[FK10]=gtk_button_new_with_label(strsql); GtkTooltips *tooltips1=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips1,v_data.knopka[FK10],gettext("Завершение работы с меню без записи введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(v_data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(vzaktaxi_knopka),&v_data); gtk_object_set_user_data(GTK_OBJECT(v_data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), v_data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(v_data.entry[E_ADRES_POD]); if(gl_data->metkazapisi == 0) clear_menu(&v_data); gtk_widget_show_all (v_data.window); gtk_main(); gdk_window_set_cursor(gl_data->window->window,gdk_cursor_new(ICEB_CURSOR)); }
int kzvmu2(short dd,short md,short gd,int skl, const char *nomdok,int kodm,int nk, int sklad1, const char *nomdokp, GtkWidget *wpredok) { char strsql[512]; class kzvmu2_data data; iceb_u_str kikz; iceb_u_str naim_mat; SQLCURSOR cur; SQL_str row; iceb_u_str repl; //char bros[512]; //iceb_poldan("Н.Д.С.",bros,"matnast.alx",wpredok); //float pnds=iceb_u_atof(bros); float pnds=iceb_pnds(dd,md,gd,wpredok); data.dd=dd; data.md=md; data.gd=gd; data.sklad=skl; data.kodm=kodm; data.nom_kar=nk; data.nomdok.plus(nomdok); data.sklad1=sklad1; data.nomdokp.plus(nomdokp); naim_mat.plus(""); sprintf(strsql,"select naimat from Material where kodm=%d",kodm); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1) naim_mat.new_plus(row[0]); sprintf(strsql,"select kolih,cena,shet,nomz,ktoi,vrem,nomkarp from Dokummat1 where \ sklad=%d and nomd='%s' and kodm=%d and nomkar=%d and datd='%04d-%02d-%02d' \ and tipz=2",skl,nomdok,kodm,nk,gd,md,dd); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) < 1) { repl.new_plus(gettext("Не найдена запись для корректировки !")); repl.ps_plus(strsql); iceb_menu_soob(&repl,wpredok); return(1); } data.kolihz=atof(row[0]); sprintf(strsql,"%.10g",data.kolihz); data.kolih.plus(strsql); data.shet.plus(row[2]); data.nomerzak.plus(row[3]); double cena=atof(row[1]); sprintf(strsql,"%.10g",cena); data.cenabnds.plus(strsql); cena=cena+cena*pnds/100.; cena=iceb_u_okrug(cena,okrg1); sprintf(strsql,"%.10g",cena); data.cenasnds.plus(strsql); kikz.plus(iceb_kikz(row[4],row[5],wpredok)); data.nomkarp=atoi(row[6]); data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Корректировка выбранной записи")); gtk_window_set_title (GTK_WINDOW (data.window),strsql); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(kzvmu2_v_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } repl.new_plus(gettext("Корректировка выбранной записи")); repl.ps_plus(gettext("Материал")); repl.plus(":"); repl.plus(kodm); repl.plus(" "); repl.plus(naim_mat.ravno()); if(kikz.getdlinna() > 1) repl.ps_plus(kikz.ravno()); GtkWidget *label=gtk_label_new(repl.ravno_toutf()); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); sprintf(strsql,"%s",gettext("Количество")); label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_KOLIH] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_KOLIH]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_KOLIH]), data.entry[E_KOLIH], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOLIH]), "activate",GTK_SIGNAL_FUNC(kzvmu2_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOLIH]),data.kolih.ravno()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOLIH]),(gpointer)E_KOLIH); sprintf(strsql,"%s",gettext("Цена с НДС")); label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_CENASNDS] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_CENASNDS]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_CENASNDS]), data.entry[E_CENASNDS], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_CENASNDS]), "activate",GTK_SIGNAL_FUNC(kzvmu2_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_CENASNDS]),data.cenasnds.ravno()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_CENASNDS]),(gpointer)E_CENASNDS); sprintf(strsql,"%s",gettext("Цена без НДС")); label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_CENABNDS] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_CENABNDS]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_CENABNDS]), data.entry[E_CENABNDS], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_CENABNDS]), "activate",GTK_SIGNAL_FUNC(kzvmu2_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_CENABNDS]),data.cenabnds.ravno()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_CENABNDS]),(gpointer)E_CENABNDS); sprintf(strsql,"%s",gettext("Счёт")); label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_SHET] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.entry[E_SHET], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_SHET]), "activate",GTK_SIGNAL_FUNC(kzvmu2_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHET]),data.shet.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHET]),(gpointer)E_SHET); sprintf(strsql,"%s",gettext("Номер заказа")); label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_NOMERZAK] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_NOMERZAK]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_NOMERZAK]), data.entry[E_NOMERZAK], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_NOMERZAK]), "activate",GTK_SIGNAL_FUNC(kzvmu2_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NOMERZAK]),data.nomerzak.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NOMERZAK]),(gpointer)E_NOMERZAK); GtkTooltips *tooltips[KOL_F_KL]; sprintf(strsql,"F2 %s",gettext("Записать")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Записать введенную в меню информацию"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(kzvmu2_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(kzvmu2_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
static void event_about_clicked (GtkButton *widget, gpointer data) { std::string version_string; GtkBuilderWindow *about_dialog = new GtkBuilderWindow ("about_dialog"); Snes9xPreferences *preferences = (Snes9xPreferences *) data; PangoFontDescription *monospace; ((version_string += _("Snes9x version: ")) += VERSION) += ", "; ((version_string += _("GTK+ port version: ")) += SNES9X_GTK_VERSION) += "\n"; (version_string += SNES9X_GTK_AUTHORS) += "\n"; (version_string += _("English localization by Brandon Wright")) += "\n"; #if defined(USE_OPENGL) || defined(USE_XV) || defined(USE_XRANDR) \ || defined(USE_JOYSTICK) || defined(NETPLAY_SUPPORT) version_string += _("\nFeatures enabled:<i>"); #else version_string += _(" Only barebones features enabled<i>"); #endif #ifdef USE_OPENGL version_string += _(" OpenGL"); #endif #ifdef USE_XV version_string += _(" XVideo"); #endif #ifdef USE_XRANDR version_string += _(" XRandR"); #endif #ifdef USE_JOYSTICK version_string += _(" Joystick"); #endif #ifdef NETPLAY_SUPPORT version_string += _(" NetPlay"); #endif version_string += "</i>"; gtk_label_set_label (GTK_LABEL (about_dialog->get_widget ("version_string_label")), version_string.c_str ()); gtk_image_set_from_pixbuf (GTK_IMAGE (about_dialog->get_widget ("preferences_splash")), top_level->splash); monospace = pango_font_description_from_string ("Monospace 7"); #ifdef USE_GTK3 gtk_widget_override_font (about_dialog->get_widget ("about_text_view"), monospace); #else gtk_widget_modify_font (about_dialog->get_widget ("about_text_view"), monospace); #endif pango_font_description_free (monospace); gtk_window_set_transient_for (about_dialog->get_window (), preferences->get_window ()); gtk_dialog_run (GTK_DIALOG (about_dialog->get_window ())); delete about_dialog; return; }
void empathy_new_individual_dialog_show_with_individual (GtkWindow *parent, FolksIndividual *individual) { GtkWidget *dialog; GtkWidget *button; EmpathyContact *contact = NULL; GtkWidget *contact_widget; g_return_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual)); if (new_individual_dialog) { gtk_window_present (GTK_WINDOW (new_individual_dialog)); return; } /* Create dialog */ dialog = gtk_dialog_new (); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_title (GTK_WINDOW (dialog), _("New Contact")); /* Cancel button */ button = gtk_button_new_with_label (GTK_STOCK_CANCEL); gtk_button_set_use_stock (GTK_BUTTON (button), TRUE); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_CANCEL); gtk_widget_show (button); /* Add button */ button = gtk_button_new_with_label (GTK_STOCK_ADD); gtk_button_set_use_stock (GTK_BUTTON (button), TRUE); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_OK); gtk_widget_show (button); /* Contact info widget */ if (individual != NULL) contact = empathy_contact_dup_from_folks_individual (individual); contact_widget = empathy_contact_widget_new (contact, EMPATHY_CONTACT_WIDGET_EDIT_ALIAS | EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT | EMPATHY_CONTACT_WIDGET_EDIT_ID | EMPATHY_CONTACT_WIDGET_EDIT_GROUPS); gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8); gtk_box_pack_start ( GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), contact_widget, TRUE, TRUE, 0); empathy_contact_widget_set_account_filter (contact_widget, can_add_contact_to_account, NULL); gtk_widget_show (contact_widget); new_individual_dialog = dialog; g_signal_connect (dialog, "response", G_CALLBACK (new_individual_response_cb), contact_widget); if (parent != NULL) gtk_window_set_transient_for (GTK_WINDOW (dialog), parent); gtk_widget_show (dialog); tp_clear_object (&contact); }
CustomerImportGui * gnc_plugin_customer_import_showGUI(GtkWindow *parent) { CustomerImportGui *gui; //gktbuilderXML *xml; GtkBuilder *builder; GList *glist; GtkCellRenderer *renderer; GtkTreeViewColumn *column; // if window exists already, activate it glist = gnc_find_gui_components ("dialog-customer-import-gui", NULL, NULL); if (glist) { // window found gui = g_list_nth_data (glist, 0); g_list_free (glist); gtk_window_present (GTK_WINDOW(gui->dialog)); return gui; } // create new window gui = g_new0 (CustomerImportGui, 1); builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "dialog-customer-import-gui.glade", "customer_import_dialog"); gui->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "customer_import_dialog")); gui->tree_view = GTK_WIDGET(gtk_builder_get_object (builder, "treeview1")); gui->entryFilename = GTK_WIDGET(gtk_builder_get_object (builder, "entryFilename")); gui->type = "CUSTOMER"; // Set a default type to import // Set the style context for this dialog so it can be easily manipulated with css gnc_widget_set_style_context (GTK_WIDGET(gui->dialog), "GncCustomerImportDialog"); gtk_window_set_transient_for (GTK_WINDOW (gui->dialog), parent); gui->regexp = g_string_new ( "^(?<id>[^;]+);(?<company>[^;]*);(?<name>[^;]+);(?<addr1>[^;]+);?(?<addr2>[^;]*);?(?<addr3>[^;]*);?(?<addr4>[^;]*);?(?<phone>[^;]*);?(?<fax>[^;]*);?(?<email>[^;]*);?(?<shipname>[^;]*);?(?<shipaddr1>[^;]*);?(?<shipaddr2>[^;]*);?(?<shipaddr3>[^;]*);?(?<shipaddr4>[^;]*);?(?<shipphone>[^;]*);?(?<shipfax>[^;]*);?(?<shipemail>[^;]*)"); gui->book = gnc_get_current_book(); // create model and bind to view gui->store = gtk_list_store_new (CI_N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model( GTK_TREE_VIEW(gui->tree_view), GTK_TREE_MODEL(gui->store) ); #define CREATE_COLUMN(description,column_id) \ renderer = gtk_cell_renderer_text_new (); \ column = gtk_tree_view_column_new_with_attributes (description, renderer, "text", column_id, NULL); \ gtk_tree_view_column_set_resizable (column, TRUE); \ gtk_tree_view_append_column (GTK_TREE_VIEW (gui->tree_view), column); CREATE_COLUMN ("id", CI_ID); CREATE_COLUMN ("company", CI_COMPANY); CREATE_COLUMN ("name", CI_NAME); CREATE_COLUMN ("addr1", CI_ADDR1); CREATE_COLUMN ("addr2", CI_ADDR2); CREATE_COLUMN ("addr3", CI_ADDR3); CREATE_COLUMN ("addr4", CI_ADDR4); CREATE_COLUMN ("phone", CI_PHONE); CREATE_COLUMN ("fax", CI_FAX); CREATE_COLUMN ("email", CI_EMAIL); CREATE_COLUMN ("notes", CI_NOTES); CREATE_COLUMN ("shipname", CI_SHIPNAME); CREATE_COLUMN ("shipaddr1", CI_SHIPADDR1); CREATE_COLUMN ("shipaddr2", CI_SHIPADDR2); CREATE_COLUMN ("shipaddr3", CI_SHIPADDR3); CREATE_COLUMN ("shipaddr4", CI_SHIPADDR4); CREATE_COLUMN ("shipphone", CI_SHIPPHONE); CREATE_COLUMN ("shipfax", CI_SHIPFAX); CREATE_COLUMN ("shipemail", CI_SHIPEMAIL); gui->component_id = gnc_register_gui_component ("dialog-customer-import-gui", NULL, gnc_customer_import_gui_close_handler, gui); /* Setup signals */ gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, gui); gtk_widget_show_all ( gui->dialog ); return gui; }
PpJobsDialog * pp_jobs_dialog_new (GtkWindow *parent, UserResponseCallback user_callback, gpointer user_data, gchar *printer_name) { GtkStyleContext *context; PpJobsDialog *dialog; GtkWidget *widget; GError *error = NULL; gchar *objects[] = { "jobs-dialog", NULL }; guint builder_result; gchar *title; dialog = g_new0 (PpJobsDialog, 1); dialog->builder = gtk_builder_new (); dialog->parent = GTK_WIDGET (parent); builder_result = gtk_builder_add_objects_from_resource (dialog->builder, "/org/gnome/control-center/printers/jobs-dialog.ui", objects, &error); if (builder_result == 0) { g_warning ("Could not load ui: %s", error->message); g_error_free (error); return NULL; } dialog->dialog = (GtkWidget *) gtk_builder_get_object (dialog->builder, "jobs-dialog"); dialog->user_callback = user_callback; dialog->user_data = user_data; dialog->printer_name = g_strdup (printer_name); dialog->current_job_id = -1; dialog->ref_count = 0; /* connect signals */ g_signal_connect (dialog->dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (dialog->dialog, "response", G_CALLBACK (jobs_dialog_response_cb), dialog); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "job-cancel-button"); g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "job-hold-button"); g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "job-release-button"); g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog); /* Set junctions */ widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "queue-scrolledwindow"); context = gtk_widget_get_style_context (widget); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "queue-toolbar"); context = gtk_widget_get_style_context (widget); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP); title = g_strdup_printf (_("%s Active Jobs"), printer_name); gtk_window_set_title (GTK_WINDOW (dialog->dialog), title); g_free (title); populate_jobs_list (dialog); gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog), GTK_WINDOW (parent)); gtk_window_present (GTK_WINDOW (dialog->dialog)); gtk_widget_show_all (GTK_WIDGET (dialog->dialog)); return dialog; }
int l_zargni(int metka_rr, //0-ввод и корек. 1-выбор iceb_u_str *kod,iceb_u_str *naim,GtkWidget *wpredok) { l_zargni_data data; char bros[512]; GdkColor color; data.poisk.clear_data(); data.metka_rr=metka_rr; data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); //gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1); //gdk_color_parse("black",&color); //gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color); sprintf(bros,"%s %s",name_system,gettext("Список городов налоговых инспекций")); gtk_window_set_title (GTK_WINDOW (data.window),bros); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_zargni_key_press),&data); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift); GtkWidget *hbox = gtk_hbox_new (FALSE, 1); gtk_container_add (GTK_CONTAINER (data.window), hbox); GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1); GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); gtk_widget_show(hbox); data.label_kolstr=gtk_label_new (gettext("Список городов налоговых инспекций")); //gdk_color_parse("green",&color); //gtk_widget_modify_fg(data.label_kolstr,GTK_STATE_NORMAL,&color); gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0); gtk_widget_show(vbox1); gtk_widget_show(vbox2); data.label_poisk=gtk_label_new (""); gdk_color_parse("red",&color); gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color); gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0); data.sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); //Кнопки GtkTooltips *tooltips[KOL_F_KL]; sprintf(bros,"F2 %s",gettext("Запись")); data.knopka[FK2]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_zargni_knopka),&data); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_widget_show(data.knopka[FK2]); sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать")); data.knopka[SFK2]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_zargni_knopka),&data); tooltips[SFK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2); gtk_widget_show(data.knopka[SFK2]); sprintf(bros,"F3 %s",gettext("Удалить")); data.knopka[FK3]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_zargni_knopka),&data); tooltips[FK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удаление выбранной записи"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3); gtk_widget_show(data.knopka[FK3]); sprintf(bros,"%sF3 %s",RFK,gettext("Удалить")); data.knopka[SFK3]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(l_zargni_knopka),&data); tooltips[SFK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Удалить неиспользуемые коды"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3); gtk_widget_show(data.knopka[SFK3]); sprintf(bros,"F4 %s",gettext("Поиск")); data.knopka[FK4]=gtk_button_new_with_label(bros); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(l_zargni_knopka),&data); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_widget_show(data.knopka[FK4]); sprintf(bros,"F5 %s",gettext("Печать")); data.knopka[FK5]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_zargni_knopka),&data); tooltips[FK5]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5); gtk_widget_show(data.knopka[FK5]); sprintf(bros,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_zargni_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_widget_show(data.knopka[FK10]); gtk_widget_realize(data.window); gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR)); gtk_widget_grab_focus(data.knopka[FK10]); l_zargni_create_list(&data); gtk_widget_show(data.window); if(metka_rr == 0) gtk_window_maximize(GTK_WINDOW(data.window)); //gtk_window_fullscreen(GTK_WINDOW(data.window)); gtk_main(); if(data.metka_voz == 0) { kod->new_plus(data.kodv.ravno()); naim->new_plus(data.naimv.ravno()); } if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.metka_voz); }