aboutsummaryrefslogtreecommitdiffstats
path: root/widgets/table/e-table-example-1.c
blob: b1eae4cc40c6ed5065769bc32d01cdcdf30a8a96 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Chris Lahey <clahey@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#include <stdio.h>
#include <string.h>
#include <gdk-pixbuf/gdk-pixbuf.h>

#include "gal/e-util/e-cursors.h"
#include "e-table-simple.h"
#include "e-table-header.h"
#include "e-table-header-item.h"
#include "e-table-item.h"
#include "e-cell-text.h"
#include "e-cell-checkbox.h"
#include "e-table.h"

#include "table-test.h"

/*
 * One way in which we make it simpler to build an ETableModel is through
 * the ETableSimple class.  Instead of creating your own ETableModel
 * class, you simply create a new object of the ETableSimple class.  You
 * give it a bunch of functions that act as callbacks.
 *
 * You also get to pass a void * to ETableSimple and it gets passed to
 * your callbacks.  This would be for having multiple models of the same
 * type.  This is just an example though, so we statically define all the
 * data and ignore the void *data parameter.
 *
 * In our example we will be creating a table model with 6 columns and 10
 * rows.  This corresponds to having 6 different types of information and
 * 10 different sets of data in our database.
 *
 * The headers will be hard coded, as will be the example data.
 *
 */

/*
 * There are two different meanings to the word "column".  The first is
 * the model column.  A model column corresponds to a specific type of
 * data.  This is very much like the usage in a database table where a
 * column is a field in the database.
 *
 * The second type of column is a view column.  A view column
 * corresponds to a visually displayed column.  Each view column
 * corresponds to a specific model column, though a model column may
 * have any number of view columns associated with it, from zero to
 * greater than one.
 *
 * Also, a view column doesn't necessarily depend on only one model
 * column.  In some cases, the view column renderer can be given a
 * reference to another column to get extra information about its
 * display.
*/

#define ROWS 10
#define COLS 4

#define IMPORTANCE_COLUMN 4
#define COLOR_COLUMN 5

/*
 * Here we define the initial layout of the table.  This is an xml
 * format that allows you to change the initial ordering of the
 * columns or to do sorting or grouping initially.  This specification
 * shows all 5 columns, but moves the importance column nearer to the
 * front.  It also sorts by the "Full Name" column (ascending.)
 * Sorting and grouping take the model column as their arguments
 * (sorting is specified by the "column" argument to the leaf elemnt.
 */

#define INITIAL_SPEC "<ETableSpecification>                            \
    <columns-shown>                                    \
        <column> 0 </column>                       \
        <column> 4 </column>                       \
        <column> 1 </column>                       \
        <column> 2 </column>                       \
        <column> 3 </column>                       \
    </columns-shown>                                   \
    <grouping> <leaf column=\"1\" ascending=\"true\"/> </grouping>    \
</ETableSpecification>"

char *headers [COLS] = {
  "Email",
  "Full Name",
  "Address",
  "Phone"
};

/*
 * Virtual Column list:
 * 0   Email
 * 1   Full Name
 * 2   Address
 * 3   Phone
 */

char *table_data [ROWS] [COLS];

/*
 * ETableSimple callbacks
 * These are the callbacks that define the behavior of our custom model.
 */

/*
 * Since our model is a constant size, we can just return its size in
 * the column and row count fields.
 */

/* This function returns the number of columns in our ETableModel. */
static int
my_col_count (ETableModel *etc, void *data)
{
    return COLS;
}

/* This function returns the number of rows in our ETableModel. */
static int
my_row_count (ETableModel *etc, void *data)
{
    return ROWS;
}

/* This function returns the value at a particular point in our ETableModel. */
static void *
my_value_at (ETableModel *etc, int col, int row, void *data)
{
    return (void *) table_data [row] [col];
}

/* This function sets the value at a particular point in our ETableModel. */
static void
my_set_value_at (ETableModel *etc, int col, int row, const void *val, void *data)
{
    g_free (table_data [row] [col]);
    table_data [row] [col] = g_strdup (val);
}

/* This function returns whether a particular cell is editable. */
static gboolean
my_is_cell_editable (ETableModel *etc, int col, int row, void *data)
{
    return TRUE;
}

/* This function duplicates the value passed to it. */
static void *
my_duplicate_value (ETableModel *etc, int col, const void *value, void *data)
{
    return g_strdup (value);
}

/* This function frees the value passed to it. */
static void
my_free_value (ETableModel *etc, int col, void *value, void *data)
{
    g_free (value);
}

/* This function creates an empty value. */
static void *
my_initialize_value (ETableModel *etc, int col, void *data)
{
    return g_strdup ("");
}

/* This function reports if a value is empty. */
static gboolean
my_value_is_empty (ETableModel *etc, int col, const void *value, void *data)
{
    return !(value && *(char *)value);
}

/* This function reports if a value is empty. */
static char *
my_value_to_string (ETableModel *etc, int col, const void *value, void *data)
{
    return g_strdup(value);
}

/* We create a window containing our new table. */
static void
create_table (void)
{
    GtkWidget *e_table, *window, *frame;
    ECell *cell_left_just;
    ETableHeader *e_table_header;
    int i, j;
    ETableModel *e_table_model = NULL;

    /* First we fill in the simple data. */
    for (i = 0; i < ROWS; i++){
        for (j = 0; j < COLS; j++)
            table_data [i] [j] = g_strdup ("");
    }
    /* Next we create our model.  This uses the functions we defined
       earlier. */
    e_table_model = e_table_simple_new (
                        my_col_count, my_row_count, my_value_at,
                        my_set_value_at, my_is_cell_editable,
                        my_duplicate_value, my_free_value,
                        my_initialize_value, my_value_is_empty,
                        my_value_to_string,
                        NULL);
    /*
     * Next we create a header.  The ETableHeader is used in two
     * different way.  The first is the full_header.  This is the
     * list of possible columns in the view.  The second use is
     * completely internal.  Many of the ETableHeader functions are
     * for that purpose.  The only functions we really need are
     * e_table_header_new and e_table_header_add_col.
     *
     * First we create the header.
     */
    e_table_header = e_table_header_new ();

    /*
     * Next we have to build renderers for all of the columns.
     * Since all our columns are text columns, we can simply use
     * the same renderer over and over again.  If we had different
     * types of columns, we could use a different renderer for
     * each column.
     */
    cell_left_just = e_cell_text_new (e_table_model, NULL, GTK_JUSTIFY_LEFT);

    /*
     * Next we create a column object for each view column and add
     * them to the header.  We don't create a column object for
     * the importance column since it will not be shown.
     */
    for (i = 0; i < COLS; i++) {
        /* Create the column. */
        ETableCol *ecol = e_table_col_new (
                           i, headers [i],
                           1.0, 20, cell_left_just,
                           g_str_compare, TRUE);
        /* Add it to the header. */
        e_table_header_add_column (e_table_header, ecol, i);
    }

    /*
     * Here we create a window for our new table.  This window
     * will get shown and the person will be able to test their
     * item.
     */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

    /* This frame is simply to get a bevel around our table. */
    frame = gtk_frame_new (NULL);

    /*
     * Here we create the table.  We give it the three pieces of
     * the table we've created, the header, the model, and the
     * initial layout.  It does the rest.
     */
    e_table = e_table_new (e_table_header, e_table_model, INITIAL_SPEC);

    /* Build the gtk widget hierarchy. */
    gtk_container_add (GTK_CONTAINER (frame), e_table);
    gtk_container_add (GTK_CONTAINER (window), frame);

    /* Size the initial window. */
    gtk_widget_set_size_request (window, 200, 200);

    /* Show it all. */
    gtk_widget_show_all (window);
}

/* This is the main function which just initializes gnome and call our create_table function */

int
main (int argc, char *argv [])
{
    gnome_init ("TableExample", "TableExample", argc, argv);
    e_cursors_init ();

    gtk_widget_push_colormap (gdk_rgb_get_colormap ());

    create_table ();

    gtk_main ();

    e_cursors_shutdown ();
    return 0;
}