src/ui/gui/psppire-variable.c

   1 /*
   2     PSPPIRE --- A Graphical User Interface for PSPP
   3     Copyright (C) 2004  Free Software Foundation
   4     Written by John Darrington
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19     02110-1301, USA. */
  20
  21 #include <string.h>
  22 #include <stdlib.h>
  23
  24 #include <data/missing-values.h>
  25 #include <data/value-labels.h>
  26 #include <data/format.h>
  27
  28 #include "psppire-variable.h"
  29 #include "psppire-dict.h"
  30
  31
  32
  33 gboolean
  34 psppire_variable_set_name(struct PsppireVariable *pv, const gchar *text)
  35 {
  36   g_return_val_if_fail(pv, FALSE);
  37   g_return_val_if_fail(pv->dict, FALSE);
  38   g_return_val_if_fail(pv->v, FALSE);
  39
  40   if ( !text)
  41     return FALSE;
  42
  43   if ( 0 == strcmp(pv->v->name, text))
  44     return FALSE;
  45
  46   if ( ! psppire_dict_check_name(pv->dict, text, TRUE) )
  47     return FALSE;
  48
  49   dict_rename_var(pv->dict->dict, pv->v, text);
  50
  51   psppire_dict_var_changed(pv->dict, pv->v->index);
  52
  53   return TRUE;
  54 }
  55
  56
  57 gboolean
  58 psppire_variable_set_columns(struct PsppireVariable *pv, gint columns)
  59 {
  60   g_return_val_if_fail(pv, FALSE);
  61   g_return_val_if_fail(pv->dict, FALSE);
  62   g_return_val_if_fail(pv->v, FALSE);
  63
  64   pv->v->display_width = columns;
  65
  66   psppire_dict_var_changed(pv->dict, pv->v->index);
  67
  68   return TRUE;
  69 }
  70
  71 gboolean
  72 psppire_variable_set_label(struct PsppireVariable *pv, const gchar *label)
  73 {
  74   g_return_val_if_fail(pv, FALSE);
  75   g_return_val_if_fail(pv->dict, FALSE);
  76   g_return_val_if_fail(pv->v, FALSE);
  77
  78   g_free(pv->v->label);
  79   pv->v->label = g_strdup(label);
  80
  81   psppire_dict_var_changed(pv->dict, pv->v->index);
  82
  83   return TRUE;
  84 }
  85
  86
  87 gboolean
  88 psppire_variable_set_decimals(struct PsppireVariable *pv, gint decimals)
  89 {
  90   struct fmt_spec fmt;
  91
  92   g_return_val_if_fail(pv, FALSE);
  93   g_return_val_if_fail(pv->dict, FALSE);
  94   g_return_val_if_fail(pv->v, FALSE);
  95
  96   fmt = pv->v->write;
  97
  98   fmt.d = decimals;
  99
 100   return psppire_variable_set_format(pv, &fmt);
 101 }
 102
 103
 104
 105 gboolean
 106 psppire_variable_set_width(struct PsppireVariable *pv, gint width)
 107 {
 108   struct fmt_spec fmt ;
 109   g_return_val_if_fail(pv, FALSE);
 110   g_return_val_if_fail(pv->dict, FALSE);
 111   g_return_val_if_fail(pv->v, FALSE);
 112
 113   fmt = pv->v->write;
 114
 115   fmt.w = width;
 116
 117   if ( pv->v->type == ALPHA )
 118     pv->v->width = width;
 119
 120   return psppire_variable_set_format(pv, &fmt);
 121 }
 122
 123
 124 gboolean
 125 psppire_variable_set_type(struct PsppireVariable *pv, int type)
 126 {
 127   g_return_val_if_fail(pv, FALSE);
 128   g_return_val_if_fail(pv->dict, FALSE);
 129   g_return_val_if_fail(pv->v, FALSE);
 130
 131   pv->v->type = type;
 132
 133   if ( type == NUMERIC )
 134     pv->v->width = 0;
 135
 136   psppire_dict_var_changed(pv->dict, pv->v->index);
 137   return TRUE;
 138 }
 139
 140
 141 gboolean
 142 psppire_variable_set_format(struct PsppireVariable *pv, struct fmt_spec *fmt)
 143 {
 144   g_return_val_if_fail(pv, FALSE);
 145   g_return_val_if_fail(pv->dict, FALSE);
 146   g_return_val_if_fail(pv->v, FALSE);
 147
 148   if ( check_output_specifier(fmt, false)
 149        &&
 150        check_specifier_type(fmt, pv->v->type, false)
 151        &&
 152        check_specifier_width(fmt, pv->v->width, false)
 153        )
 154     {
 155       pv->v->write = pv->v->print = *fmt;
 156       psppire_dict_var_changed(pv->dict, pv->v->index);
 157       return TRUE;
 158     }
 159
 160   return FALSE;
 161 }
 162
 163
 164 gboolean
 165 psppire_variable_set_value_labels(const struct PsppireVariable *pv,
 166                                const struct val_labs *vls)
 167 {
 168   g_return_val_if_fail(pv, FALSE);
 169   g_return_val_if_fail(pv->dict, FALSE);
 170   g_return_val_if_fail(pv->v, FALSE);
 171
 172   val_labs_destroy(pv->v->val_labs);
 173   pv->v->val_labs = val_labs_copy(vls);
 174
 175   psppire_dict_var_changed(pv->dict, pv->v->index);
 176   return TRUE;
 177 }
 178
 179 gboolean
 180 psppire_variable_set_missing(const struct PsppireVariable *pv,
 181                           const struct missing_values *miss)
 182 {
 183   g_return_val_if_fail(pv, FALSE);
 184   g_return_val_if_fail(pv->dict, FALSE);
 185   g_return_val_if_fail(pv->v, FALSE);
 186
 187   mv_copy(&pv->v->miss, miss);
 188
 189   psppire_dict_var_changed(pv->dict, pv->v->index);
 190   return TRUE;
 191 }
 192
 193 gboolean
 194 psppire_variable_set_write_spec(const struct PsppireVariable *pv, struct fmt_spec fmt)
 195 {
 196   g_return_val_if_fail(pv, FALSE);
 197   g_return_val_if_fail(pv->v, FALSE);
 198
 199   pv->v->write = fmt;
 200
 201   psppire_dict_var_changed(pv->dict, pv->v->index);
 202   return TRUE;
 203 }
 204
 205 gboolean
 206 psppire_variable_set_print_spec(const struct PsppireVariable *pv, struct fmt_spec fmt)
 207 {
 208   g_return_val_if_fail(pv, FALSE);
 209   g_return_val_if_fail(pv->v, FALSE);
 210
 211   pv->v->print = fmt;
 212
 213   psppire_dict_var_changed(pv->dict, pv->v->index);
 214   return TRUE;
 215 }
 216
 217
 218
 219 gboolean
 220 psppire_variable_set_alignment(struct PsppireVariable *pv, gint align)
 221 {
 222   g_return_val_if_fail(pv, FALSE);
 223   g_return_val_if_fail(pv->dict, FALSE);
 224   g_return_val_if_fail(pv->v, FALSE);
 225
 226   pv->v->alignment = align;
 227
 228   psppire_dict_var_changed(pv->dict, pv->v->index);
 229   return TRUE;
 230 }
 231
 232
 233 gboolean
 234 psppire_variable_set_measure(struct PsppireVariable *pv, gint measure)
 235 {
 236   g_return_val_if_fail(pv, FALSE);
 237   g_return_val_if_fail(pv->dict, FALSE);
 238   g_return_val_if_fail(pv->v, FALSE);
 239
 240   pv->v->measure = measure + 1;
 241
 242   psppire_dict_var_changed(pv->dict, pv->v->index);
 243   return TRUE;
 244 }
 245
 246
 247 const struct fmt_spec *
 248 psppire_variable_get_write_spec(const struct PsppireVariable *pv)
 249 {
 250   g_return_val_if_fail(pv, NULL);
 251   g_return_val_if_fail(pv->v, NULL);
 252
 253
 254   return &pv->v->write;
 255 }
 256
 257
 258 const gchar *
 259 psppire_variable_get_name(const struct PsppireVariable *pv)
 260 {
 261   g_return_val_if_fail(pv, NULL);
 262   g_return_val_if_fail(pv->v, NULL);
 263
 264   return pv->v->name;
 265 }
 266
 267
 268 gint
 269 psppire_variable_get_columns(const struct PsppireVariable *pv)
 270 {
 271   g_return_val_if_fail(pv, -1);
 272   g_return_val_if_fail(pv->v, -1);
 273
 274   return pv->v->display_width;
 275 }
 276
 277
 278
 279 const gchar *
 280 psppire_variable_get_label(const struct PsppireVariable *pv)
 281 {
 282   g_return_val_if_fail(pv, NULL);
 283   g_return_val_if_fail(pv->v, NULL);
 284
 285   return pv->v->label;
 286 }
 287
 288
 289 const struct missing_values *
 290 psppire_variable_get_missing(const struct PsppireVariable *pv)
 291 {
 292   g_return_val_if_fail(pv, NULL);
 293   g_return_val_if_fail(pv->v, NULL);
 294
 295   return &pv->v->miss;
 296 }
 297
 298
 299 const struct val_labs *
 300 psppire_variable_get_value_labels(const struct PsppireVariable *pv)
 301 {
 302   g_return_val_if_fail(pv, NULL);
 303   g_return_val_if_fail(pv->v, NULL);
 304
 305   return pv->v->val_labs;
 306 }
 307
 308
 309 gint
 310 psppire_variable_get_alignment(const struct PsppireVariable *pv)
 311 {
 312   g_return_val_if_fail(pv, -1);
 313   g_return_val_if_fail(pv->v, -1);
 314
 315   return pv->v->alignment;
 316 }
 317
 318
 319
 320 gint
 321 psppire_variable_get_measure(const struct PsppireVariable *pv)
 322 {
 323   g_return_val_if_fail(pv, -1);
 324   g_return_val_if_fail(pv->v, -1);
 325
 326   return pv->v->measure - 1;
 327 }
 328
 329 gint
 330 psppire_variable_get_type(const struct PsppireVariable *pv)
 331 {
 332   g_return_val_if_fail(pv, -1);
 333   g_return_val_if_fail(pv->v, -1);
 334
 335   return pv->v->type;
 336 }
 337
 338
 339 gint
 340 psppire_variable_get_width(const struct PsppireVariable *pv)
 341 {
 342   g_return_val_if_fail(pv, -1);
 343   g_return_val_if_fail(pv->v, -1);
 344
 345   return pv->v->width;
 346 }
 347
 348
 349 gint
 350 psppire_variable_get_fv(const struct PsppireVariable *pv)
 351 {
 352   g_return_val_if_fail(pv, -1);
 353   g_return_val_if_fail(pv->v, -1);
 354
 355   return pv->v->fv;
 356 }
 357
 358
 359
 360 gint
 361 psppire_variable_get_index(const struct PsppireVariable *pv)
 362 {
 363   g_return_val_if_fail(pv, -1);
 364   g_return_val_if_fail(pv->v, -1);
 365
 366   return pv->v->index;
 367 }
 368