/**
* 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);
}
