Implemented a rotations subdialog for the FACTOR command
[pspp] / src / output / table-select.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2009 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include <libpspp/assertion.h>
20 #include <libpspp/cast.h>
21 #include <output/table-provider.h>
22
23 #include "gl/minmax.h"
24 #include "gl/xalloc.h"
25
26 struct table_select
27   {
28     struct table table;
29     struct table *subtable;
30     int ofs[2];
31   };
32
33 static const struct table_class table_select_class;
34
35 static struct table_select *
36 table_select_cast (const struct table *table)
37 {
38   assert (table->class == &table_select_class);
39   return UP_CAST (table, struct table_select, table);
40 }
41
42 /* Takes ownership of SUBTABLE and returns a new table whose contents are the
43    rectangular subregion of SUBTABLE that contains rows RECT[TABLE_VERT][0]
44    through RECT[TABLE_VERT][1], exclusive, and columns RECT[TABLE_HORZ][0]
45    through RECT[TABLE_HORZ][1]. */
46 struct table *
47 table_select (struct table *subtable, int rect[TABLE_N_AXES][2])
48 {
49   struct table_select *ts;
50   int axis;
51
52   if (rect[TABLE_HORZ][0] == 0
53       && rect[TABLE_HORZ][1] == subtable->n[TABLE_HORZ]
54       && rect[TABLE_VERT][0] == 0
55       && rect[TABLE_VERT][1] == subtable->n[TABLE_VERT])
56     return subtable;
57
58   if (!table_is_shared (subtable) && subtable->class->select != NULL)
59     {
60       struct table *selected = subtable->class->select (subtable, rect);
61       if (selected != NULL)
62         return selected;
63     }
64
65   ts = xmalloc (sizeof *ts);
66   table_init (&ts->table, &table_select_class);
67   ts->subtable = subtable;
68   for (axis = 0; axis < TABLE_N_AXES; axis++)
69     {
70       int h1;
71       ts->ofs[axis] = rect[axis][0];
72       ts->table.n[axis] = rect[axis][1] - rect[axis][0];
73       if (subtable->h[axis][0] > rect[axis][0])
74         ts->table.h[axis][0] = subtable->h[axis][0] - rect[axis][0];
75       h1 = subtable->n[axis] - subtable->h[axis][1];
76       if (h1 < rect[axis][1])
77         ts->table.h[axis][1] = rect[axis][1] - h1;
78     }
79   return &ts->table;
80 }
81
82 /* Takes ownership of TABLE and returns a new table whose contents are:
83
84         - If AXIS is TABLE_HORZ, columns Z0 through Z1 (exclusive) of SUBTABLE.
85           If ADD_HEADERS is true, the returned table also includes any header
86           columns in SUBTABLE.
87
88         - If AXIS is TABLE_VERT, rows Z0 through Z1 (exclusive) of SUBTABLE.
89           If ADD_HEADERS is true, the returned table also includes any header
90           rows in SUBTABLE. */
91 struct table *
92 table_select_slice (struct table *subtable, enum table_axis axis,
93                     int z0, int z1, bool add_headers)
94 {
95   struct table *table;
96   int rect[TABLE_N_AXES][2];
97
98   if (add_headers)
99     {
100       if (z0 == subtable->h[axis][0] && z1 == subtable->h[axis][1])
101         return subtable;
102
103       if (subtable->h[axis][0])
104         table_ref (subtable);
105       if (subtable->h[axis][1])
106         table_ref (subtable);
107     }
108   else
109     {
110       if (z0 == 0 && z1 == subtable->n[axis])
111         return subtable;
112     }
113
114   rect[TABLE_HORZ][0] = 0;
115   rect[TABLE_VERT][0] = 0;
116   rect[TABLE_HORZ][1] = subtable->n[TABLE_HORZ];
117   rect[TABLE_VERT][1] = subtable->n[TABLE_VERT];
118   rect[axis][0] = z0;
119   rect[axis][1] = z1;
120   table = table_select (subtable, rect);
121
122   if (add_headers)
123     {
124       if (subtable->h[axis][0])
125         table = table_paste (
126           table_select_slice (subtable, axis, 0, subtable->h[axis][0],
127                               false),
128           table, axis);
129
130       if (subtable->h[axis][1])
131         table = table_paste (
132           table,
133           table_select_slice (subtable, axis,
134                               subtable->n[axis] - subtable->h[axis][1],
135                               subtable->n[axis], false),
136           axis);
137     }
138
139   return table;
140 }
141
142 /* Takes ownership of TABLE and returns a new table whose contents are columns
143    X0 through X1 (exclusive) of SUBTABLE.  If ADD_HEADERS is true, the
144    returned table also includes any header columns in SUBTABLE. */
145 struct table *
146 table_select_columns (struct table *subtable, int x0, int x1,
147                       bool add_headers)
148 {
149   return table_select_slice (subtable, TABLE_HORZ, x0, x1, add_headers);
150 }
151
152 /* Takes ownership of TABLE and returns a new table whose contents are rows Y0
153    through Y1 (exclusive) of SUBTABLE.  If ADD_HEADERS is true, the returned
154    table also includes any header rows in SUBTABLE. */
155 struct table *
156 table_select_rows (struct table *subtable, int y0, int y1,
157                    bool add_headers)
158 {
159   return table_select_slice (subtable, TABLE_VERT, y0, y1, add_headers);
160 }
161
162 static void
163 table_select_destroy (struct table *ti)
164 {
165   struct table_select *ts = table_select_cast (ti);
166   table_unref (ts->subtable);
167   free (ts);
168 }
169
170 static void
171 table_select_get_cell (const struct table *ti, int x, int y,
172                        struct table_cell *cell)
173 {
174   struct table_select *ts = table_select_cast (ti);
175   int axis;
176
177   table_get_cell (ts->subtable,
178                   x + ts->ofs[TABLE_HORZ],
179                   y + ts->ofs[TABLE_VERT], cell);
180
181   for (axis = 0; axis < TABLE_N_AXES; axis++)
182     {
183       int *d = cell->d[axis];
184       int ofs = ts->ofs[axis];
185
186       d[0] = MAX (d[0] - ofs, 0);
187       d[1] = MIN (d[1] - ofs, ti->n[axis]);
188     }
189 }
190
191 static int
192 table_select_get_rule (const struct table *ti,
193                        enum table_axis axis,
194                        int x, int y)
195 {
196   struct table_select *ts = table_select_cast (ti);
197   return table_get_rule (ts->subtable, axis,
198                          x + ts->ofs[TABLE_HORZ],
199                          y + ts->ofs[TABLE_VERT]);
200 }
201
202 static struct table *
203 table_select_select (struct table *ti, int rect[TABLE_N_AXES][2])
204 {
205   struct table_select *ts = table_select_cast (ti);
206   int axis;
207
208   for (axis = 0; axis < TABLE_N_AXES; axis++)
209     {
210       int h1;
211
212       if (ts->table.h[axis][0] > rect[axis][0])
213         ts->table.h[axis][0] = ts->table.h[axis][0] - rect[axis][0];
214       else
215         ts->table.h[axis][0] = 0;
216
217       h1 = ts->table.n[axis] - ts->table.h[axis][1];
218       if (h1 < rect[axis][1])
219         ts->table.h[axis][1] = rect[axis][1] - h1;
220       else
221         ts->table.h[axis][1] = 0;
222
223       ts->ofs[axis] += rect[axis][0];
224       ts->table.n[axis] = rect[axis][1] - rect[axis][0];
225     }
226   return ti;
227 }
228
229 static const struct table_class table_select_class =
230   {
231     table_select_destroy,
232     table_select_get_cell,
233     table_select_get_rule,
234     NULL,                       /* paste */
235     table_select_select,
236   };