src_ui_gui_psppiredir = $(pkgdatadir)
-- dist_src_ui_gui_psppire_DATA = \
-- $(top_srcdir)/src/ui/gui/data-editor.glade \
-- $(top_srcdir)/src/ui/gui/descriptives-dialog.glade \
-- $(top_srcdir)/src/ui/gui/examine.glade \
++ nodist_src_ui_gui_psppire_DATA = \
++ $(top_srcdir)/src/ui/gui/crosstabs.ui \
++ $(top_srcdir)/src/ui/gui/examine.ui \
++ $(top_srcdir)/src/ui/gui/frequencies.ui \
++ $(top_srcdir)/src/ui/gui/message-dialog.ui \
++ $(top_srcdir)/src/ui/gui/psppire.ui \
++ $(top_srcdir)/src/ui/gui/oneway.ui \
++ $(top_srcdir)/src/ui/gui/rank.ui \
++ $(top_srcdir)/src/ui/gui/recode.ui \
++ $(top_srcdir)/src/ui/gui/regression.ui \
++ $(top_srcdir)/src/ui/gui/t-test.ui
++
++ EXTRA_DIST += \
$(top_srcdir)/src/ui/gui/crosstabs.glade \
++ $(top_srcdir)/src/ui/gui/examine.glade \
$(top_srcdir)/src/ui/gui/frequencies.glade \
$(top_srcdir)/src/ui/gui/message-dialog.glade \
-- $(top_srcdir)/src/ui/gui/oneway.glade \
-- $(top_srcdir)/src/ui/gui/output-viewer.glade \
$(top_srcdir)/src/ui/gui/psppire.glade \
++ $(top_srcdir)/src/ui/gui/oneway.glade \
$(top_srcdir)/src/ui/gui/rank.glade \
$(top_srcdir)/src/ui/gui/recode.glade \
$(top_srcdir)/src/ui/gui/regression.glade \
++ $(top_srcdir)/src/ui/gui/t-test.glade
++
++ dist_src_ui_gui_psppire_DATA = \
++ $(top_srcdir)/src/ui/gui/data-editor.glade \
++ $(top_srcdir)/src/ui/gui/descriptives-dialog.glade \
++ $(top_srcdir)/src/ui/gui/output-viewer.glade \
$(top_srcdir)/src/ui/gui/syntax-editor.glade \
$(top_srcdir)/src/ui/gui/text-data-import.glade \
-- $(top_srcdir)/src/ui/gui/t-test.glade \
$(top_srcdir)/src/ui/gui/psppicon.png \
$(top_srcdir)/src/ui/gui/pspplogo.png \
$(top_srcdir)/src/ui/gui/icons/value-labels.png \
src/ui/gui/frequencies-dialog.h \
src/ui/gui/goto-case-dialog.c \
src/ui/gui/goto-case-dialog.h \
- src/ui/gui/data-editor.c \
- src/ui/gui/data-editor.h \
src/ui/gui/descriptives-dialog.c \
src/ui/gui/descriptives-dialog.h \
src/ui/gui/examine-dialog.c \
src/ui/gui/missing-val-dialog.h \
src/ui/gui/oneway-anova-dialog.c \
src/ui/gui/oneway-anova-dialog.h \
- src/ui/gui/output-viewer.c \
- src/ui/gui/output-viewer.h \
src/ui/gui/psppire-acr.h \
src/ui/gui/psppire-buttonbox.h \
src/ui/gui/psppire-hbuttonbox.h \
src/ui/gui/sort-cases-dialog.h \
src/ui/gui/split-file-dialog.c \
src/ui/gui/split-file-dialog.h \
- src/ui/gui/syntax-editor.c \
- src/ui/gui/syntax-editor.h \
src/ui/gui/syntax-editor-source.c \
src/ui/gui/syntax-editor-source.h \
src/ui/gui/text-data-import-dialog.c \
src/ui/gui/weight-cases-dialog.h \
src/ui/gui/widget-io.c \
src/ui/gui/widget-io.h \
- src/ui/gui/window-manager.c \
- src/ui/gui/window-manager.h
+ src/ui/gui/psppire-data-window.c \
+ src/ui/gui/psppire-data-window.h \
+ src/ui/gui/psppire-output-window.c \
+ src/ui/gui/psppire-output-window.h \
+ src/ui/gui/psppire-window.c \
+ src/ui/gui/psppire-window.h \
+ src/ui/gui/psppire-window-register.c \
+ src/ui/gui/psppire-window-register.h \
+ src/ui/gui/psppire-syntax-window.c \
+ src/ui/gui/psppire-syntax-window.h
nodist_src_ui_gui_psppire_SOURCES = \
src/ui/gui/psppire-marshal.c \
src/ui/gui/psppire-marshal.h
--
--
yelp-check:
@if ! yelp --version > /dev/null 2>&1 ; then \
echo ; \
src/ui/gui/psppire-marshal.h: src/ui/gui/marshaller-list
glib-genmarshal --header --prefix=psppire_marshal $< > $@
++ .glade.ui:
++ gtk-builder-convert $< $@
++
EXTRA_DIST += src/ui/gui/OChangeLog\
src/ui/gui/marshaller-list
#include "psppire-dialog.h"
#include "helper.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
+#include "psppire-data-editor.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
#include "psppire-var-store.h"
#include <ui/syntax-gen.h>
#include "dialog-common.h"
#include <gtk/gtk.h>
-- #include <glade/glade.h>
#include <gettext.h>
struct comment_dialog
{
-- GladeXML *xml;
++ GtkBuilder *xml;
PsppireDict *dict;
};
{
GtkTextIter iter;
gint response ;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
struct comment_dialog cd;
-- GladeXML *xml = XML_NEW ("psppire.glade");
++ GtkBuilder *xml = builder_new ("psppire.ui");
GtkWidget *dialog = get_widget_assert (xml, "comments-dialog");
GtkWidget *textview = get_widget_assert (xml, "comments-textview1");
g_object_get (de->data_editor, "var-store", &vs, NULL);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
{
PangoContext * context ;
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&cd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
{
gchar *syntax = generate_syntax (&cd);
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include "helper.h"
#include "psppire-dialog.h"
#include "psppire-keypad.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "psppire-var-store.h"
#include "dialog-common.h"
#include "dict-display.h"
#include <language/expressions/public.h>
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
static void function_list_populate (GtkTreeView *tv);
struct compute_dialog
{
-- GladeXML *xml; /* The xml that generated the widgets */
++ GtkBuilder *xml; /* The xml that generated the widgets */
PsppireDict *dict;
gboolean use_type;
};
static void
on_keypad_button (PsppireKeypad *kp, const gchar *syntax, gpointer data)
{
-- GladeXML *xml = data;
++ GtkBuilder *xml = data;
GtkWidget *rhs = get_widget_assert (xml, "compute-textview1");
static void
erase (PsppireKeypad *kp, gpointer data)
{
-- GladeXML *xml = data;
++ GtkBuilder *xml = data;
GtkWidget *rhs = get_widget_assert (xml, "compute-textview1");
compute_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = data;
PsppireVarStore *vs = NULL;
struct compute_dialog scd;
-- GladeXML *xml = XML_NEW ("psppire.glade");
++ GtkBuilder *xml = builder_new ("psppire.ui");
GtkWidget *dialog = get_widget_assert (xml, "compute-variable-dialog");
g_signal_connect (expression, "toggled",
G_CALLBACK(on_expression_toggle), &scd);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (dict_view),
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&scd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
{
gchar *syntax = generate_syntax (&scd);
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include <stdlib.h>
#include <language/syntax-string-source.h>
-#include <ui/gui/data-editor.h>
+#include <ui/gui/psppire-data-window.h>
#include <ui/gui/dialog-common.h>
#include <ui/gui/dict-display.h>
-- #include <ui/gui/helper.h>
++ #include "helper.h"
#include <ui/gui/psppire-dialog.h>
#include <ui/gui/psppire-var-store.h>
-#include <ui/gui/syntax-editor.h>
+#include <ui/gui/helper.h>
#include "gettext.h"
#define _(msgid) gettext (msgid)
crosstabs_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
-
struct crosstabs_dialog cd;
-- GladeXML *xml = XML_NEW ("crosstabs.glade");
--
++ GtkBuilder *xml = builder_new ("crosstabs.ui");
PsppireVarStore *vs = NULL;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
+
+
GtkWidget *dialog = get_widget_assert (xml, "crosstabs-dialog");
GtkWidget *source = get_widget_assert (xml, "dict-treeview");
GtkWidget *dest_rows = get_widget_assert (xml, "rows");
cells
);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (source),
vs->dict,
cd.current_opts.table = TRUE;
cd.current_opts.pivot = TRUE;
- gtk_window_set_transient_for (GTK_WINDOW (cd.format_dialog), de->parent.window);
- gtk_window_set_transient_for (GTK_WINDOW (cd.cell_dialog), de->parent.window);
- gtk_window_set_transient_for (GTK_WINDOW (cd.stat_dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (cd.format_dialog), GTK_WINDOW (de));
+ gtk_window_set_transient_for (GTK_WINDOW (cd.cell_dialog), GTK_WINDOW (de));
+ gtk_window_set_transient_for (GTK_WINDOW (cd.stat_dialog), GTK_WINDOW (de));
g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), &cd);
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&cd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
{
gchar *syntax = generate_syntax (&cd);
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include <stdlib.h>
#include <language/syntax-string-source.h>
-#include <ui/gui/data-editor.h>
+#include <ui/gui/psppire-data-window.h>
#include <ui/gui/dialog-common.h>
#include <ui/gui/dict-display.h>
#include <ui/gui/helper.h>
#include <ui/gui/psppire-dialog.h>
#include <ui/gui/psppire-var-store.h>
-#include <ui/gui/syntax-editor.h>
+#include <ui/gui/helper.h>
#include "gettext.h"
#define _(msgid) gettext (msgid)
examine_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
struct examine_dialog ex_d;
--
-- GladeXML *xml = XML_NEW ("examine.glade");
--
++ GtkBuilder *xml = builder_new ("examine.ui");
GtkWidget *dialog = get_widget_assert (xml, "examine-dialog");
GtkWidget *source = get_widget_assert (xml, "treeview1");
ex_d.percentiles_button = GTK_TOGGLE_BUTTON
(get_widget_assert (xml, "percentiles-button"));
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
- gtk_window_set_transient_for (GTK_WINDOW (ex_d.stats_dialog), de->parent.window);
- gtk_window_set_transient_for (GTK_WINDOW (ex_d.opts_dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
+ gtk_window_set_transient_for (GTK_WINDOW (ex_d.stats_dialog), GTK_WINDOW (de));
+ gtk_window_set_transient_for (GTK_WINDOW (ex_d.opts_dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (source),
vs->dict,
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&ex_d);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
-
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
break;
#include "psppire-selector.h"
#include "psppire-dialog.h"
#include "helper.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "dict-display.h"
#include <data/value.h>
#include <data/format.h>
#include <libpspp/message.h>
#include <gtk/gtk.h>
-- #include <glade/glade.h>
#include <stdlib.h>
#include "xalloc.h"
struct find_dialog
{
-- GladeXML *xml;
++ GtkBuilder *xml;
PsppireDict *dict;
struct datasheet *data;
- struct data_editor *de;
+ PsppireDataWindow *de;
GtkWidget *variable_entry;
GtkWidget *value_entry;
GtkWidget *value_labels_checkbox;
void
find_dialog (GObject *o, gpointer data)
{
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
struct find_dialog fd;
PsppireVarStore *vs ;
PsppireDataStore *ds ;
-- fd.xml = XML_NEW ("psppire.glade");
++ fd.xml = builder_new ("psppire.ui");
fd.de = de;
find_button = gtk_button_new_from_stock (GTK_STOCK_FIND);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (source),
#include <stdlib.h>
#include <language/syntax-string-source.h>
-#include <ui/gui/data-editor.h>
+#include <ui/gui/psppire-data-window.h>
#include <ui/gui/dialog-common.h>
#include <ui/gui/dict-display.h>
#include <ui/gui/helper.h>
#include <ui/gui/psppire-dialog.h>
#include <ui/gui/psppire-var-store.h>
-#include <ui/gui/syntax-editor.h>
+#include <ui/gui/helper.h>
#include "gettext.h"
#define _(msgid) gettext (msgid)
frequencies_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
struct frequencies_dialog fd;
-- GladeXML *xml = XML_NEW ("frequencies.glade");
++ GtkBuilder *xml = builder_new ("frequencies.ui");
GtkWidget *dialog = get_widget_assert (xml, "frequencies-dialog");
GtkWidget *source = get_widget_assert (xml, "dict-treeview");
);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (source),
vs->dict,
fd.current_opts.limit = 50;
- gtk_window_set_transient_for (GTK_WINDOW (fd.format_dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (fd.format_dialog), GTK_WINDOW (de));
g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), &fd);
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&fd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&fd);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
-
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
break;
#include "goto-case-dialog.h"
#include "helper.h"
#include "psppire-dialog.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "psppire-data-store.h"
static void
-- refresh (const PsppireDataWindow *de, GladeXML *xml)
-refresh (const struct data_editor *de, GtkBuilder *xml)
+++refresh (const PsppireDataWindow *de, GtkBuilder *xml)
{
PsppireDataStore *ds = NULL;
casenumber case_count ;
goto_case_dialog (GObject *o, gpointer data)
{
gint response;
-- GladeXML *xml = XML_NEW ("psppire.glade");
++ GtkBuilder *xml = builder_new ("psppire.ui");
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
GtkWidget *dialog = get_widget_assert (xml, "goto-case-dialog");
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
refresh (de, xml);
*/
#include <config.h>
+#include "psppire-syntax-window.h"
+
#include <glib-object.h>
#include <glib.h>
#include <data/casereader-provider.h>
#include <libpspp/message.h>
++ #include <gtk/gtkbuilder.h>
#include <libpspp/i18n.h>
#include <ctype.h>
#include <language/lexer/lexer.h>
#include "psppire-data-store.h"
#include <output/manager.h>
-#include "output-viewer.h"
+#include "psppire-output-window.h"
#include "xalloc.h"
}
++ GtkBuilder *
++ builder_new_real (const gchar *name)
++ {
++ GtkBuilder *builder = gtk_builder_new ();
++
++ GError *err = NULL;
++ if ( ! gtk_builder_add_from_file (builder, name, &err))
++ {
++ g_critical ("Couldnt open user interface file %s: %s", name, err->message);
++ g_clear_error (&err);
++ }
++
++ return builder;
++ }
++
++
++
GtkWidget *
-- get_widget_assert (GladeXML *xml, const gchar *name)
++ get_widget_assert (gpointer x, const gchar *name)
{
-- GtkWidget *w;
-- g_assert (xml);
++ GObject *obj = G_OBJECT (x);
++ GtkWidget *w = NULL;
g_assert (name);
-- w = glade_xml_get_widget (xml, name);
++ if (GTK_IS_BUILDER (obj))
++ w = GTK_WIDGET (gtk_builder_get_object (GTK_BUILDER (obj), name));
++
++ if (GLADE_IS_XML (obj))
++ w = glade_xml_get_widget (GLADE_XML (obj), name);
if ( !w )
g_critical ("Widget \"%s\" could not be found\n", name);
som_flush ();
- reload_the_viewer ();
+ psppire_output_window_reload ();
return retval;
}
}
--
--
+void
+paste_syntax_in_new_window (const gchar *syntax)
+{
+ GtkWidget *se = psppire_syntax_window_new ();
+ gtk_text_buffer_insert_at_cursor (PSPPIRE_SYNTAX_WINDOW (se)->buffer, syntax, -1);
+
+ gtk_widget_show (se);
+}
#include <gtk/gtk.h>
#include <glade/glade.h>
+
+
+void paste_syntax_in_new_window (const gchar *syntax);
+
/*
GtkRecentChooserMenu was added in 2.10.0
but it didn't support GtkRecentFilters until
gboolean text_to_value (const gchar *text, union value *v,
struct fmt_spec format);
-- GtkWidget * get_widget_assert (GladeXML *xml, const gchar *name);
++ GtkWidget * get_widget_assert (gpointer x, const gchar *name);
/* Converts a string in the pspp locale to utf-8 */
char * pspp_locale_to_utf8 (const gchar *text, gssize len, GError **err);
glade_xml_new (relocate(PKGDATADIR "/" FILE), NULL, NULL)
-- void marshaller_VOID__INT_INT_INT (GClosure *closure,
-- GValue *return_value,
-- guint n_param_values,
-- const GValue *param_values,
-- gpointer invocation_hint,
-- gpointer marshal_data);
++ #define builder_new(NAME) builder_new_real (relocate (PKGDATADIR "/" NAME))
++
++ GtkBuilder *builder_new_real (const gchar *name);
/* Create a deep copy of SRC */
#include <config.h>
-- #include <glade/glade.h>
#include <gtk/gtk.h>
#include "oneway-anova-dialog.h"
#include "psppire-dict.h"
#include "psppire-var-store.h"
#include "helper.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "psppire-dialog.h"
#include "dialog-common.h"
#include "dict-display.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
#include "gettext.h"
}
++
/* Pops up the dialog box */
void
oneway_anova_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
PsppireVarStore *vs = NULL;
-- GladeXML *xml = XML_NEW ("oneway.glade");
--
struct oneway_anova_dialog ow;
++ GtkBuilder *builder = builder_new ("oneway.ui");
++
GtkWidget *dict_view =
-- get_widget_assert (xml, "oneway-anova-treeview1");
++ get_widget_assert (builder, "oneway-anova-treeview1");
GtkWidget *selector2 =
-- get_widget_assert (xml, "oneway-anova-selector2");
++ get_widget_assert (builder, "oneway-anova-selector2");
GtkWidget *selector1 =
-- get_widget_assert (xml, "oneway-anova-selector1");
++ get_widget_assert (builder, "oneway-anova-selector1");
GtkWidget *contrasts_button =
-- get_widget_assert (xml, "contrasts-button");
++ get_widget_assert (builder, "contrasts-button");
g_signal_connect_swapped (contrasts_button, "clicked",
G_CALLBACK (run_contrasts_dialog), &ow);
-- ow.factor_entry = get_widget_assert (xml, "oneway-anova-entry");
++ ow.factor_entry = get_widget_assert (builder, "oneway-anova-entry");
ow.vars_treeview =
-- get_widget_assert (xml, "oneway-anova-treeview2");
++ get_widget_assert (builder, "oneway-anova-treeview2");
ow.descriptives =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "checkbutton1"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "checkbutton1"));
ow.homogeneity =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "checkbutton2"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "checkbutton2"));
g_object_get (de->data_editor, "var-store", &vs, NULL);
ow.dict = vs->dict;
ow.dialog =
-- GTK_WINDOW (get_widget_assert (xml, "oneway-anova-dialog"));
++ GTK_WINDOW (get_widget_assert (builder, "oneway-anova-dialog"));
- gtk_window_set_transient_for (ow.dialog, de->parent.window);
+ gtk_window_set_transient_for (ow.dialog, GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (dict_view),
vs->dict,
{
struct contrasts_subdialog *cd = &ow.contrasts;
-- GtkEntry *entry = GTK_ENTRY (get_widget_assert (xml, "entry1"));
++ GtkEntry *entry = GTK_ENTRY (get_widget_assert (builder, "entry1"));
-- cd->acr = PSPPIRE_ACR (get_widget_assert (xml, "psppire-acr1"));
-- cd->contrasts_dialog = get_widget_assert (xml, "contrasts-dialog");
++ cd->acr = PSPPIRE_ACR (get_widget_assert (builder, "psppire-acr1"));
++ cd->contrasts_dialog = get_widget_assert (builder, "contrasts-dialog");
-- cd->next = get_widget_assert (xml, "next-button");
-- cd->prev = get_widget_assert (xml, "prev-button");
-- cd->ctotal = get_widget_assert (xml, "entry2");
++ cd->next = get_widget_assert (builder, "next-button");
++ cd->prev = get_widget_assert (builder, "prev-button");
++ cd->ctotal = get_widget_assert (builder, "entry2");
-- cd->stack_label = get_widget_assert (xml, "contrast-stack-label");
++ cd->stack_label = get_widget_assert (builder, "contrast-stack-label");
/* Contrasts */
ow.contrasts_array = g_array_new (FALSE, FALSE, sizeof (GtkListStore *));
psppire_acr_set_entry (cd->acr, entry);
gtk_window_set_transient_for (GTK_WINDOW (cd->contrasts_dialog),
- de->parent.window);
+ GTK_WINDOW (de));
}
response = psppire_dialog_run (PSPPIRE_DIALOG (ow.dialog));
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&ow);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&ow);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
g_array_free (ow.contrasts_array, FALSE);
-- g_object_unref (xml);
++ g_object_unref (builder);
}
--- /dev/null
-- gtk_widget_unparent (menubar);
+/* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2008 Free Software Foundation
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+
+#include <gtk/gtksignal.h>
+#include <gtk/gtkbox.h>
+#include <glade/glade.h>
+#include "helper.h"
+
+#include <libpspp/message.h>
+#include <stdlib.h>
+
+#include "psppire-syntax-window.h"
+
+#include "psppire-data-window.h"
+#include "psppire-window-register.h"
+#include "about.h"
+#include "psppire-syntax-window.h"
+#include "syntax-editor-source.h"
+#include <language/lexer/lexer.h>
+
+#include <gettext.h>
+#define _(msgid) gettext (msgid)
+#define N_(msgid) msgid
+
+static void psppire_syntax_window_base_finalize (PsppireSyntaxWindowClass *, gpointer);
+static void psppire_syntax_window_base_init (PsppireSyntaxWindowClass *class);
+static void psppire_syntax_window_class_init (PsppireSyntaxWindowClass *class);
+static void psppire_syntax_window_init (PsppireSyntaxWindow *syntax_editor);
+
+GType
+psppire_syntax_window_get_type (void)
+{
+ static GType psppire_syntax_window_type = 0;
+
+ if (!psppire_syntax_window_type)
+ {
+ static const GTypeInfo psppire_syntax_window_info =
+ {
+ sizeof (PsppireSyntaxWindowClass),
+ (GBaseInitFunc) psppire_syntax_window_base_init,
+ (GBaseFinalizeFunc) psppire_syntax_window_base_finalize,
+ (GClassInitFunc)psppire_syntax_window_class_init,
+ (GClassFinalizeFunc) NULL,
+ NULL,
+ sizeof (PsppireSyntaxWindow),
+ 0,
+ (GInstanceInitFunc) psppire_syntax_window_init,
+ };
+
+ psppire_syntax_window_type =
+ g_type_register_static (PSPPIRE_WINDOW_TYPE, "PsppireSyntaxWindow",
+ &psppire_syntax_window_info, 0);
+ }
+
+ return psppire_syntax_window_type;
+}
+
+static GObjectClass *parent_class ;
+
+static void
+psppire_syntax_window_finalize (GObject *object)
+{
+ if (G_OBJECT_CLASS (parent_class)->finalize)
+ (*G_OBJECT_CLASS (parent_class)->finalize) (object);
+}
+
+
+static void
+psppire_syntax_window_class_init (PsppireSyntaxWindowClass *class)
+{
+ parent_class = g_type_class_peek_parent (class);
+}
+
+
+static void
+psppire_syntax_window_base_init (PsppireSyntaxWindowClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+ object_class->finalize = psppire_syntax_window_finalize;
+}
+
+
+
+static void
+psppire_syntax_window_base_finalize (PsppireSyntaxWindowClass *class,
+ gpointer class_data)
+{
+}
+
+
+static void
+editor_execute_syntax (const PsppireSyntaxWindow *sw, GtkTextIter start,
+ GtkTextIter stop)
+{
+ PsppireWindow *win = PSPPIRE_WINDOW (sw);
+ const gchar *name = psppire_window_get_filename (win);
+ execute_syntax (create_syntax_editor_source (sw->buffer, start, stop, name));
+}
+
+
+/* Parse and execute all the text in the buffer */
+static void
+on_run_all (GtkMenuItem *menuitem, gpointer user_data)
+{
+ GtkTextIter begin, end;
+ PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (user_data);
+
+ gtk_text_buffer_get_iter_at_offset (se->buffer, &begin, 0);
+ gtk_text_buffer_get_iter_at_offset (se->buffer, &end, -1);
+
+ editor_execute_syntax (se, begin, end);
+}
+
+/* Parse and execute the currently selected text */
+static void
+on_run_selection (GtkMenuItem *menuitem, gpointer user_data)
+{
+ GtkTextIter begin, end;
+ PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (user_data);
+
+ if ( gtk_text_buffer_get_selection_bounds (se->buffer, &begin, &end) )
+ editor_execute_syntax (se, begin, end);
+}
+
+
+/* Parse and execute the from the current line, to the end of the
+ buffer */
+static void
+on_run_to_end (GtkMenuItem *menuitem, gpointer user_data)
+{
+ GtkTextIter begin, end;
+ GtkTextIter here;
+ gint line;
+
+ PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (user_data);
+
+ /* Get the current line */
+ gtk_text_buffer_get_iter_at_mark (se->buffer,
+ &here,
+ gtk_text_buffer_get_insert (se->buffer)
+ );
+
+ line = gtk_text_iter_get_line (&here) ;
+
+ /* Now set begin and end to the start of this line, and end of buffer
+ respectively */
+ gtk_text_buffer_get_iter_at_line (se->buffer, &begin, line);
+ gtk_text_buffer_get_iter_at_line (se->buffer, &end, -1);
+
+ editor_execute_syntax (se, begin, end);
+}
+
+
+
+/* Parse and execute the current line */
+static void
+on_run_current_line (GtkMenuItem *menuitem, gpointer user_data)
+{
+ GtkTextIter begin, end;
+ GtkTextIter here;
+ gint line;
+
+ PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (user_data);
+
+ /* Get the current line */
+ gtk_text_buffer_get_iter_at_mark (se->buffer,
+ &here,
+ gtk_text_buffer_get_insert (se->buffer)
+ );
+
+ line = gtk_text_iter_get_line (&here) ;
+
+ /* Now set begin and end to the start of this line, and start of
+ following line respectively */
+ gtk_text_buffer_get_iter_at_line (se->buffer, &begin, line);
+ gtk_text_buffer_get_iter_at_line (se->buffer, &end, line + 1);
+
+ editor_execute_syntax (se, begin, end);
+}
+
+
+
+/* Append ".sps" to FILENAME if necessary.
+ The returned result must be freed when no longer required.
+ */
+static gchar *
+append_suffix (const gchar *filename)
+{
+ if ( ! g_str_has_suffix (filename, ".sps" ) &&
+ ! g_str_has_suffix (filename, ".SPS" ) )
+ {
+ return g_strdup_printf ("%s.sps", filename);
+ }
+
+ return strdup (filename);
+}
+
+/*
+ Save BUFFER to the file called FILENAME.
+ If successful, clears the buffer's modified flag
+*/
+static gboolean
+save_editor_to_file (PsppireSyntaxWindow *se,
+ const gchar *filename,
+ GError **err)
+{
+ GtkTextBuffer *buffer = se->buffer;
+ gboolean result ;
+ GtkTextIter start, stop;
+ gchar *text;
+
+ gchar *suffixedname;
+ gchar *glibfilename;
+ g_assert (filename);
+
+ suffixedname = append_suffix (filename);
+
+ glibfilename = g_filename_from_utf8 (suffixedname, -1, 0, 0, err);
+
+ g_free ( suffixedname);
+
+ if ( ! glibfilename )
+ return FALSE;
+
+ gtk_text_buffer_get_iter_at_line (buffer, &start, 0);
+ gtk_text_buffer_get_iter_at_offset (buffer, &stop, -1);
+
+ text = gtk_text_buffer_get_text (buffer, &start, &stop, FALSE);
+
+ result = g_file_set_contents (glibfilename, text, -1, err);
+
+ if ( result )
+ {
+ psppire_window_set_filename (PSPPIRE_WINDOW (se), filename);
+ gtk_text_buffer_set_modified (buffer, FALSE);
+ }
+
+ return result;
+}
+
+/* If the buffer's modified flag is set, then save it, and close the window.
+ Otherwise just close the window.
+*/
+static void
+save_if_modified (PsppireSyntaxWindow *se)
+{
+
+ if ( TRUE == gtk_text_buffer_get_modified (se->buffer))
+ {
+ gint response;
+ GtkWidget *dialog;
+
+ const gchar *filename = psppire_window_get_filename (PSPPIRE_WINDOW (se));
+
+ g_return_if_fail (filename != NULL);
+
+ dialog =
+ gtk_message_dialog_new (GTK_WINDOW (se),
+ GTK_DIALOG_MODAL,
+ GTK_MESSAGE_QUESTION,
+ GTK_BUTTONS_NONE,
+ _("Save contents of syntax editor to %s?"),
+ filename);
+
+ gtk_dialog_add_button (GTK_DIALOG (dialog),
+ GTK_STOCK_YES,
+ GTK_RESPONSE_ACCEPT);
+ gtk_dialog_add_button (GTK_DIALOG (dialog),
+ GTK_STOCK_NO,
+ GTK_RESPONSE_REJECT);
+ gtk_dialog_add_button (GTK_DIALOG (dialog),
+ GTK_STOCK_CANCEL,
+ GTK_RESPONSE_CANCEL);
+
+
+ response = gtk_dialog_run (GTK_DIALOG (dialog));
+
+ gtk_widget_destroy (dialog);
+
+ if ( response == GTK_RESPONSE_ACCEPT )
+ {
+ GError *err = NULL;
+
+ if ( ! save_editor_to_file (se, filename, &err) )
+ {
+ msg (ME, err->message);
+ g_error_free (err);
+ }
+ }
+
+ if ( response == GTK_RESPONSE_CANCEL )
+ return ;
+ }
+
+ gtk_widget_destroy (GTK_WIDGET (se));
+}
+
+/* Callback for the File->SaveAs menuitem */
+static void
+on_syntax_save_as (GtkMenuItem *menuitem, gpointer user_data)
+{
+ GtkFileFilter *filter;
+ gint response;
+
+ PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (user_data);
+
+ GtkWidget *dialog =
+ gtk_file_chooser_dialog_new (_("Save Syntax"),
+ GTK_WINDOW (se),
+ GTK_FILE_CHOOSER_ACTION_SAVE,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+ NULL);
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name (filter, _("Syntax Files (*.sps) "));
+ gtk_file_filter_add_pattern (filter, "*.sps");
+ gtk_file_filter_add_pattern (filter, "*.SPS");
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name (filter, _("All Files"));
+ gtk_file_filter_add_pattern (filter, "*");
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
+
+ gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
+ TRUE);
+ response = gtk_dialog_run (GTK_DIALOG (dialog));
+
+ if ( response == GTK_RESPONSE_ACCEPT )
+ {
+ GError *err = NULL;
+ char *filename =
+ gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog) );
+
+ if ( ! save_editor_to_file (se, filename, &err) )
+ {
+ msg ( ME, err->message );
+ g_error_free (err);
+ }
+
+ free (filename);
+ }
+
+ gtk_widget_destroy (dialog);
+}
+
+
+/* Callback for the File->Save menuitem */
+static void
+on_syntax_save (GtkMenuItem *menuitem, gpointer user_data)
+{
+ PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (user_data);
+ const gchar *filename = psppire_window_get_filename (PSPPIRE_WINDOW (se));
+
+
+ if ( filename == NULL )
+ on_syntax_save_as (menuitem, se);
+ else
+ {
+ GError *err = NULL;
+ save_editor_to_file (se, filename, &err);
+ if ( err )
+ {
+ msg (ME, err->message);
+ g_error_free (err);
+ }
+ }
+}
+
+
+/* Callback for the File->Quit menuitem */
+static gboolean
+on_quit (GtkMenuItem *menuitem, gpointer user_data)
+{
+ PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (user_data);
+ save_if_modified (se);
+ return FALSE;
+}
+
+
+/* Callback for the "delete" action (clicking the x on the top right
+ hand corner of the window) */
+static gboolean
+on_delete (GtkWidget *w, GdkEvent *event, gpointer user_data)
+{
+ PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (user_data);
+
+ save_if_modified (se);
+ return TRUE;
+}
+
+
+void
+create_syntax_window (void)
+{
+ GtkWidget *w = psppire_syntax_window_new ();
+ gtk_widget_show (w);
+}
+
+/* Callback for the File->Open->Syntax menuitem */
+void
+open_syntax_window (GtkMenuItem *menuitem, gpointer parent)
+{
+ GtkFileFilter *filter;
+ gint response;
+
+ GtkWidget *dialog =
+ gtk_file_chooser_dialog_new (_("Open Syntax"),
+ GTK_WINDOW (parent),
+ GTK_FILE_CHOOSER_ACTION_OPEN,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+ NULL);
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name (filter, _("Syntax Files (*.sps) "));
+ gtk_file_filter_add_pattern (filter, "*.sps");
+ gtk_file_filter_add_pattern (filter, "*.SPS");
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name (filter, _("All Files"));
+ gtk_file_filter_add_pattern (filter, "*");
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
+
+ response = gtk_dialog_run (GTK_DIALOG (dialog));
+
+ if (response == GTK_RESPONSE_ACCEPT)
+ {
+ const char *file_name = gtk_file_chooser_get_filename
+ (GTK_FILE_CHOOSER (dialog));
+
+ GtkWidget *se = psppire_syntax_window_new ();
+
+ if ( psppire_syntax_window_load_from_file (PSPPIRE_SYNTAX_WINDOW (se), file_name, NULL) )
+#if RECENT_LISTS_AVAILABLE
+ {
+ GtkRecentManager *manager = gtk_recent_manager_get_default();
+ gchar *uri = g_filename_to_uri (file_name, NULL, NULL);
+
+ gtk_recent_manager_remove_item (manager, uri, NULL);
+ if ( ! gtk_recent_manager_add_item (manager, uri))
+ g_warning ("Could not add item %s to recent list\n",uri);
+
+ g_free (uri);
+ }
+#else
+ ;
+#endif
+ gtk_widget_show (se);
+ }
+
+ gtk_widget_destroy (dialog);
+}
+
+
+
+extern struct source_stream *the_source_stream ;
+
+static void
+psppire_syntax_window_init (PsppireSyntaxWindow *window)
+{
+ GladeXML *xml = XML_NEW ("syntax-editor.glade");
+ GtkWidget *box = gtk_vbox_new (FALSE, 0);
+
+ GtkWidget *menubar = get_widget_assert (xml, "menubar2");
+ GtkWidget *sw = get_widget_assert (xml, "scrolledwindow8");
+ GtkWidget *sb = get_widget_assert (xml, "statusbar2");
+
+ GtkWidget *text_view = get_widget_assert (xml, "syntax_text_view");
+ window->buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
+ window->lexer = lex_create (the_source_stream);
+
+ connect_help (xml);
+
+ gtk_container_add (GTK_CONTAINER (window), box);
+
+ g_object_ref (menubar);
-- gtk_widget_unparent (sw);
+
+ g_object_ref (sw);
-- gtk_widget_unparent (sb);
+
+ g_object_ref (sb);
+
+
+ gtk_box_pack_start (GTK_BOX (box), menubar, FALSE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (box), sb, FALSE, TRUE, 0);
+
+ gtk_widget_show_all (box);
+
+ g_signal_connect (get_widget_assert (xml,"file_new_syntax"),
+ "activate",
+ G_CALLBACK (create_syntax_window),
+ NULL);
+
+ g_signal_connect (get_widget_assert (xml,"file_open_syntax"),
+ "activate",
+ G_CALLBACK (open_syntax_window),
+ window);
+
+#if 0
+ g_signal_connect (get_widget_assert (xml,"file_new_data"),
+ "activate",
+ G_CALLBACK (create_data_window),
+ window);
+#endif
+
+ g_signal_connect (get_widget_assert (xml,"help_about"),
+ "activate",
+ G_CALLBACK (about_new),
+ window);
+
+ g_signal_connect (get_widget_assert (xml,"help_reference"),
+ "activate",
+ G_CALLBACK (reference_manual),
+ NULL);
+
+ g_signal_connect (get_widget_assert (xml, "file_save"),
+ "activate",
+ G_CALLBACK (on_syntax_save),
+ window);
+
+ g_signal_connect (get_widget_assert (xml, "file_save_as"),
+ "activate",
+ G_CALLBACK (on_syntax_save_as),
+ window);
+
+ g_signal_connect (get_widget_assert (xml,"file_quit"),
+ "activate",
+ G_CALLBACK (on_quit),
+ window);
+
+ g_signal_connect (get_widget_assert (xml,"run_all"),
+ "activate",
+ G_CALLBACK (on_run_all),
+ window);
+
+
+ g_signal_connect (get_widget_assert (xml,"run_selection"),
+ "activate",
+ G_CALLBACK (on_run_selection),
+ window);
+
+ g_signal_connect (get_widget_assert (xml,"run_current_line"),
+ "activate",
+ G_CALLBACK (on_run_current_line),
+ window);
+
+ g_signal_connect (get_widget_assert (xml,"run_to_end"),
+ "activate",
+ G_CALLBACK (on_run_to_end),
+ window);
+
+ g_signal_connect (get_widget_assert (xml,"windows_minimise_all"),
+ "activate",
+ G_CALLBACK (psppire_window_minimise_all), NULL);
+
+ PSPPIRE_WINDOW (window)->menu = GTK_MENU_SHELL (get_widget_assert (xml,"windows_menu"));
+
+ g_object_unref (xml);
+
+ g_signal_connect (window, "delete-event",
+ G_CALLBACK (on_delete), window);
+}
+
+
+GtkWidget*
+psppire_syntax_window_new (void)
+{
+ return GTK_WIDGET (g_object_new (psppire_syntax_window_get_type (),
+ "usage", PSPPIRE_WINDOW_USAGE_SYNTAX,
+ NULL));
+}
+
+
+/*
+ Loads the buffer from the file called FILENAME
+*/
+gboolean
+psppire_syntax_window_load_from_file (PsppireSyntaxWindow *se,
+ const gchar *filename,
+ GError **err)
+{
+ gchar *text;
+ GtkTextIter iter;
+
+ gchar *glibfilename = g_filename_from_utf8 (filename, -1, 0, 0, err);
+
+ if ( ! glibfilename )
+ return FALSE;
+
+ /* FIXME: What if it's a very big file ? */
+ if ( ! g_file_get_contents (glibfilename, &text, NULL, err) )
+ {
+ g_free (glibfilename);
+ return FALSE;
+ }
+ g_free (glibfilename);
+
+ gtk_text_buffer_get_iter_at_line (se->buffer, &iter, 0);
+
+ gtk_text_buffer_insert (se->buffer, &iter, text, -1);
+
+ psppire_window_set_filename (PSPPIRE_WINDOW (se), filename);
+
+ gtk_text_buffer_set_modified (se->buffer, FALSE);
+
+ return TRUE;
+}
+
#include <stdlib.h>
#include <language/syntax-string-source.h>
-#include <ui/gui/data-editor.h>
+#include <ui/gui/psppire-data-window.h>
#include <ui/gui/dialog-common.h>
#include <ui/gui/dict-display.h>
#include <ui/gui/helper.h>
#include <ui/gui/psppire-dialog.h>
#include <ui/gui/psppire-var-store.h>
-#include <ui/gui/syntax-editor.h>
+#include <ui/gui/helper.h>
#include "gettext.h"
#define _(msgid) gettext (msgid)
rank_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
struct rank_dialog rd;
-- GladeXML *xml = XML_NEW ("rank.glade");
++ GtkBuilder * builder = builder_new ("rank.ui");
-- GtkWidget *vars = get_widget_assert (xml, "dict-treeview");
-- GtkWidget *selector1 = get_widget_assert (xml, "psppire-selector1");
-- GtkWidget *selector2 = get_widget_assert (xml, "psppire-selector2");
++ GtkWidget *vars = get_widget_assert (builder, "dict-treeview");
++ GtkWidget *selector1 = get_widget_assert (builder, "psppire-selector1");
++ GtkWidget *selector2 = get_widget_assert (builder, "psppire-selector2");
-- GtkWidget *types_button = get_widget_assert (xml, "button1");
-- GtkWidget *ties_button = get_widget_assert (xml, "button2");
++ GtkWidget *types_button = get_widget_assert (builder, "button1");
++ GtkWidget *ties_button = get_widget_assert (builder, "button2");
PsppireVarStore *vs = NULL;
g_object_get (de->data_editor, "var-store", &vs, NULL);
rd.dict = vs->dict;
-- rd.rank_vars = get_widget_assert (xml, "variables-treeview");
-- rd.group_vars = get_widget_assert (xml, "group-vars-treeview");
-- rd.dialog = get_widget_assert (xml, "rank-dialog");
++ rd.rank_vars = get_widget_assert (builder, "variables-treeview");
++ rd.group_vars = get_widget_assert (builder, "group-vars-treeview");
++ rd.dialog = get_widget_assert (builder, "rank-dialog");
rd.ascending_togglebutton =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "radiobutton1"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "radiobutton1"));
rd.summary_togglebutton =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "summary-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "summary-checkbutton"));
-- rd.types_dialog = get_widget_assert (xml, "rank-types-dialog");
++ rd.types_dialog = get_widget_assert (builder, "rank-types-dialog");
-- rd.ntiles_entry = get_widget_assert (xml, "ntiles-entry");
++ rd.ntiles_entry = get_widget_assert (builder, "ntiles-entry");
rd.func_button[RANK] =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "rank-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "rank-checkbutton"));
rd.func_button[SAVAGE] =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "savage-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "savage-checkbutton"));
rd.func_button[RFRACTION] =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "rfrac-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "rfrac-checkbutton"));
rd.func_button[PERCENT] =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "percent-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "percent-checkbutton"));
rd.func_button[N] =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "sum-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "sum-checkbutton"));
rd.func_button[NTILES] =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "ntiles-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "ntiles-checkbutton"));
rd.func_button[PROPORTION] =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "prop-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "prop-checkbutton"));
rd.func_button[NORMAL] =
-- GTK_TOGGLE_BUTTON (get_widget_assert (xml, "normal-checkbutton"));
++ GTK_TOGGLE_BUTTON (get_widget_assert (builder, "normal-checkbutton"));
-- rd.formula_box = get_widget_assert (xml, "formula-frame");
++ rd.formula_box = get_widget_assert (builder, "formula-frame");
-- rd.blom = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "blom-button"));
-- rd.tukey = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "tukey-button"));
-- rd.rankit = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "rankit-button"));
-- rd.vw = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "vw-button"));
++ rd.blom = GTK_TOGGLE_BUTTON (get_widget_assert (builder, "blom-button"));
++ rd.tukey = GTK_TOGGLE_BUTTON (get_widget_assert (builder, "tukey-button"));
++ rd.rankit = GTK_TOGGLE_BUTTON (get_widget_assert (builder, "rankit-button"));
++ rd.vw = GTK_TOGGLE_BUTTON (get_widget_assert (builder, "vw-button"));
/* Ties dialog */
-- rd.ties_dialog = PSPPIRE_DIALOG (get_widget_assert (xml, "ties-dialog"));
++ rd.ties_dialog = PSPPIRE_DIALOG (get_widget_assert (builder, "ties-dialog"));
-- rd.mean = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "mean-button"));
-- rd.low = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "low-button"));
-- rd.high = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "high-button"));
-- rd.condense = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "condense-button"));
++ rd.mean = GTK_TOGGLE_BUTTON (get_widget_assert (builder, "mean-button"));
++ rd.low = GTK_TOGGLE_BUTTON (get_widget_assert (builder, "low-button"));
++ rd.high = GTK_TOGGLE_BUTTON (get_widget_assert (builder, "high-button"));
++ rd.condense = GTK_TOGGLE_BUTTON (get_widget_assert (builder, "condense-button"));
g_signal_connect_swapped (rd.func_button[PROPORTION], "toggled",
G_CALLBACK (set_sensitivity),
G_CALLBACK (on_ntiles_toggle),
rd.ntiles_entry);
- gtk_window_set_transient_for (GTK_WINDOW (rd.dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (rd.dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (vars),
vs->dict,
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&rd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&rd);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
-
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
break;
break;
}
-- g_object_unref (xml);
++ g_object_unref (builder);
}
#include <gtk/gtk.h>
#include <language/syntax-string-source.h>
-#include <ui/gui/data-editor.h>
+#include <ui/gui/psppire-data-window.h>
#include <ui/gui/dialog-common.h>
#include <ui/gui/dict-display.h>
#include <ui/gui/helper.h>
#include <ui/gui/psppire-dialog.h>
#include <ui/gui/psppire-var-store.h>
-#include <ui/gui/syntax-editor.h>
+#include <ui/gui/helper.h>
#include <ui/syntax-gen.h>
#include "psppire-acr.h"
gtk_widget_set_sensitive (target, state);
}
-static void recode_dialog (struct data_editor *de, gboolean diff);
+static void recode_dialog (PsppireDataWindow *de, gboolean diff);
/* Pops up the Recode Same version of the dialog box */
void
recode_same_dialog (GObject *o, gpointer data)
{
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
recode_dialog (de, FALSE);
}
void
recode_different_dialog (GObject *o, gpointer data)
{
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
recode_dialog (de, TRUE);
}
}
static void
-recode_dialog (struct data_editor *de, gboolean diff)
+recode_dialog (PsppireDataWindow *de, gboolean diff)
{
gint response;
struct recode_dialog rd;
-- GladeXML *xml = XML_NEW ("recode.glade");
++ GtkBuilder *builder = builder_new ("recode.ui");
++ GtkWidget *selector = get_widget_assert (builder, "psppire-selector1");
-- GtkWidget *selector = get_widget_assert (xml, "psppire-selector1");
++ GtkWidget *oldandnew = get_widget_assert (builder, "button1");
-- GtkWidget *oldandnew = get_widget_assert (xml, "button1");
--
-- GtkWidget *output_variable_box = get_widget_assert (xml,"frame4");
++ GtkWidget *output_variable_box = get_widget_assert (builder,"frame4");
PsppireVarStore *vs = NULL;
g_object_get (de->data_editor, "var-store", &vs, NULL);
-- rd.change_button = get_widget_assert (xml, "change-button");
++ rd.change_button = get_widget_assert (builder, "change-button");
-- rd.dialog = get_widget_assert (xml, "recode-dialog");
-- rd.dict_treeview = get_widget_assert (xml, "treeview1");
-- rd.variable_treeview = get_widget_assert (xml, "treeview2");
-- rd.new_name_entry = get_widget_assert (xml, "dest-name-entry");
-- rd.new_label_entry = get_widget_assert (xml, "dest-label-entry");
++ rd.dialog = get_widget_assert (builder, "recode-dialog");
++ rd.dict_treeview = get_widget_assert (builder, "treeview1");
++ rd.variable_treeview = get_widget_assert (builder, "treeview2");
++ rd.new_name_entry = get_widget_assert (builder, "dest-name-entry");
++ rd.new_label_entry = get_widget_assert (builder, "dest-label-entry");
rd.dict = vs->dict;
rd.different = diff;
- gtk_window_set_transient_for (GTK_WINDOW (rd.dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (rd.dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (rd.dict_treeview),
/* Set up the Old & New Values subdialog */
{
-- rd.string_button = get_widget_assert (xml, "checkbutton1");
-- rd.width_entry = get_widget_assert (xml, "spinbutton1");
++ rd.string_button = get_widget_assert (builder, "checkbutton1");
++ rd.width_entry = get_widget_assert (builder, "spinbutton1");
-- rd.convert_button = get_widget_assert (xml, "checkbutton2");
++ rd.convert_button = get_widget_assert (builder, "checkbutton2");
-- rd.ov_range_lower_entry = get_widget_assert (xml, "entry5");
-- rd.ov_range_upper_entry = get_widget_assert (xml, "entry3");
-- rd.ov_low_up_entry = get_widget_assert (xml, "entry6");
-- rd.ov_high_down_entry = get_widget_assert (xml, "entry7");
++ rd.ov_range_lower_entry = get_widget_assert (builder, "entry5");
++ rd.ov_range_upper_entry = get_widget_assert (builder, "entry3");
++ rd.ov_low_up_entry = get_widget_assert (builder, "entry6");
++ rd.ov_high_down_entry = get_widget_assert (builder, "entry7");
-- rd.new_value_entry = get_widget_assert (xml, "entry1");
-- rd.ov_value_entry = get_widget_assert (xml, "entry2");
++ rd.new_value_entry = get_widget_assert (builder, "entry1");
++ rd.ov_value_entry = get_widget_assert (builder, "entry2");
-- rd.toggle[BUTTON_NEW_VALUE] = get_widget_assert (xml, "radiobutton1");
-- rd.toggle[BUTTON_NEW_SYSMIS] = get_widget_assert (xml, "radiobutton2");
-- rd.toggle[BUTTON_NEW_COPY] = get_widget_assert (xml, "radiobutton3");
-- rd.toggle[BUTTON_OLD_VALUE] = get_widget_assert (xml, "radiobutton4");
-- rd.toggle[BUTTON_OLD_SYSMIS] = get_widget_assert (xml, "radiobutton6");
-- rd.toggle[BUTTON_OLD_MISSING]= get_widget_assert (xml, "radiobutton7");
-- rd.toggle[BUTTON_OLD_RANGE] = get_widget_assert (xml, "radiobutton8");
-- rd.toggle[BUTTON_OLD_LOW_UP] = get_widget_assert (xml, "radiobutton10");
-- rd.toggle[BUTTON_OLD_HIGH_DOWN] = get_widget_assert (xml, "radiobutton5");
-- rd.toggle[BUTTON_OLD_ELSE] = get_widget_assert (xml, "radiobutton11");
++ rd.toggle[BUTTON_NEW_VALUE] = get_widget_assert (builder, "radiobutton1");
++ rd.toggle[BUTTON_NEW_SYSMIS] = get_widget_assert (builder, "radiobutton2");
++ rd.toggle[BUTTON_NEW_COPY] = get_widget_assert (builder, "radiobutton3");
++ rd.toggle[BUTTON_OLD_VALUE] = get_widget_assert (builder, "radiobutton4");
++ rd.toggle[BUTTON_OLD_SYSMIS] = get_widget_assert (builder, "radiobutton6");
++ rd.toggle[BUTTON_OLD_MISSING]= get_widget_assert (builder, "radiobutton7");
++ rd.toggle[BUTTON_OLD_RANGE] = get_widget_assert (builder, "radiobutton8");
++ rd.toggle[BUTTON_OLD_LOW_UP] = get_widget_assert (builder, "radiobutton10");
++ rd.toggle[BUTTON_OLD_HIGH_DOWN] = get_widget_assert (builder, "radiobutton5");
++ rd.toggle[BUTTON_OLD_ELSE] = get_widget_assert (builder, "radiobutton11");
-- rd.new_copy_label = get_widget_assert (xml, "label3");
-- rd.strings_box = get_widget_assert (xml, "table3");
++ rd.new_copy_label = get_widget_assert (builder, "label3");
++ rd.strings_box = get_widget_assert (builder, "table3");
rd.old_and_new_dialog =
-- PSPPIRE_DIALOG (get_widget_assert (xml, "old-new-values-dialog"));
++ PSPPIRE_DIALOG (get_widget_assert (builder, "old-new-values-dialog"));
gtk_window_set_transient_for (GTK_WINDOW (rd.old_and_new_dialog),
- de->parent.window);
+ GTK_WINDOW (de));
-- rd.acr = PSPPIRE_ACR (get_widget_assert (xml, "psppire-acr1"));
++ rd.acr = PSPPIRE_ACR (get_widget_assert (builder, "psppire-acr1"));
g_signal_connect_swapped (rd.toggle[BUTTON_NEW_VALUE], "toggled",
G_CALLBACK (set_acr), &rd);
g_signal_connect (rd.toggle[BUTTON_OLD_RANGE], "toggled",
G_CALLBACK (toggle_sensitivity),
-- get_widget_assert (xml, "entry3"));
++ get_widget_assert (builder, "entry3"));
g_signal_connect (rd.toggle[BUTTON_OLD_RANGE], "toggled",
G_CALLBACK (toggle_sensitivity),
-- get_widget_assert (xml, "entry5"));
++ get_widget_assert (builder, "entry5"));
g_signal_connect (rd.toggle[BUTTON_OLD_LOW_UP], "toggled",
G_CALLBACK (toggle_sensitivity), rd.ov_low_up_entry);
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&rd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&rd);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
gtk_list_store_clear (GTK_LIST_STORE (rd.value_map));
g_object_unref (rd.value_map);
-- g_object_unref (xml);
++ g_object_unref (builder);
}
/* Initialise VAL to reflect the current status of RD */
#include <stdlib.h>
#include <language/syntax-string-source.h>
-#include <ui/gui/data-editor.h>
+#include <ui/gui/psppire-data-window.h>
#include <ui/gui/dialog-common.h>
#include <ui/gui/dict-display.h>
#include <ui/gui/helper.h>
#include <ui/gui/psppire-dialog.h>
#include <ui/gui/psppire-var-store.h>
-#include <ui/gui/syntax-editor.h>
+#include <ui/gui/helper.h>
#include "gettext.h"
#define _(msgid) gettext (msgid)
regression_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
-
struct regression_dialog rd;
-- GladeXML *xml = XML_NEW ("regression.glade");
++ GtkBuilder *xml = builder_new ("regression.ui");
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
--
PsppireVarStore *vs;
GtkWidget *dialog = get_widget_assert (xml, "regression-dialog");
stats
);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (source),
vs->dict,
rd.current_opts.pred = FALSE;
rd.current_opts.resid = FALSE;
- gtk_window_set_transient_for (GTK_WINDOW (rd.save_dialog), de->parent.window);
- gtk_window_set_transient_for (GTK_WINDOW (rd.stat_dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (rd.save_dialog), GTK_WINDOW (de));
+ gtk_window_set_transient_for (GTK_WINDOW (rd.stat_dialog), GTK_WINDOW (de));
g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), &rd);
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&rd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&rd);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include "select-cases-dialog.h"
#include <gtk/gtk.h>
-- #include <glade/glade.h>
#include "helper.h"
#include "psppire-dialog.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "dialog-common.h"
#include "dict-display.h"
#include "widget-io.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
#include <gettext.h>
struct select_cases_dialog
{
/* The XML that created the dialog */
-- GladeXML *xml;
++ GtkBuilder *xml;
GtkWidget *spinbutton ;
GtkWidget *spinbutton1 ;
gint response;
struct select_cases_dialog scd = {0,0,0,0,0,0};
GtkWidget *dialog ;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
GtkWidget *entry = NULL;
GtkWidget *selector ;
GtkWidget *button_range;
GtkWidget *button_sample;
-- scd.xml = XML_NEW ("psppire.glade");
++ scd.xml = builder_new ("psppire.ui");
g_object_get (de->data_editor, "data-store", &scd.data_store, NULL);
dialog = get_widget_assert (scd.xml, "select-cases-dialog");
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
{
GtkWidget *source = get_widget_assert (scd.xml, "select-cases-treeview");
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&scd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&scd);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include "sort-cases-dialog.h"
#include "helper.h"
#include "psppire-dialog.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "psppire-var-store.h"
#include "dialog-common.h"
#include "dict-display.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
static void
refresh (PsppireDialog *dialog, GtkTreeView *dest)
sort_cases_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
struct sort_cases_dialog scd;
-- GladeXML *xml = XML_NEW ("psppire.glade");
++ GtkBuilder *xml = builder_new ("psppire.ui");
GtkWidget *dialog = get_widget_assert (xml, "sort-cases-dialog");
g_object_get (de->data_editor, "var-store", &vs, NULL);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (source),
vs->dict,
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&scd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&scd);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include "psppire-selector.h"
#include "psppire-dialog.h"
#include "helper.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "dict-display.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
#include <data/dictionary.h>
#include <gtk/gtk.h>
-- #include <glade/glade.h>
#include "dialog-common.h"
struct split_file_dialog
{
/* The XML that created the dialog */
-- GladeXML *xml;
++ GtkBuilder *xml;
/* The dictionary to which this dialog pertains */
PsppireDict *dict;
on_off_toggled (GtkToggleButton *togglebutton,
gpointer user_data)
{
-- GladeXML *xml = user_data;
++ GtkBuilder *xml = user_data;
GtkWidget *dest = get_widget_assert (xml, "split-file-grouping-vars");
GtkWidget *selector = get_widget_assert (xml, "split-file-selector");
GtkWidget *source = get_widget_assert (xml, "split-file-dict-treeview");
split_file_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
struct split_file_dialog sfd;
PsppireVarStore *vs ;
GtkWidget *selector ;
GtkWidget *on_off ;
-- sfd.xml = XML_NEW ("psppire.glade");
++ sfd.xml = builder_new ("psppire.ui");
dialog = get_widget_assert (sfd.xml, "split-file-dialog");
source = get_widget_assert (sfd.xml, "split-file-dict-treeview");
g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), &sfd);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&sfd);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&sfd);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
<glade-interface>
---<widget class="GtkWindow" id="syntax_editor">
--- <property name="default_width">640</property>
--- <property name="default_height">480</property>
--- <property name="can_focus">True</property>
--- <property name="title" translatable="yes">Psppire Syntax Editor</property>
--- <property name="type">GTK_WINDOW_TOPLEVEL</property>
--- <property name="window_position">GTK_WIN_POS_NONE</property>
--- <property name="modal">False</property>
--- <property name="resizable">True</property>
--- <property name="destroy_with_parent">False</property>
--- <property name="decorated">True</property>
--- <property name="skip_taskbar_hint">False</property>
--- <property name="skip_pager_hint">False</property>
--- <property name="type_hint">GDK_WINDOW_TYPE_HINT_NORMAL</property>
--- <property name="gravity">GDK_GRAVITY_NORTH_WEST</property>
--- <property name="focus_on_map">True</property>
--- <property name="urgency_hint">False</property>
---
--- <child>
--- <widget class="GtkVBox" id="vbox14">
--- <property name="visible">True</property>
--- <property name="homogeneous">False</property>
--- <property name="spacing">0</property>
---
--- <child>
<widget class="GtkMenuBar" id="menubar2">
<property name="visible">True</property>
<property name="pack_direction">GTK_PACK_DIRECTION_LTR</property>
</widget>
</child>
</widget>
--- <packing>
--- <property name="padding">0</property>
--- <property name="expand">False</property>
--- <property name="fill">False</property>
--- </packing>
--- </child>
---
--- <child>
+++
+++
<widget class="GtkScrolledWindow" id="scrolledwindow8">
<property name="visible">True</property>
<property name="can_focus">True</property>
</widget>
</child>
</widget>
--- <packing>
--- <property name="padding">0</property>
--- <property name="expand">True</property>
--- <property name="fill">True</property>
--- </packing>
--- </child>
---
--- <child>
+++
<widget class="GtkStatusbar" id="statusbar2">
<property name="visible">True</property>
<property name="has_resize_grip">True</property>
</widget>
--- <packing>
--- <property name="padding">0</property>
--- <property name="expand">False</property>
--- <property name="fill">False</property>
--- </packing>
--- </child>
--- </widget>
--- </child>
---</widget>
</glade-interface>
#include <config.h>
-- #include <glade/glade.h>
#include <gtk/gtk.h>
#include "t-test-independent-samples-dialog.h"
#include "psppire-dict.h"
#include "psppire-var-store.h"
#include "helper.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "psppire-dialog.h"
#include "dialog-common.h"
#include "dict-display.h"
#include <ui/syntax-gen.h>
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
#include <gl/xalloc.h>
}
static struct tt_groups_dialog *
-- tt_groups_dialog_create (GladeXML *xml, GtkWindow *parent)
++ tt_groups_dialog_create (GtkBuilder *xml, GtkWindow *parent)
{
struct tt_groups_dialog *grps = xmalloc (sizeof (*grps));
struct tt_indep_samples_dialog
{
-- GladeXML *xml; /* The xml that generated the widgets */
++ GtkBuilder *xml; /* The xml that generated the widgets */
GtkWidget *dialog;
PsppireDict *dict;
GtkWidget *define_groups_button;
{
struct tt_indep_samples_dialog tt_d;
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
PsppireVarStore *vs = NULL;
-- GladeXML *xml = XML_NEW ("t-test.glade");
++ GtkBuilder *xml = builder_new ("t-test.ui");
GtkWidget *dict_view =
get_widget_assert (xml, "indep-samples-t-test-treeview1");
tt_d.define_groups_button = get_widget_assert (xml, "define-groups-button");
tt_d.groups_entry = get_widget_assert (xml, "indep-samples-t-test-entry");
- tt_d.opts = tt_options_dialog_create (xml, de->parent.window);
- tt_d.grps = tt_groups_dialog_create (xml, de->parent.window);
+ tt_d.opts = tt_options_dialog_create (xml, GTK_WINDOW (de));
+ tt_d.grps = tt_groups_dialog_create (xml, GTK_WINDOW (de));
- gtk_window_set_transient_for (GTK_WINDOW (tt_d.dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (tt_d.dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (dict_view),
vs->dict,
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&tt_d);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&tt_d);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
-
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
break;
#include <config.h>
-- #include <glade/glade.h>
#include <gtk/gtk.h>
#include "t-test-one-sample.h"
#include "psppire-dict.h"
#include "psppire-var-store.h"
#include "helper.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "psppire-dialog.h"
#include "dialog-common.h"
#include "dict-display.h"
#include "t-test-options.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
#include <gettext.h>
#define _(msgid) gettext (msgid)
{
struct tt_one_sample_dialog tt_d;
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
PsppireVarStore *vs = NULL;
-- GladeXML *xml = XML_NEW ("t-test.glade");
++ GtkBuilder *xml = builder_new ("t-test.ui");
GtkWidget *dict_view =
get_widget_assert (xml, "one-sample-t-test-treeview2");
tt_d.dict = vs->dict;
tt_d.vars_treeview = get_widget_assert (xml, "one-sample-t-test-treeview1");
tt_d.test_value_entry = get_widget_assert (xml, "test-value-entry");
- tt_d.opt = tt_options_dialog_create (xml, de->parent.window);
+ tt_d.opt = tt_options_dialog_create (xml, GTK_WINDOW (de));
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (dict_view),
vs->dict,
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&tt_d);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
{
gchar *syntax = generate_syntax (&tt_d);
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include <config.h>
#include <gtk/gtk.h>
-- #include <glade/glade.h>
#include <language/syntax-string-source.h>
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "psppire-dict.h"
#include "psppire-var-store.h"
#include "dialog-common.h"
#include "psppire-dialog.h"
-#include "syntax-editor.h"
-
#include "helper.h"
#include "psppire-var-ptr.h"
{
struct tt_paired_samples_dialog tt_d;
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
PsppireVarStore *vs = NULL;
-- GladeXML *xml = XML_NEW ("t-test.glade");
++ GtkBuilder *xml = builder_new ("t-test.ui");
GtkWidget *dict_view =
get_widget_assert (xml, "paired-samples-t-test-treeview1");
tt_d.dict = vs->dict;
tt_d.pairs_treeview =
get_widget_assert (xml, "paired-samples-t-test-treeview2");
- tt_d.opt = tt_options_dialog_create (xml, de->parent.window);
+ tt_d.opt = tt_options_dialog_create (xml, GTK_WINDOW (de));
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (dict_view),
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (&tt_d);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&tt_d);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include "psppire-selector.h"
#include "psppire-dialog.h"
#include "helper.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "dict-display.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
#include "dialog-common.h"
#include <gtk/gtk.h>
-- #include <glade/glade.h>
#include <gettext.h>
#include "psppire-var-store.h"
-- static gchar * generate_syntax (PsppireDict *dict, GladeXML *xml);
++ static gchar * generate_syntax (PsppireDict *dict, GtkBuilder *xml);
static void
refresh (PsppireDialog *dialog, gpointer data)
{
-- GladeXML *xml = data;
++ GtkBuilder *xml = data;
GtkWidget *dest = get_widget_assert (xml, "variables-treeview");
GtkWidget *entry = get_widget_assert (xml, "new-name-entry");
GtkTreeModel *dmodel = gtk_tree_view_get_model (GTK_TREE_VIEW (dest));
static gboolean
dialog_state_valid (gpointer data)
{
-- GladeXML *xml = data;
++ GtkBuilder *xml = data;
GtkWidget *tv = get_widget_assert (xml, "variables-treeview");
GtkWidget *entry = get_widget_assert (xml, "new-name-entry");
transpose_dialog (GObject *o, gpointer data)
{
gint response ;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
-- GladeXML *xml = XML_NEW ("psppire.glade");
++ GtkBuilder *xml = builder_new ("psppire.ui");
PsppireVarStore *vs = NULL;
g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), xml);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (dialog),
dialog_state_valid, xml);
case GTK_RESPONSE_OK:
{
gchar *syntax = generate_syntax (vs->dict, xml);
+
struct getl_interface *sss = create_syntax_string_source (syntax);
execute_syntax (sss);
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (vs->dict, xml);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
FLIP /VARIABLES=var_list /NEWNAMES=var_name.
*/
static gchar *
-- generate_syntax (PsppireDict *dict, GladeXML *xml)
++ generate_syntax (PsppireDict *dict, GtkBuilder *xml)
{
const gchar *text;
GString *string = g_string_new ("FLIP");
#include <config.h>
#include <gtk/gtk.h>
-- #include <glade/glade.h>
#include "dict-display.h"
#include "var-display.h"
#include <data/variable.h>
#include <data/format.h>
#include <data/value-labels.h>
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "psppire-dialog.h"
#include "psppire-var-store.h"
#include "helper.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
#include <gettext.h>
void
variable_info_dialog (GObject *o, gpointer data)
{
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
gint response ;
-- GladeXML *xml = XML_NEW ("psppire.glade");
++ GtkBuilder *xml = builder_new ("psppire.ui");
GtkWidget *dialog = get_widget_assert (xml, "variable-info-dialog");
GtkWidget *treeview = get_widget_assert (xml, "treeview2");
g_object_get (de->data_editor, "var-store", &vs, NULL);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
attach_dictionary_to_treeview (GTK_TREE_VIEW (treeview),
vs->dict,
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (GTK_TREE_VIEW (treeview));
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
#include "psppire-selector.h"
#include "psppire-dialog.h"
#include "helper.h"
-#include "data-editor.h"
+#include "psppire-data-window.h"
#include "dict-display.h"
#include <language/syntax-string-source.h>
-#include "syntax-editor.h"
+#include "helper.h"
#include <gtk/gtk.h>
-- #include <glade/glade.h>
#include <gettext.h>
#define _(msgid) gettext (msgid)
weight_cases_dialog (GObject *o, gpointer data)
{
gint response;
- struct data_editor *de = data;
+ PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
struct weight_cases_dialog wcd;
-- GladeXML *xml = XML_NEW ("psppire.glade");
++ GtkBuilder *xml = builder_new ("psppire.ui");
GtkWidget *dialog = get_widget_assert (xml, "weight-cases-dialog");
GtkWidget *source = get_widget_assert (xml, "weight-cases-treeview");
g_object_get (de->data_editor, "var-store", &vs, NULL);
- gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
g_signal_connect (radiobutton1, "toggled", G_CALLBACK (on_toggle), entry);
g_signal_connect (selector, "selected", G_CALLBACK (on_select),
case PSPPIRE_RESPONSE_PASTE:
{
gchar *syntax = generate_syntax (&wcd);
-
- struct syntax_editor *se =
- (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
-
- gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
-
+ paste_syntax_in_new_window (syntax);
g_free (syntax);
}
break;
projects / pspp / commitdiff