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 "missing-values.h"
  25 #include "value-labels.h"
  26 #include "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   g_return_val_if_fail(pv, FALSE);
  91   g_return_val_if_fail(pv->dict, FALSE);
  92   g_return_val_if_fail(pv->v, FALSE);
  93
  94   struct fmt_spec fmt = pv->v->write;
  95
  96   fmt.d = decimals;
  97
  98   return psppire_variable_set_format(pv, &fmt);
  99 }
 100
 101
 102
 103 gboolean
 104 psppire_variable_set_width(struct PsppireVariable *pv, gint width)
 105 {
 106   g_return_val_if_fail(pv, FALSE);
 107   g_return_val_if_fail(pv->dict, FALSE);
 108   g_return_val_if_fail(pv->v, FALSE);
 109
 110   struct fmt_spec fmt = pv->v->write;
 111
 112   fmt.w = width;
 113
 114   if ( pv->v->type == ALPHA )
 115     pv->v->width = width;
 116
 117   return psppire_variable_set_format(pv, &fmt);
 118 }
 119
 120
 121 gboolean
 122 psppire_variable_set_type(struct PsppireVariable *pv, int type)
 123 {
 124   g_return_val_if_fail(pv, FALSE);
 125   g_return_val_if_fail(pv->dict, FALSE);
 126   g_return_val_if_fail(pv->v, FALSE);
 127
 128   pv->v->type = type;
 129
 130   if ( type == NUMERIC )
 131     pv->v->width = 0;
 132
 133   psppire_dict_var_changed(pv->dict, pv->v->index);
 134   return TRUE;
 135 }
 136
 137
 138 gboolean
 139 psppire_variable_set_format(struct PsppireVariable *pv, struct fmt_spec *fmt)
 140 {
 141   g_return_val_if_fail(pv, FALSE);
 142   g_return_val_if_fail(pv->dict, FALSE);
 143   g_return_val_if_fail(pv->v, FALSE);
 144
 145   if ( check_output_specifier(fmt, false)
 146        &&
 147        check_specifier_type(fmt, pv->v->type, false)
 148        &&
 149        check_specifier_width(fmt, pv->v->width, false)
 150        )
 151     {
 152       pv->v->write = pv->v->print = *fmt;
 153       psppire_dict_var_changed(pv->dict, pv->v->index);
 154       return TRUE;
 155     }
 156
 157   return FALSE;
 158 }
 159
 160
 161 gboolean
 162 psppire_variable_set_value_labels(const struct PsppireVariable *pv,
 163                                const struct val_labs *vls)
 164 {
 165   g_return_val_if_fail(pv, FALSE);
 166   g_return_val_if_fail(pv->dict, FALSE);
 167   g_return_val_if_fail(pv->v, FALSE);
 168
 169   val_labs_destroy(pv->v->val_labs);
 170   pv->v->val_labs = val_labs_copy(vls);
 171
 172   psppire_dict_var_changed(pv->dict, pv->v->index);
 173   return TRUE;
 174 }
 175
 176 gboolean
 177 psppire_variable_set_missing(const struct PsppireVariable *pv,
 178                           const struct missing_values *miss)
 179 {
 180   g_return_val_if_fail(pv, FALSE);
 181   g_return_val_if_fail(pv->dict, FALSE);
 182   g_return_val_if_fail(pv->v, FALSE);
 183
 184   mv_copy(&pv->v->miss, miss);
 185
 186   psppire_dict_var_changed(pv->dict, pv->v->index);
 187   return TRUE;
 188 }
 189
 190 gboolean
 191 psppire_variable_set_write_spec(const struct PsppireVariable *pv, struct fmt_spec fmt)
 192 {
 193   g_return_val_if_fail(pv, FALSE);
 194   g_return_val_if_fail(pv->v, FALSE);
 195
 196   pv->v->write = fmt;
 197
 198   psppire_dict_var_changed(pv->dict, pv->v->index);
 199   return TRUE;
 200 }
 201
 202 gboolean
 203 psppire_variable_set_print_spec(const struct PsppireVariable *pv, struct fmt_spec fmt)
 204 {
 205   g_return_val_if_fail(pv, FALSE);
 206   g_return_val_if_fail(pv->v, FALSE);
 207
 208   pv->v->print = fmt;
 209
 210   psppire_dict_var_changed(pv->dict, pv->v->index);
 211   return TRUE;
 212 }
 213
 214
 215
 216 gboolean
 217 psppire_variable_set_alignment(struct PsppireVariable *pv, gint align)
 218 {
 219   g_return_val_if_fail(pv, FALSE);
 220   g_return_val_if_fail(pv->dict, FALSE);
 221   g_return_val_if_fail(pv->v, FALSE);
 222
 223   pv->v->alignment = align;
 224
 225   psppire_dict_var_changed(pv->dict, pv->v->index);
 226   return TRUE;
 227 }
 228
 229
 230 gboolean
 231 psppire_variable_set_measure(struct PsppireVariable *pv, gint measure)
 232 {
 233   g_return_val_if_fail(pv, FALSE);
 234   g_return_val_if_fail(pv->dict, FALSE);
 235   g_return_val_if_fail(pv->v, FALSE);
 236
 237   pv->v->measure = measure + 1;
 238
 239   psppire_dict_var_changed(pv->dict, pv->v->index);
 240   return TRUE;
 241 }
 242
 243
 244 const struct fmt_spec *
 245 psppire_variable_get_write_spec(const struct PsppireVariable *pv)
 246 {
 247   g_return_val_if_fail(pv, NULL);
 248   g_return_val_if_fail(pv->v, NULL);
 249
 250
 251   return &pv->v->write;
 252 }
 253
 254
 255 const gchar *
 256 psppire_variable_get_name(const struct PsppireVariable *pv)
 257 {
 258   g_return_val_if_fail(pv, NULL);
 259   g_return_val_if_fail(pv->v, NULL);
 260
 261   return pv->v->name;
 262 }
 263
 264
 265 gint
 266 psppire_variable_get_columns(const struct PsppireVariable *pv)
 267 {
 268   g_return_val_if_fail(pv, -1);
 269   g_return_val_if_fail(pv->v, -1);
 270
 271   return pv->v->display_width;
 272 }
 273
 274
 275
 276 const gchar *
 277 psppire_variable_get_label(const struct PsppireVariable *pv)
 278 {
 279   g_return_val_if_fail(pv, NULL);
 280   g_return_val_if_fail(pv->v, NULL);
 281
 282   return pv->v->label;
 283 }
 284
 285
 286 const struct missing_values *
 287 psppire_variable_get_missing(const struct PsppireVariable *pv)
 288 {
 289   g_return_val_if_fail(pv, NULL);
 290   g_return_val_if_fail(pv->v, NULL);
 291
 292   return &pv->v->miss;
 293 }
 294
 295
 296 const struct val_labs *
 297 psppire_variable_get_value_labels(const struct PsppireVariable *pv)
 298 {
 299   g_return_val_if_fail(pv, NULL);
 300   g_return_val_if_fail(pv->v, NULL);
 301
 302   return pv->v->val_labs;
 303 }
 304
 305
 306 gint
 307 psppire_variable_get_alignment(const struct PsppireVariable *pv)
 308 {
 309   g_return_val_if_fail(pv, -1);
 310   g_return_val_if_fail(pv->v, -1);
 311
 312   return pv->v->alignment;
 313 }
 314
 315
 316
 317 gint
 318 psppire_variable_get_measure(const struct PsppireVariable *pv)
 319 {
 320   g_return_val_if_fail(pv, -1);
 321   g_return_val_if_fail(pv->v, -1);
 322
 323   return pv->v->measure - 1;
 324 }
 325
 326 gint
 327 psppire_variable_get_type(const struct PsppireVariable *pv)
 328 {
 329   g_return_val_if_fail(pv, -1);
 330   g_return_val_if_fail(pv->v, -1);
 331
 332   return pv->v->type;
 333 }
 334
 335
 336 gint
 337 psppire_variable_get_width(const struct PsppireVariable *pv)
 338 {
 339   g_return_val_if_fail(pv, -1);
 340   g_return_val_if_fail(pv->v, -1);
 341
 342   return pv->v->width;
 343 }
 344
 345 gint
 346 psppire_variable_get_index(const struct PsppireVariable *pv)
 347 {
 348   g_return_val_if_fail(pv, -1);
 349   g_return_val_if_fail(pv->v, -1);
 350
 351   return pv->v->fv;
 352 }
 353