source: pkg/main/evolution/branches/upstream/current/widgets/table/e-table-header.c @ 80

Revision 80, 24.0 KB checked in by alanbach-guest, 7 years ago (diff)

[svn-inject] Installing original source of evolution

Line 
1/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2/*
3 * e-table-header.c
4 * Copyright 1999, 2000, 2001, Ximian, Inc.
5 *
6 * Authors:
7 *   Chris Lahey <clahey@ximian.com>
8 *   Miguel de Icaza <miguel@ximian.com>
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Library General Public
12 * License, version 2, as published by the Free Software Foundation.
13 *
14 * This library is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * Library General Public License for more details.
18 *
19 * You should have received a copy of the GNU Library General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 * 02111-1307, USA.
23 */
24
25#include <config.h>
26
27#include <string.h>
28
29#include <glib-object.h>
30#include <gtk/gtk.h>
31
32#include "e-util/e-util.h"
33
34#include "e-table-defines.h"
35#include "e-table-header.h"
36
37/* The arguments we take */
38enum {
39        PROP_0,
40        PROP_SORT_INFO,
41        PROP_WIDTH,
42        PROP_WIDTH_EXTRAS
43};
44
45enum {
46        STRUCTURE_CHANGE,
47        DIMENSION_CHANGE,
48        EXPANSION_CHANGE,
49        REQUEST_WIDTH,
50        LAST_SIGNAL
51};
52
53static void eth_set_size (ETableHeader *eth, int idx, int size);
54static void eth_calc_widths (ETableHeader *eth);
55
56static guint eth_signals [LAST_SIGNAL] = { 0, };
57
58static GObjectClass *e_table_header_parent_class;
59
60struct two_ints {
61        int column;
62        int width;
63};
64
65static void
66eth_set_width (ETableHeader *eth, int width)
67{
68        eth->width = width;
69}
70
71static void
72dequeue (ETableHeader *eth, int *column, int *width)
73{
74        GSList *head;
75        struct two_ints *store;
76        head = eth->change_queue;
77        eth->change_queue = eth->change_queue->next;
78        if (!eth->change_queue)
79                eth->change_tail = NULL;
80        store = head->data;
81        g_slist_free_1(head);
82        if (column)
83                *column = store->column;
84        if (width)
85                *width = store->width;
86        g_free(store);
87}
88
89static gboolean
90dequeue_idle (ETableHeader *eth)
91{
92        int column, width;
93
94        dequeue (eth, &column, &width);
95        while (eth->change_queue && ((struct two_ints *) eth->change_queue->data)->column == column)
96                dequeue (eth, &column, &width);
97
98        if (column == -1)
99                eth_set_width (eth, width);
100        else if (column < eth->col_count)
101                eth_set_size (eth, column, width);
102        if (eth->change_queue)
103                return TRUE;
104        else {
105                eth_calc_widths (eth);
106                eth->idle = 0;
107                return FALSE;
108        }
109}
110
111static void
112enqueue (ETableHeader *eth, int column, int width)
113{
114        struct two_ints *store;
115        store = g_new(struct two_ints, 1);
116        store->column = column;
117        store->width = width;
118       
119        eth->change_tail = g_slist_last(g_slist_append(eth->change_tail, store));
120        if (!eth->change_queue)
121                eth->change_queue = eth->change_tail;
122
123        if (!eth->idle) {
124                eth->idle = g_idle_add_full(G_PRIORITY_LOW, (GSourceFunc) dequeue_idle, eth, NULL);
125        }
126}
127
128void
129e_table_header_set_size (ETableHeader *eth, int idx, int size)
130{
131        g_return_if_fail (eth != NULL);
132        g_return_if_fail (E_IS_TABLE_HEADER (eth));
133
134        enqueue (eth, idx, size);
135}
136
137static void
138eth_do_remove (ETableHeader *eth, int idx, gboolean do_unref)
139{
140        if (do_unref)
141                g_object_unref (eth->columns [idx]);
142       
143        memmove (&eth->columns [idx], &eth->columns [idx+1],
144                 sizeof (ETableCol *) * (eth->col_count - idx - 1));
145        eth->col_count--;
146}
147
148static void
149eth_finalize (GObject *object)
150{
151        ETableHeader *eth = E_TABLE_HEADER (object);
152        const int cols = eth->col_count;
153        int i;
154       
155        if (eth->sort_info) {
156                if (eth->sort_info_group_change_id)
157                        g_signal_handler_disconnect(G_OBJECT(eth->sort_info),
158                                                    eth->sort_info_group_change_id);
159                g_object_unref(eth->sort_info);
160                eth->sort_info = NULL;
161        }
162
163        if (eth->idle)
164                g_source_remove(eth->idle);
165        eth->idle = 0;
166
167        if (eth->change_queue) {
168                g_slist_foreach(eth->change_queue, (GFunc) g_free, NULL);
169                g_slist_free(eth->change_queue);
170                eth->change_queue = NULL;
171        }
172       
173        /*
174         * Destroy columns
175         */
176        for (i = cols - 1; i >= 0; i--){
177                eth_do_remove (eth, i, TRUE);
178        }
179        g_free (eth->columns);
180
181        eth->col_count = 0;
182        eth->columns = NULL;
183
184        if (e_table_header_parent_class->finalize)
185                e_table_header_parent_class->finalize (object);
186}
187
188static void
189eth_group_info_changed(ETableSortInfo *info, ETableHeader *eth)
190{
191        enqueue(eth, -1, eth->nominal_width);
192}
193
194static void
195eth_set_property (GObject *object, guint prop_id, const GValue *val, GParamSpec *pspec)
196{
197        ETableHeader *eth = E_TABLE_HEADER (object);
198
199        switch (prop_id) {
200        case PROP_WIDTH:
201                eth->nominal_width = g_value_get_double (val);
202                enqueue(eth, -1, eth->nominal_width);
203                break;
204        case PROP_WIDTH_EXTRAS:
205                eth->width_extras = g_value_get_double (val);
206                enqueue(eth, -1, eth->nominal_width);
207                break;
208        case PROP_SORT_INFO:
209                if (eth->sort_info) {
210                        if (eth->sort_info_group_change_id)
211                                g_signal_handler_disconnect(G_OBJECT(eth->sort_info), eth->sort_info_group_change_id);
212                        g_object_unref (eth->sort_info);
213                }
214                eth->sort_info = E_TABLE_SORT_INFO(g_value_get_object (val));
215                if (eth->sort_info) {
216                        g_object_ref(eth->sort_info);
217                        eth->sort_info_group_change_id
218                                = g_signal_connect(G_OBJECT(eth->sort_info), "group_info_changed",
219                                                   G_CALLBACK(eth_group_info_changed), eth);
220                }
221                enqueue(eth, -1, eth->nominal_width);
222                break;
223        default:
224                break;
225        }
226}
227
228static void
229eth_get_property (GObject *object, guint prop_id, GValue *val, GParamSpec *pspec)
230{
231        ETableHeader *eth = E_TABLE_HEADER (object);
232
233        switch (prop_id) {
234        case PROP_SORT_INFO:
235                g_value_set_object (val, G_OBJECT(eth->sort_info));
236                break;
237        case PROP_WIDTH:
238                g_value_set_double (val, eth->nominal_width);
239                break;
240        case PROP_WIDTH_EXTRAS:
241                g_value_set_double (val, eth->width_extras);
242                break;
243        default:
244                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
245                break;
246        }
247}
248
249static void
250e_table_header_class_init (GObjectClass *object_class)
251{
252        ETableHeaderClass *klass = E_TABLE_HEADER_CLASS (object_class);
253
254        object_class->finalize = eth_finalize;
255        object_class->set_property = eth_set_property;
256        object_class->get_property = eth_get_property;
257
258        e_table_header_parent_class = g_type_class_peek_parent (object_class);
259
260        g_object_class_install_property (
261                object_class, PROP_WIDTH,
262                g_param_spec_double ("width", "Width", "Width", 
263                                     0.0, G_MAXDOUBLE, 0.0, 
264                                     G_PARAM_READWRITE)); 
265
266        g_object_class_install_property (
267                object_class, PROP_WIDTH_EXTRAS,
268                g_param_spec_double ("width_extras", "Width of Extras", "Width of Extras", 
269                                     0.0, G_MAXDOUBLE, 0.0, 
270                                     G_PARAM_READWRITE)); 
271
272        g_object_class_install_property (
273                object_class, PROP_SORT_INFO,
274                g_param_spec_object ("sort_info", "Sort Info", "Sort Info", 
275                                     E_TABLE_SORT_INFO_TYPE,
276                                     G_PARAM_READWRITE)); 
277
278        eth_signals [STRUCTURE_CHANGE] =
279                g_signal_new ("structure_change",
280                              E_OBJECT_CLASS_TYPE (object_class),
281                              G_SIGNAL_RUN_LAST,
282                              G_STRUCT_OFFSET (ETableHeaderClass, structure_change),
283                              (GSignalAccumulator) NULL, NULL,
284                              g_cclosure_marshal_VOID__VOID,
285                              G_TYPE_NONE, 0);
286        eth_signals [DIMENSION_CHANGE] = 
287                g_signal_new ("dimension_change", 
288                              E_OBJECT_CLASS_TYPE (object_class),
289                              G_SIGNAL_RUN_LAST,
290                              G_STRUCT_OFFSET (ETableHeaderClass, dimension_change),
291                              (GSignalAccumulator) NULL, NULL,
292                              g_cclosure_marshal_VOID__INT,
293                              G_TYPE_NONE, 1, G_TYPE_INT);
294        eth_signals [EXPANSION_CHANGE] = 
295                g_signal_new ("expansion_change", 
296                              E_OBJECT_CLASS_TYPE (object_class),
297                              G_SIGNAL_RUN_LAST,
298                              G_STRUCT_OFFSET (ETableHeaderClass, expansion_change),
299                              (GSignalAccumulator) NULL, NULL,
300                              g_cclosure_marshal_VOID__VOID,
301                              G_TYPE_NONE, 0);
302        eth_signals [REQUEST_WIDTH] = 
303                g_signal_new ("request_width",
304                              E_OBJECT_CLASS_TYPE (object_class),
305                              G_SIGNAL_RUN_LAST,
306                              G_STRUCT_OFFSET (ETableHeaderClass, request_width),
307                              (GSignalAccumulator) NULL, NULL,
308                              e_util_marshal_INT__INT,
309                              G_TYPE_INT, 1, G_TYPE_INT);
310
311        klass->structure_change = NULL;
312        klass->dimension_change = NULL;
313        klass->expansion_change = NULL;
314        klass->request_width = NULL;
315}
316
317static void
318e_table_header_init (ETableHeader *eth)
319{
320        eth->col_count                 = 0;
321        eth->width                     = 0;
322
323        eth->sort_info                 = NULL;
324        eth->sort_info_group_change_id = 0;
325
326        eth->columns                   = NULL;
327       
328        eth->change_queue              = NULL;
329        eth->change_tail               = NULL;
330
331        eth->width_extras              = 0;
332}
333
334/**
335 * e_table_header_new:
336 *
337 * Returns: A new @ETableHeader object.
338 */
339ETableHeader *
340e_table_header_new (void)
341{
342
343        return (ETableHeader *) g_object_new (E_TABLE_HEADER_TYPE, NULL);
344}
345
346static void
347eth_update_offsets (ETableHeader *eth)
348{
349        int i;
350        int x = 0;
351       
352        for (i = 0; i < eth->col_count; i++){
353                ETableCol *etc = eth->columns [i];
354
355                etc->x = x;
356                x += etc->width;
357        }
358}
359
360static void
361eth_do_insert (ETableHeader *eth, int pos, ETableCol *val)
362{
363        memmove (&eth->columns [pos+1], &eth->columns [pos],
364                sizeof (ETableCol *) * (eth->col_count - pos));
365        eth->columns [pos] = val;
366        eth->col_count ++;
367}
368
369/**
370 * e_table_header_add_column:
371 * @eth: the table header to add the column to.
372 * @tc: the ETableCol definition
373 * @pos: position where the ETableCol will go.
374 *
375 * This function adds the @tc ETableCol definition into the @eth ETableHeader
376 * at position @pos.  This is the way you add new ETableCols to the
377 * ETableHeader.  The header will assume ownership of the @tc; you should not
378 * unref it after you add it.
379 *
380 * This function will emit the "structure_change" signal on the @eth object.
381 * The ETableCol is assumed
382 */
383void
384e_table_header_add_column (ETableHeader *eth, ETableCol *tc, int pos)
385{
386        g_return_if_fail (eth != NULL);
387        g_return_if_fail (E_IS_TABLE_HEADER (eth));
388        g_return_if_fail (tc != NULL);
389        g_return_if_fail (E_IS_TABLE_COL (tc));
390        g_return_if_fail (pos >= -1 && pos <= eth->col_count);
391
392        if (pos == -1)
393                pos = eth->col_count;
394        eth->columns = g_realloc (eth->columns, sizeof (ETableCol *) * (eth->col_count + 1));
395
396        /*
397         * We are the primary owners of the column
398         */
399        g_object_ref (tc);
400       
401        eth_do_insert (eth, pos, tc);
402
403        enqueue(eth, -1, eth->nominal_width);
404        g_signal_emit (G_OBJECT (eth), eth_signals [STRUCTURE_CHANGE], 0);
405}
406
407/**
408 * e_table_header_get_column:
409 * @eth: the ETableHeader to query
410 * @column: the column inside the @eth.
411 *
412 * Returns: The ETableCol at @column in the @eth object
413 */
414ETableCol *
415e_table_header_get_column (ETableHeader *eth, int column)
416{
417        g_return_val_if_fail (eth != NULL, NULL);
418        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), NULL);
419
420        if (column < 0)
421                return NULL;
422
423        if (column >= eth->col_count)
424                return NULL;
425
426        return eth->columns [column];
427}
428
429/**
430 * e_table_header_get_column_by_col_id:
431 * @eth: the ETableHeader to query
432 * @col_id: the col_id to search for.
433 *
434 * Returns: The ETableCol with col_idx = @col_idx in the @eth object
435 */
436ETableCol *
437e_table_header_get_column_by_col_idx (ETableHeader *eth, int col_idx)
438{
439        int i;
440        g_return_val_if_fail (eth != NULL, NULL);
441        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), NULL);
442
443        for (i = 0; i < eth->col_count; i++) {
444                if (eth->columns[i]->col_idx == col_idx) {
445                        return eth->columns [i];
446                }
447        }
448
449        return NULL;
450}
451
452/**
453 * e_table_header_count:
454 * @eth: the ETableHeader to query
455 *
456 * Returns: the number of columns in this ETableHeader.
457 */
458int
459e_table_header_count (ETableHeader *eth)
460{
461        g_return_val_if_fail (eth != NULL, 0);
462        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), 0);
463
464        return eth->col_count;
465}
466
467/**
468 * e_table_header_index:
469 * @eth: the ETableHeader to query
470 * @col: the column to fetch.
471 *
472 * ETableHeaders contain the visual list of columns that the user will
473 * view.  The visible columns will typically map to different columns
474 * in the ETableModel (because the user reordered the data for
475 * example).
476 *
477 * Returns: the column in the model that the @col column
478 * in the ETableHeader points to.  */
479int
480e_table_header_index (ETableHeader *eth, int col)
481{
482        g_return_val_if_fail (eth != NULL, -1);
483        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), -1);
484        g_return_val_if_fail (col >= 0 && col < eth->col_count, -1);
485
486        return eth->columns [col]->col_idx;
487}
488
489/**
490 * e_table_header_get_index_at:
491 * @eth: the ETableHeader to query
492 * @x_offset: a pixel count from the beginning of the ETableHeader
493 *
494 * This will return the ETableHeader column that would contain
495 * the @x_offset pixel.
496 *
497 * Returns: the column that contains pixel @x_offset, or -1
498 * if no column inside this ETableHeader contains that pixel.
499 */
500int
501e_table_header_get_index_at (ETableHeader *eth, int x_offset)
502{
503        int i, total;
504       
505        g_return_val_if_fail (eth != NULL, 0);
506        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), 0);
507
508        total = 0;
509        for (i = 0; i < eth->col_count; i++){
510                total += eth->columns [i]->width;
511
512                if (x_offset < total)
513                        return i;
514        }
515
516        return -1;
517}
518
519/**
520 * e_table_header_get_columns:
521 * @eth: The ETableHeader to query
522 *
523 * Returns: A NULL terminated array of the ETableCols
524 * contained in the ETableHeader @eth.  Note that every
525 * returned ETableCol in the array has been referenced, to release
526 * this information you need to g_free the buffer returned
527 * and you need to g_object_unref every element returned
528 */
529ETableCol **
530e_table_header_get_columns (ETableHeader *eth)
531{
532        ETableCol **ret;
533        int i;
534       
535        g_return_val_if_fail (eth != NULL, 0);
536        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), 0);
537
538        ret = g_new (ETableCol *, eth->col_count + 1);
539        memcpy (ret, eth->columns, sizeof (ETableCol *) * eth->col_count);
540        ret [eth->col_count] = NULL;
541
542        for (i = 0; i < eth->col_count; i++) {
543                g_object_ref(ret[i]);
544        }
545
546        return ret;
547}
548
549/**
550 * e_table_header_get_selected:
551 * @eth: The ETableHeader to query
552 *
553 * Returns: The number of selected columns in the @eth object.
554 */
555int
556e_table_header_get_selected (ETableHeader *eth)
557{
558        int i;
559        int selected = 0;
560       
561        g_return_val_if_fail (eth != NULL, 0);
562        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), 0);
563
564        for (i = 0; i < eth->col_count; i++){
565                if (eth->columns [i]->selected)
566                        selected++;
567        }
568
569        return selected;
570}
571
572/**
573 * e_table_header_total_width:
574 * @eth: The ETableHeader to query
575 *
576 * Returns: the number of pixels used by the @eth object
577 * when rendered on screen
578 */
579int
580e_table_header_total_width (ETableHeader *eth)
581{
582        int total, i;
583       
584        g_return_val_if_fail (eth != NULL, 0);
585        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), 0);
586
587        total = 0;
588        for (i = 0; i < eth->col_count; i++)
589                total += eth->columns [i]->width;
590
591        return total;
592}
593
594/**
595 * e_table_header_min_width:
596 * @eth: The ETableHeader to query
597 *
598 * Returns: the minimum number of pixels required by the @eth object.
599 **/
600int
601e_table_header_min_width (ETableHeader *eth)
602{
603        int total, i;
604       
605        g_return_val_if_fail (eth != NULL, 0);
606        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), 0);
607
608        total = 0;
609        for (i = 0; i < eth->col_count; i++)
610                total += eth->columns [i]->min_width;
611
612        return total;
613}
614
615/**
616 * e_table_header_move:
617 * @eth: The ETableHeader to operate on.
618 * @source_index: the source column to move.
619 * @target_index: the target location for the column
620 *
621 * This function moves the column @source_index to @target_index
622 * inside the @eth ETableHeader.  The signals "dimension_change"
623 * and "structure_change" will be emmited
624 */
625void
626e_table_header_move (ETableHeader *eth, int source_index, int target_index)
627{
628        ETableCol *old;
629       
630        g_return_if_fail (eth != NULL);
631        g_return_if_fail (E_IS_TABLE_HEADER (eth));
632        g_return_if_fail (source_index >= 0);
633        g_return_if_fail (target_index >= 0);
634        g_return_if_fail (source_index < eth->col_count);
635        g_return_if_fail (target_index < eth->col_count + 1); /* Can be moved beyond the last item. */
636
637        if (source_index < target_index)
638                target_index --;
639
640        old = eth->columns [source_index];
641        eth_do_remove (eth, source_index, FALSE);
642        eth_do_insert (eth, target_index, old);
643        eth_update_offsets (eth);
644       
645        g_signal_emit (G_OBJECT (eth), eth_signals [DIMENSION_CHANGE], 0, eth->width);
646        g_signal_emit (G_OBJECT (eth), eth_signals [STRUCTURE_CHANGE], 0);
647}
648
649/**
650 * e_table_header_remove:
651 * @eth: The ETableHeader to operate on.
652 * @idx: the index to the column to be removed.
653 *
654 * Removes the column at @idx position in the ETableHeader @eth.
655 * This emmits the "structure_change" signal on the @eth object.
656 */
657void
658e_table_header_remove (ETableHeader *eth, int idx)
659{
660        g_return_if_fail (eth != NULL);
661        g_return_if_fail (E_IS_TABLE_HEADER (eth));
662        g_return_if_fail (idx >= 0);
663        g_return_if_fail (idx < eth->col_count);
664
665        eth_do_remove (eth, idx, TRUE);
666        enqueue(eth, -1, eth->nominal_width);
667        g_signal_emit (G_OBJECT (eth), eth_signals [STRUCTURE_CHANGE], 0);
668}
669
670/*
671 * FIXME: deprecated?
672 */
673void
674e_table_header_set_selection (ETableHeader *eth, gboolean allow_selection)
675{
676        g_return_if_fail (eth != NULL);
677        g_return_if_fail (E_IS_TABLE_HEADER (eth));
678}
679
680static void
681eth_set_size (ETableHeader *eth, int idx, int size)
682{
683        double expansion;
684        double old_expansion;
685        int min_width;
686        int left_width;
687        int total_extra;
688        int expandable_count;
689        int usable_width;
690        int i;
691        g_return_if_fail (eth != NULL);
692        g_return_if_fail (E_IS_TABLE_HEADER (eth));
693        g_return_if_fail (idx >= 0);
694        g_return_if_fail (idx < eth->col_count);
695       
696        /* If this column is not resizable, don't do anything. */
697        if (!eth->columns[idx]->resizable)
698                return;
699
700        expansion = 0;
701        min_width = 0;
702        left_width = 0;
703        expandable_count = -1;
704
705        /* Calculate usable area. */
706        for (i = 0; i < idx; i++) {
707                left_width += eth->columns[i]->width;
708        }
709        /* - 1 to account for the last pixel border. */
710        usable_width = eth->width - left_width - 1;
711
712        if (eth->sort_info)
713                usable_width -= e_table_sort_info_grouping_get_count(eth->sort_info) * GROUP_INDENT;
714
715        /* Calculate minimum_width of stuff on the right as well as
716         * total usable expansion on the right.
717         */
718        for (; i < eth->col_count; i++) {
719                min_width += eth->columns[i]->min_width + eth->width_extras;
720                if (eth->columns[i]->resizable) {
721                        expansion += eth->columns[i]->expansion;
722                        expandable_count ++;
723                }
724        }
725        /* If there's no room for anything, don't change. */
726        if (expansion == 0)
727                return;
728
729        /* (1) If none of the columns to the right are expandable, use
730         * all the expansion space in this column.
731         */
732        if(expandable_count == 0) {
733                eth->columns[idx]->expansion = expansion;
734                for (i = idx + 1; i < eth->col_count; i++) {
735                        eth->columns[i]->expansion = 0;
736                }
737
738                g_signal_emit (G_OBJECT (eth), eth_signals [EXPANSION_CHANGE], 0);
739                return;
740        }
741
742        total_extra = usable_width - min_width;
743        /* If there's no extra space, set all expansions to 0. */
744        if (total_extra <= 0) {
745                for (i = idx; i < eth->col_count; i++) {
746                        eth->columns[i]->expansion = 0;
747                }
748                g_signal_emit (G_OBJECT (eth), eth_signals [EXPANSION_CHANGE], 0);
749                return;
750        }
751
752        /* If you try to resize smaller than the minimum width, it
753         * uses the minimum. */
754        if (size < eth->columns[idx]->min_width + eth->width_extras)
755                size = eth->columns[idx]->min_width + eth->width_extras;
756
757        /* If all the extra space will be used up in this column, use
758         * all the expansion and set all others to 0.
759         */
760        if (size >= total_extra + eth->columns[idx]->min_width + eth->width_extras) {
761                eth->columns[idx]->expansion = expansion;
762                for (i = idx + 1; i < eth->col_count; i++) {
763                        eth->columns[i]->expansion = 0;
764                }
765                g_signal_emit (G_OBJECT (eth), eth_signals [EXPANSION_CHANGE], 0);
766                return;
767        }
768       
769        /* The old_expansion used by columns to the right. */
770        old_expansion = expansion;
771        old_expansion -= eth->columns[idx]->expansion;
772        /* Set the new expansion so that it will generate the desired size. */
773        eth->columns[idx]->expansion = expansion * (((double)(size - (eth->columns[idx]->min_width + eth->width_extras)))/((double)total_extra));
774        /* The expansion left for the columns on the right. */
775        expansion -= eth->columns[idx]->expansion;
776
777        /* (2) If the old columns to the right didn't have any
778         * expansion before, expand them evenly.  old_expansion > 0 by
779         * expansion = SUM(i=idx to col_count -1,
780         * columns[i]->min_width) - columns[idx]->min_width) =
781         * SUM(non-negatives).
782         */
783        if (old_expansion == 0) {
784                for (i = idx + 1; i < eth->col_count; i++) {
785                        if (eth->columns[idx]->resizable) {
786                                /* expandable_count != 0 by (1) */
787                                eth->columns[i]->expansion = expansion / expandable_count;
788                        }
789                }
790                g_signal_emit (G_OBJECT (eth), eth_signals [EXPANSION_CHANGE], 0);
791                return;
792        }
793
794        /* Remove from total_extra the amount used for this column. */
795        total_extra -= size - (eth->columns[idx]->min_width + eth->width_extras);
796        for (i = idx + 1; i < eth->col_count; i++) {
797                if (eth->columns[idx]->resizable) {
798                        /* old_expansion != 0 by (2) */
799                        eth->columns[i]->expansion *= expansion / old_expansion;
800                }
801        }
802        g_signal_emit (G_OBJECT (eth), eth_signals [EXPANSION_CHANGE], 0);
803}
804
805/**
806 * e_table_header_col_diff:
807 * @eth: the ETableHeader to query.
808 * @start_col: the starting column
809 * @end_col: the ending column.
810 *
811 * Computes the number of pixels between the columns @start_col and
812 * @end_col.
813 *
814 * Returns: the number of pixels between @start_col and @end_col on the
815 * @eth ETableHeader object
816 */
817int
818e_table_header_col_diff (ETableHeader *eth, int start_col, int end_col)
819{
820        int total, col;
821
822        g_return_val_if_fail (eth != NULL, 0);
823        g_return_val_if_fail (E_IS_TABLE_HEADER (eth), 0);
824
825        if (start_col < 0)
826                start_col = 0;
827        if (end_col > eth->col_count)
828                end_col = eth->col_count;
829
830        total = 0;
831        for (col = start_col; col < end_col; col++){
832               
833                total += eth->columns [col]->width;
834        }
835
836        return total;
837}
838
839static void
840eth_calc_widths (ETableHeader *eth)
841{
842        int i;
843        int extra;
844        double expansion;
845        int last_position = 0;
846        double next_position = 0;
847        int last_resizable = -1;
848        int *widths;
849        gboolean changed;
850
851        widths = g_new (int, eth->col_count);
852
853        /* - 1 to account for the last pixel border. */
854        extra = eth->width - 1;
855        expansion = 0;
856        for (i = 0; i < eth->col_count; i++) {
857                extra -= eth->columns[i]->min_width + eth->width_extras;
858                if (eth->columns[i]->resizable && eth->columns[i]->expansion > 0)
859                        last_resizable = i;
860                expansion += eth->columns[i]->resizable ? eth->columns[i]->expansion : 0;
861                widths[i] = eth->columns[i]->min_width + eth->width_extras;
862        }
863        if (eth->sort_info)
864                extra -= e_table_sort_info_grouping_get_count(eth->sort_info) * GROUP_INDENT;
865        if (expansion != 0 && extra > 0) {
866                for (i = 0; i < last_resizable; i++) {
867                        next_position += extra * (eth->columns[i]->resizable ? eth->columns[i]->expansion : 0)/expansion;
868                        widths[i] += next_position - last_position;
869                        last_position = next_position;
870                }
871                widths[i] += extra - last_position;
872        }
873
874        changed = FALSE;
875
876        for (i = 0; i < eth->col_count; i++) {
877                if (eth->columns[i]->width != widths[i]) {
878                        changed = TRUE;
879                        eth->columns[i]->width = widths[i];
880                }
881        }
882        g_free (widths);
883        if (changed)
884                g_signal_emit (G_OBJECT (eth), eth_signals [DIMENSION_CHANGE], 0, eth->width);
885        eth_update_offsets (eth);
886}
887
888void
889e_table_header_update_horizontal (ETableHeader *eth)
890{
891        int i;
892        int cols;
893
894        cols = eth->col_count;
895
896        for (i = 0; i < cols; i++) {
897                int width = 0;
898               
899                g_signal_emit_by_name (G_OBJECT (eth),
900                                         "request_width",
901                                         i, &width);
902                eth->columns[i]->min_width = width + 10;
903                eth->columns[i]->expansion = 1;
904        }
905        enqueue(eth, -1, eth->nominal_width);
906        g_signal_emit (G_OBJECT (eth), eth_signals [EXPANSION_CHANGE], 0);
907}
908
909E_MAKE_TYPE(e_table_header, "ETableHeader", ETableHeader, e_table_header_class_init, e_table_header_init, G_TYPE_OBJECT)
910
911int
912e_table_header_prioritized_column (ETableHeader *eth)
913{
914        int best_model_col = 0;
915        int best_priority;
916        int i;
917        int count;
918
919        count = e_table_header_count (eth);
920        if (count == 0)
921                return -1;
922        best_priority = e_table_header_get_column (eth, 0)->priority;
923        best_model_col = e_table_header_get_column (eth, 0)->col_idx;
924        for (i = 1; i < count; i++) {
925                int priority = e_table_header_get_column (eth, i)->priority;
926                if (priority > best_priority) {
927                        best_priority = priority;
928                        best_model_col = e_table_header_get_column (eth, i)->col_idx;
929                }
930        }
931        return best_model_col;
932}
933
934ETableCol *
935e_table_header_prioritized_column_selected (ETableHeader *eth, ETableColCheckFunc check_func, gpointer user_data)
936{
937        ETableCol *best_col = NULL;
938        int best_priority = G_MININT;
939        int i;
940        int count;
941
942        count = e_table_header_count (eth);
943        if (count == 0)
944                return NULL;
945        for (i = 1; i < count; i++) {
946                ETableCol *col = e_table_header_get_column (eth, i);
947                if (col) {
948                        if ((best_col == NULL || col->priority > best_priority) && check_func (col, user_data)) {
949                                best_priority = col->priority;
950                                best_col = col;
951                        }
952                }
953        }
954        return best_col;
955}
Note: See TracBrowser for help on using the repository browser.