← Back to branch summary

~ubuntu-branches/ubuntu/karmic/kst/karmic

« back to all changes in this revision

Viewing changes to kst/kst/extensions/js/bind_datamatrix.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-06-30 19:11:30 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060630191130-acumuar75bz4puty
Tags: 1.2.1-1ubuntu1
Merge from debian unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
kst/kst/extensions/js/bind_datamatrix.cpp
 
1
/***************************************************************************
 
2
                             bind_datamatrix.cpp
 
3
                             -------------------
 
4
    begin                : Jul 27 2005
 
5
    copyright            : (C) 2005 The University of Toronto
 
6
    email                :
 
7
 ***************************************************************************/
 
8
 
 
9
/***************************************************************************
 
10
 *                                                                         *
 
11
 *   This program is free software; you can redistribute it and/or modify  *
 
12
 *   it under the terms of the GNU General Public License as published by  *
 
13
 *   the Free Software Foundation; either version 2 of the License, or     *
 
14
 *   (at your option) any later version.                                   *
 
15
 *                                                                         *
 
16
 ***************************************************************************/
 
17
 
 
18
#include "bind_datamatrix.h"
 
19
#include "bind_datasource.h"
 
20
 
 
21
#include <kstdatasource.h>
 
22
#include <kstdatacollection.h>
 
23
 
 
24
#include <kdebug.h>
 
25
 
 
26
KstBindDataMatrix::KstBindDataMatrix(KJS::ExecState *exec, KstRMatrixPtr v)
 
27
: KstBindMatrix(exec, v.data(), "DataMatrix") {
 
28
  KJS::Object o(this);
 
29
  addBindings(exec, o);
 
30
}
 
31
 
 
32
 
 
33
KstBindDataMatrix::KstBindDataMatrix(KJS::ExecState *exec, KJS::Object *globalObject)
 
34
: KstBindMatrix(exec, globalObject, "DataMatrix") {
 
35
  KJS::Object o(this);
 
36
  addBindings(exec, o);
 
37
}
 
38
 
 
39
 
 
40
KstBindDataMatrix::KstBindDataMatrix(int id)
 
41
: KstBindMatrix(id, "DataMatrix Method") {
 
42
}
 
43
 
 
44
 
 
45
KstBindDataMatrix::~KstBindDataMatrix() {
 
46
}
 
47
 
 
48
 
 
49
inline int d2i(double x) {
 
50
    return int(floor(x+0.5));
 
51
}
 
52
 
 
53
 
 
54
KJS::Object KstBindDataMatrix::construct(KJS::ExecState *exec, const KJS::List& args) {
 
55
  KstRMatrixPtr v;
 
56
 
 
57
  KstDataSourcePtr dp = extractDataSource(exec, args[0]);
 
58
  // Constructor: DataMatrix(DataSource, field)
 
59
  if (args.size() == 2) {
 
60
    if (args[1].type() != KJS::StringType) {
 
61
      KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
62
      exec->setException(eobj);
 
63
      return KJS::Object();
 
64
    }
 
65
 
 
66
    QString field = args[1].toString(exec).qstring();
 
67
 
 
68
    v = new KstRMatrix(dp, field, QString::null, 0, 0, -1, -1, false, false, -1);
 
69
    KST::addMatrixToList(KstMatrixPtr(v));
 
70
  }
 
71
 
 
72
  // Constructor: DataMatrix(DataSource, field, xStart, yStart, xCount, yCount)
 
73
  if (args.size() == 6) {
 
74
    if (args[1].type() != KJS::StringType ||
 
75
        args[2].type() != KJS::NumberType ||
 
76
        args[3].type() != KJS::NumberType ||
 
77
        args[4].type() != KJS::NumberType ||
 
78
        args[5].type() != KJS::NumberType) {
 
79
      KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
80
      exec->setException(eobj);
 
81
      return KJS::Object();
 
82
    }
 
83
 
 
84
    QString field = args[1].toString(exec).qstring();
 
85
    int xStart = d2i(args[2].toNumber(exec));
 
86
    int yStart = d2i(args[3].toNumber(exec));
 
87
    int xCount = d2i(args[4].toNumber(exec));
 
88
    int yCount = d2i(args[5].toNumber(exec));
 
89
 
 
90
    v = new KstRMatrix(dp, field, QString::null, xStart, yStart, xCount, yCount,false, false, -1);
 
91
    KST::addMatrixToList(KstMatrixPtr(v));
 
92
  }
 
93
 
 
94
  // Constructor: DataMatrix(DataSource, field, xStart, yStart, xCount, yCount, skip)
 
95
  if (args.size() == 7) {
 
96
    if (args[1].type() != KJS::StringType ||
 
97
        args[2].type() != KJS::NumberType ||
 
98
        args[3].type() != KJS::NumberType ||
 
99
        args[4].type() != KJS::NumberType ||
 
100
        args[5].type() != KJS::NumberType ||
 
101
        args[6].type() != KJS::NumberType) {
 
102
      KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
103
      exec->setException(eobj);
 
104
      return KJS::Object();
 
105
    }
 
106
 
 
107
    QString field = args[1].toString(exec).qstring();
 
108
    int xStart = d2i(args[2].toNumber(exec));
 
109
    int yStart = d2i(args[3].toNumber(exec));
 
110
    int xCount = d2i(args[4].toNumber(exec));
 
111
    int yCount = d2i(args[5].toNumber(exec));
 
112
    int skip = d2i(args[6].toNumber(exec));
 
113
 
 
114
    v = new KstRMatrix(dp, field, QString::null, xStart, yStart, xCount, yCount, false, true, skip);
 
115
    KST::addMatrixToList(KstMatrixPtr(v));
 
116
  }
 
117
 
 
118
 
 
119
  // Constructor: DataMatrix(DataSource, field, xStart, yStart, xCount, yCount, skip, ave)
 
120
  if (args.size() == 8) {
 
121
    if (args[1].type() != KJS::StringType ||
 
122
        args[2].type() != KJS::NumberType ||
 
123
        args[3].type() != KJS::NumberType ||
 
124
        args[4].type() != KJS::NumberType ||
 
125
        args[5].type() != KJS::NumberType ||
 
126
        args[6].type() != KJS::NumberType ||
 
127
        args[7].type() != KJS::BooleanType) {
 
128
      KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
129
      exec->setException(eobj);
 
130
      return KJS::Object();
 
131
    }
 
132
 
 
133
    QString field = args[1].toString(exec).qstring();
 
134
    int xStart = d2i(args[2].toNumber(exec));
 
135
    int yStart = d2i(args[3].toNumber(exec));
 
136
    int xCount = d2i(args[4].toNumber(exec));
 
137
    int yCount = d2i(args[5].toNumber(exec));
 
138
    int skip = d2i(args[6].toNumber(exec));
 
139
    bool ave = d2i(args[7].toBoolean(exec));
 
140
 
 
141
    v = new KstRMatrix(dp, field, QString::null, xStart, yStart, xCount, yCount, ave, true, skip);
 
142
    KST::addMatrixToList(KstMatrixPtr(v));
 
143
  }
 
144
 
 
145
  if (!v) {
 
146
    KJS::Object eobj = KJS::Error::create(exec, KJS::SyntaxError);
 
147
    exec->setException(eobj);
 
148
    return KJS::Object();
 
149
  }
 
150
 
 
151
  return KJS::Object(new KstBindDataMatrix(exec, v));
 
152
}
 
153
 
 
154
 
 
155
struct DataMatrixBindings {
 
156
  const char *name;
 
157
  KJS::Value (KstBindDataMatrix::*method)(KJS::ExecState*, const KJS::List&);
 
158
};
 
159
 
 
160
 
 
161
struct DataMatrixProperties {
 
162
  const char *name;
 
163
  void (KstBindDataMatrix::*set)(KJS::ExecState*, const KJS::Value&);
 
164
  KJS::Value (KstBindDataMatrix::*get)(KJS::ExecState*) const;
 
165
};
 
166
 
 
167
 
 
168
static DataMatrixBindings dataMatrixBindings[] = {
 
169
  { "changeFile", &KstBindDataMatrix::changeFile },
 
170
  { "change", &KstBindDataMatrix::change },
 
171
  { "reload", &KstBindDataMatrix::reload },
 
172
  { 0L, 0L }
 
173
};
 
174
 
 
175
 
 
176
static DataMatrixProperties dataMatrixProperties[] = {
 
177
  { "valid", 0L, &KstBindDataMatrix::valid },
 
178
  { "skip", 0L, &KstBindDataMatrix::skip },
 
179
  { "boxcar", 0L, &KstBindDataMatrix::boxcar },
 
180
  { "xReadToEnd", 0L, &KstBindDataMatrix::xReadToEnd },
 
181
  { "yReadToEnd", 0L, &KstBindDataMatrix::yReadToEnd },
 
182
  { "xCountFromEnd", 0L, &KstBindDataMatrix::xCountFromEnd },
 
183
  { "yCountFromEnd", 0L, &KstBindDataMatrix::yCountFromEnd },
 
184
  { "skipLength", 0L, &KstBindDataMatrix::skipLength },
 
185
  { "field", 0L, &KstBindDataMatrix::field },
 
186
  { "dataSource", 0L, &KstBindDataMatrix::dataSource },
 
187
  { 0L, 0L, 0L }
 
188
};
 
189
 
 
190
 
 
191
KJS::ReferenceList KstBindDataMatrix::propList(KJS::ExecState *exec, bool recursive) {
 
192
  KJS::ReferenceList rc = KstBindMatrix::propList(exec, recursive);
 
193
 
 
194
  for (int i = 0; dataMatrixProperties[i].name; ++i) {
 
195
    rc.append(KJS::Reference(this, KJS::Identifier(dataMatrixProperties[i].name)));
 
196
  }
 
197
 
 
198
  return rc;
 
199
}
 
200
 
 
201
 
 
202
bool KstBindDataMatrix::hasProperty(KJS::ExecState *exec, const KJS::Identifier& propertyName) const {
 
203
  QString prop = propertyName.qstring();
 
204
  for (int i = 0; dataMatrixProperties[i].name; ++i) {
 
205
    if (prop == dataMatrixProperties[i].name) {
 
206
      return true;
 
207
    }
 
208
  }
 
209
 
 
210
  return KstBindMatrix::hasProperty(exec, propertyName);
 
211
}
 
212
 
 
213
 
 
214
void KstBindDataMatrix::put(KJS::ExecState *exec, const KJS::Identifier& propertyName, const KJS::Value& value, int attr) {
 
215
  if (!_d) {
 
216
    KstBindMatrix::put(exec, propertyName, value, attr);
 
217
    return;
 
218
  }
 
219
 
 
220
  QString prop = propertyName.qstring();
 
221
 
 
222
  for (int i = 0; dataMatrixProperties[i].name; ++i) {
 
223
    if (prop == dataMatrixProperties[i].name) {
 
224
      if (!dataMatrixProperties[i].set) {
 
225
        break;
 
226
      }
 
227
      (this->*dataMatrixProperties[i].set)(exec, value);
 
228
      return;
 
229
    }
 
230
  }
 
231
 
 
232
  KstBindMatrix::put(exec, propertyName, value, attr);
 
233
}
 
234
 
 
235
 
 
236
KJS::Value KstBindDataMatrix::get(KJS::ExecState *exec, const KJS::Identifier& propertyName) const {
 
237
  if (!_d) {
 
238
    return KstBindMatrix::get(exec, propertyName);
 
239
  }
 
240
 
 
241
  QString prop = propertyName.qstring();
 
242
  for (int i = 0; dataMatrixProperties[i].name; ++i) {
 
243
    if (prop == dataMatrixProperties[i].name) {
 
244
      if (!dataMatrixProperties[i].get) {
 
245
        break;
 
246
      }
 
247
      return (this->*dataMatrixProperties[i].get)(exec);
 
248
    }
 
249
  }
 
250
 
 
251
  return KstBindMatrix::get(exec, propertyName);
 
252
}
 
253
 
 
254
 
 
255
KJS::Value KstBindDataMatrix::call(KJS::ExecState *exec, KJS::Object& self, const KJS::List& args) {
 
256
  int id = this->id();
 
257
  if (id <= 0) {
 
258
    KJS::Object eobj = KJS::Error::create(exec, KJS::GeneralError);
 
259
    exec->setException(eobj);
 
260
    return KJS::Undefined();
 
261
  }
 
262
 
 
263
  int start = KstBindMatrix::methodCount();
 
264
  if (id > start) {
 
265
    KstBindDataMatrix *imp = dynamic_cast<KstBindDataMatrix*>(self.imp());
 
266
    if (!imp) {
 
267
      KJS::Object eobj = KJS::Error::create(exec, KJS::GeneralError);
 
268
      exec->setException(eobj);
 
269
      return KJS::Undefined();
 
270
    }
 
271
 
 
272
    return (imp->*dataMatrixBindings[id - start - 1].method)(exec, args);
 
273
  }
 
274
 
 
275
  return KstBindMatrix::call(exec, self, args);
 
276
}
 
277
 
 
278
 
 
279
void KstBindDataMatrix::addBindings(KJS::ExecState *exec, KJS::Object& obj) {
 
280
  int start = KstBindMatrix::methodCount();
 
281
  for (int i = 0; dataMatrixBindings[i].name != 0L; ++i) {
 
282
    KJS::Object o = KJS::Object(new KstBindDataMatrix(i + start + 1));
 
283
    obj.put(exec, dataMatrixBindings[i].name, o, KJS::Function);
 
284
  }
 
285
}
 
286
 
 
287
 
 
288
#define makeDataMatrix(X) dynamic_cast<KstRMatrix*>(const_cast<KstObject*>(X.data()))
 
289
 
 
290
KJS::Value KstBindDataMatrix::reload(KJS::ExecState *exec, const KJS::List& args) {
 
291
  Q_UNUSED(args)
 
292
  KstRMatrixPtr v = makeDataMatrix(_d);
 
293
  if (!v) {
 
294
    KJS::Object eobj = KJS::Error::create(exec, KJS::GeneralError);
 
295
    exec->setException(eobj);
 
296
    return KJS::Undefined();
 
297
  }
 
298
  KstWriteLocker wl(v);
 
299
  v->reload();
 
300
  return KJS::Undefined();
 
301
}
 
302
 
 
303
 
 
304
KJS::Value KstBindDataMatrix::changeFile(KJS::ExecState *exec, const KJS::List& args) {
 
305
  KstRMatrixPtr v = makeDataMatrix(_d);
 
306
  if (!v) {
 
307
    KJS::Object eobj = KJS::Error::create(exec, KJS::GeneralError);
 
308
    exec->setException(eobj);
 
309
    return KJS::Undefined();
 
310
  }
 
311
 
 
312
  if (args.size() != 1) {
 
313
    KJS::Object eobj = KJS::Error::create(exec, KJS::SyntaxError, "Requires exactly one argument.");
 
314
    exec->setException(eobj);
 
315
    return KJS::Undefined();
 
316
  }
 
317
 
 
318
  if (args[0].type() != KJS::ObjectType) {
 
319
    KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
320
    exec->setException(eobj);
 
321
    return KJS::Undefined();
 
322
  }
 
323
 
 
324
  KstBindDataSource *imp = dynamic_cast<KstBindDataSource*>(args[0].toObject(exec).imp());
 
325
  if (!imp) {
 
326
    KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
327
    exec->setException(eobj);
 
328
    return KJS::Undefined();
 
329
  }
 
330
 
 
331
#define makeSource(X) dynamic_cast<KstDataSource*>(const_cast<KstObject*>(X.data()))
 
332
  KstDataSourcePtr s = makeSource(imp->_d);
 
333
  if (!s) {
 
334
    KJS::Object eobj = KJS::Error::create(exec, KJS::GeneralError);
 
335
    exec->setException(eobj);
 
336
    return KJS::Undefined();
 
337
  }
 
338
  v->writeLock();
 
339
  s->writeLock();
 
340
  v->changeFile(s);
 
341
  s->writeUnlock();
 
342
  v->writeUnlock();
 
343
#undef makeSource
 
344
 
 
345
  return KJS::Undefined();
 
346
}
 
347
 
 
348
 
 
349
KJS::Value KstBindDataMatrix::change(KJS::ExecState *exec, const KJS::List& args) {
 
350
  KstRMatrixPtr v = makeDataMatrix(_d);
 
351
  if (!v) {
 
352
    KJS::Object eobj = KJS::Error::create(exec, KJS::GeneralError);
 
353
    exec->setException(eobj);
 
354
    return KJS::Undefined();
 
355
  }
 
356
 
 
357
  if (args.size() > 3) {
 
358
    if (args[0].type() != KJS::NumberType ||
 
359
        args[1].type() != KJS::NumberType) {
 
360
      KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
361
      exec->setException(eobj);
 
362
      return KJS::Undefined();
 
363
    }
 
364
 
 
365
    KstWriteLocker wl(v);
 
366
    int xStart = d2i(args[0].toNumber(exec));
 
367
    int yStart = d2i(args[1].toNumber(exec));
 
368
    int xCount = d2i(args[2].toNumber(exec));
 
369
    int yCount = d2i(args[3].toNumber(exec));
 
370
    int skip = v->doSkip() ? v->skip() : -1;
 
371
    bool ave = v->doAverage();
 
372
 
 
373
    if (args.size() > 4) {
 
374
      if (args[4].type() != KJS::NumberType) {
 
375
        KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
376
        exec->setException(eobj);
 
377
        return KJS::Undefined();
 
378
      }
 
379
 
 
380
      skip = d2i(args[4].toNumber(exec));
 
381
 
 
382
      if (args.size() > 5) {
 
383
        if (args[5].type() != KJS::BooleanType) {
 
384
          KJS::Object eobj = KJS::Error::create(exec, KJS::TypeError);
 
385
          exec->setException(eobj);
 
386
          return KJS::Undefined();
 
387
        }
 
388
 
 
389
        ave = d2i(args[5].toBoolean(exec));
 
390
      }
 
391
    }
 
392
 
 
393
    v->change(v->dataSource(), v->field(), v->tagName(), xStart, yStart, xCount, yCount, skip, skip >= 0, ave);
 
394
    return KJS::Undefined();
 
395
  }
 
396
 
 
397
  KJS::Object eobj = KJS::Error::create(exec, KJS::SyntaxError);
 
398
  exec->setException(eobj);
 
399
  return KJS::Undefined();
 
400
}
 
401
 
 
402
 
 
403
KJS::Value KstBindDataMatrix::valid(KJS::ExecState *exec) const {
 
404
  Q_UNUSED(exec)
 
405
  KstRMatrixPtr v = makeDataMatrix(_d);
 
406
  KstReadLocker rl(v);
 
407
  return KJS::Boolean(v->isValid());
 
408
}
 
409
 
 
410
 
 
411
KJS::Value KstBindDataMatrix::skip(KJS::ExecState *exec) const {
 
412
  Q_UNUSED(exec)
 
413
  KstRMatrixPtr v = makeDataMatrix(_d);
 
414
  KstReadLocker rl(v);
 
415
  return KJS::Boolean(v->doSkip());
 
416
}
 
417
 
 
418
 
 
419
KJS::Value KstBindDataMatrix::boxcar(KJS::ExecState *exec) const {
 
420
  Q_UNUSED(exec)
 
421
  KstRMatrixPtr v = makeDataMatrix(_d);
 
422
  KstReadLocker rl(v);
 
423
  return KJS::Boolean(v->doAverage());
 
424
}
 
425
 
 
426
 
 
427
KJS::Value KstBindDataMatrix::xReadToEnd(KJS::ExecState *exec) const {
 
428
  Q_UNUSED(exec)
 
429
  KstRMatrixPtr v = makeDataMatrix(_d);
 
430
  KstReadLocker rl(v);
 
431
  return KJS::Boolean(v->xReadToEnd());
 
432
}
 
433
 
 
434
 
 
435
KJS::Value KstBindDataMatrix::yReadToEnd(KJS::ExecState *exec) const {
 
436
  Q_UNUSED(exec)
 
437
  KstRMatrixPtr v = makeDataMatrix(_d);
 
438
  KstReadLocker rl(v);
 
439
  return KJS::Boolean(v->yReadToEnd());
 
440
}
 
441
 
 
442
 
 
443
KJS::Value KstBindDataMatrix::xCountFromEnd(KJS::ExecState *exec) const {
 
444
  Q_UNUSED(exec)
 
445
  KstRMatrixPtr v = makeDataMatrix(_d);
 
446
  KstReadLocker rl(v);
 
447
  return KJS::Boolean(v->xCountFromEnd());
 
448
}
 
449
 
 
450
 
 
451
KJS::Value KstBindDataMatrix::yCountFromEnd(KJS::ExecState *exec) const {
 
452
  Q_UNUSED(exec)
 
453
  KstRMatrixPtr v = makeDataMatrix(_d);
 
454
  KstReadLocker rl(v);
 
455
  return KJS::Boolean(v->yCountFromEnd());
 
456
}
 
457
 
 
458
 
 
459
KJS::Value KstBindDataMatrix::skipLength(KJS::ExecState *exec) const {
 
460
  Q_UNUSED(exec)
 
461
  KstRMatrixPtr v = makeDataMatrix(_d);
 
462
  KstReadLocker rl(v);
 
463
  return KJS::Number(v->skip());
 
464
}
 
465
 
 
466
 
 
467
KJS::Value KstBindDataMatrix::field(KJS::ExecState *exec) const {
 
468
  Q_UNUSED(exec)
 
469
  KstRMatrixPtr v = makeDataMatrix(_d);
 
470
  KstReadLocker rl(v);
 
471
  return KJS::String(v->field());
 
472
}
 
473
 
 
474
 
 
475
KJS::Value KstBindDataMatrix::dataSource(KJS::ExecState *exec) const {
 
476
  KstRMatrixPtr v = makeDataMatrix(_d);
 
477
  KstReadLocker rl(v);
 
478
  KstDataSourcePtr dp = v->dataSource();
 
479
  if (!dp) {
 
480
    return KJS::Undefined();
 
481
  }
 
482
 
 
483
  return KJS::Object(new KstBindDataSource(exec, dp));
 
484
}
 
485
 
 
486
#undef makeDataMatrix
 
487
 
 
488
// vim: ts=2 sw=2 et