← Back to branch summary

~ubuntu-branches/ubuntu/saucy/gnash/saucy-proposed

« back to all changes in this revision

Viewing changes to libcore/asobj/flash/geom/Point_as.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Sindhudweep Narayan Sarkar
  • Date: 2009-10-07 00:06:10 UTC
  • mfrom: (1.1.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20091007000610-mj9rwqe774gizn1j
Tags: 0.8.6-0ubuntu1
https://launchpad.net/bugs/435897
new upstream release 0.8.6 (LP: #435897)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libcore/asobj/flash/geom/Point_as.cpp
21
21
#include "as_object.h" // for inheritance
22
22
#include "log.h"
23
23
#include "fn_call.h"
 
24
#include "Global_as.h"
24
25
#include "smart_ptr.h" // for boost intrusive_ptr
25
26
#include "builtin_function.h" // need builtin_function
26
27
#include "GnashException.h" // for ActionException
27
28
#include "Object.h" // for AS inheritance
28
29
#include "VM.h" // for addStatics
29
 
#include "utility.h" // isFinite
 
30
#include "GnashNumeric.h"
30
31
 
31
32
#include <sstream>
32
33
 
52
53
{
53
54
    int fl=0; // flags...
54
55
 
55
 
    o.init_member("add", new builtin_function(Point_add), fl);
56
 
    o.init_member("clone", new builtin_function(Point_clone), fl);
57
 
    o.init_member("equals", new builtin_function(Point_equals), fl);
58
 
    o.init_member("normalize", new builtin_function(Point_normalize), fl);
59
 
    o.init_member("offset", new builtin_function(Point_offset), fl);
60
 
    o.init_member("subtract", new builtin_function(Point_subtract), fl);
61
 
    o.init_member("toString", new builtin_function(Point_toString), fl);
 
56
    Global_as* gl = getGlobal(o);
 
57
    o.init_member("add", gl->createFunction(Point_add), fl);
 
58
    o.init_member("clone", gl->createFunction(Point_clone), fl);
 
59
    o.init_member("equals", gl->createFunction(Point_equals), fl);
 
60
    o.init_member("normalize", gl->createFunction(Point_normalize), fl);
 
61
    o.init_member("offset", gl->createFunction(Point_offset), fl);
 
62
    o.init_member("subtract", gl->createFunction(Point_subtract), fl);
 
63
    o.init_member("toString", gl->createFunction(Point_toString), fl);
62
64
    o.init_property("length", Point_length_getset, Point_length_getset, fl);
63
65
}
64
66
 
65
67
static void
66
68
attachPointStaticProperties(as_object& o)
67
69
{
68
 
    o.init_member("distance", new builtin_function(Point_distance), 0);
69
 
    o.init_member("interpolate", new builtin_function(Point_interpolate), 0);
70
 
    o.init_member("polar", new builtin_function(Point_polar), 0);
 
70
    Global_as* gl = getGlobal(o);
 
71
    o.init_member("distance", gl->createFunction(Point_distance), 0);
 
72
    o.init_member("interpolate", gl->createFunction(Point_interpolate), 0);
 
73
    o.init_member("polar", gl->createFunction(Point_polar), 0);
71
74
}
72
75
 
73
76
static as_object*
74
77
getPointInterface()
75
78
{
76
 
        static boost::intrusive_ptr<as_object> o;
77
 
 
78
 
        if ( ! o )
79
 
        {
80
 
                // TODO: check if this class should inherit from Object
81
 
                //       or from a different class
82
 
                o = new as_object(getObjectInterface());
83
 
                VM::get().addStatic(o.get());
84
 
 
85
 
                attachPointInterface(*o);
86
 
 
87
 
        }
88
 
 
89
 
        return o.get();
 
79
    static boost::intrusive_ptr<as_object> o;
 
80
 
 
81
    if ( ! o )
 
82
    {
 
83
        // TODO: check if this class should inherit from Object
 
84
        //       or from a different class
 
85
        o = new as_object(getObjectInterface());
 
86
        VM::get().addStatic(o.get());
 
87
 
 
88
        attachPointInterface(*o);
 
89
 
 
90
    }
 
91
 
 
92
    return o.get();
90
93
}
91
94
 
92
95
 
93
96
class Point_as: public as_object
94
97
{
95
98
public:
96
 
        Point_as()
97
 
            :
98
 
            as_object(getPointInterface())
99
 
        {}
100
 
            
 
99
    Point_as()
 
100
        :
 
101
        as_object(getPointInterface())
 
102
    {}
 
103
        
101
104
};
102
105
 
103
106
 
104
107
static as_value
105
108
Point_add(const fn_call& fn)
106
109
{
107
 
        boost::intrusive_ptr<as_object> ptr = ensureType<as_object>(fn.this_ptr);
108
 
 
109
 
        as_value x, y;
110
 
        ptr->get_member(NSV::PROP_X, &x);
111
 
        ptr->get_member(NSV::PROP_Y, &y);
112
 
 
113
 
        as_value x1, y1;
114
 
 
115
 
        if ( ! fn.nargs )
116
 
        {
117
 
                IF_VERBOSE_ASCODING_ERRORS(
118
 
                log_aserror(_("%s: missing arguments"), "Point.add()");
119
 
                );
120
 
        }
121
 
        else
122
 
        {
123
 
                IF_VERBOSE_ASCODING_ERRORS(
124
 
                if ( fn.nargs > 1 )
125
 
                {
126
 
                        std::stringstream ss; fn.dump_args(ss);
127
 
                        log_aserror("Point.add(%s): %s", ss.str(), _("arguments after first discarded"));
128
 
                }
129
 
                );
130
 
                const as_value& arg1 = fn.arg(0);
131
 
                as_object* o = arg1.to_object().get();
132
 
                if ( ! o )
133
 
                {
134
 
                        IF_VERBOSE_ASCODING_ERRORS(
135
 
                        std::stringstream ss; fn.dump_args(ss);
136
 
                        log_aserror("Point.add(%s): %s", ss.str(), _("first argument doesn't cast to object"));
137
 
                        );
138
 
                }
139
 
                else
140
 
                {
141
 
                        if ( ! o->get_member(NSV::PROP_X, &x1) )
142
 
                        {
143
 
                                IF_VERBOSE_ASCODING_ERRORS(
144
 
                                std::stringstream ss; fn.dump_args(ss);
145
 
                                log_aserror("Point.add(%s): %s", ss.str(),
146
 
                                        _("first argument cast to object doesn't contain an 'x' member"));
147
 
                                );
148
 
                        }
149
 
                        if ( ! o->get_member(NSV::PROP_Y, &y1) )
150
 
                        {
151
 
                                IF_VERBOSE_ASCODING_ERRORS(
152
 
                                std::stringstream ss; fn.dump_args(ss);
153
 
                                log_aserror("Point.add(%s): %s", ss.str(),
154
 
                                        _("first argument cast to object doesn't contain an 'y' member"));
155
 
                                );
156
 
                        }
157
 
                }
158
 
        }
159
 
 
160
 
        x.newAdd(x1);
161
 
        y.newAdd(y1);
162
 
 
163
 
        boost::intrusive_ptr<as_object> ret = new Point_as;
164
 
        ret->set_member(NSV::PROP_X, x);
165
 
        ret->set_member(NSV::PROP_Y, y);
166
 
 
167
 
        return as_value(ret.get());
 
110
    boost::intrusive_ptr<as_object> ptr = ensureType<as_object>(fn.this_ptr);
 
111
 
 
112
    as_value x, y;
 
113
    ptr->get_member(NSV::PROP_X, &x);
 
114
    ptr->get_member(NSV::PROP_Y, &y);
 
115
 
 
116
    as_value x1, y1;
 
117
 
 
118
    if ( ! fn.nargs )
 
119
    {
 
120
        IF_VERBOSE_ASCODING_ERRORS(
 
121
        log_aserror(_("%s: missing arguments"), "Point.add()");
 
122
        );
 
123
    }
 
124
    else
 
125
    {
 
126
        IF_VERBOSE_ASCODING_ERRORS(
 
127
        if ( fn.nargs > 1 )
 
128
        {
 
129
            std::stringstream ss; fn.dump_args(ss);
 
130
            log_aserror("Point.add(%s): %s", ss.str(), _("arguments after first discarded"));
 
131
        }
 
132
        );
 
133
        const as_value& arg1 = fn.arg(0);
 
134
        as_object* o = arg1.to_object(*getGlobal(fn)).get();
 
135
        if ( ! o )
 
136
        {
 
137
            IF_VERBOSE_ASCODING_ERRORS(
 
138
            std::stringstream ss; fn.dump_args(ss);
 
139
            log_aserror("Point.add(%s): %s", ss.str(), _("first argument doesn't cast to object"));
 
140
            );
 
141
        }
 
142
        else
 
143
        {
 
144
            if ( ! o->get_member(NSV::PROP_X, &x1) )
 
145
            {
 
146
                IF_VERBOSE_ASCODING_ERRORS(
 
147
                std::stringstream ss; fn.dump_args(ss);
 
148
                log_aserror("Point.add(%s): %s", ss.str(),
 
149
                    _("first argument cast to object doesn't contain an 'x' member"));
 
150
                );
 
151
            }
 
152
            if ( ! o->get_member(NSV::PROP_Y, &y1) )
 
153
            {
 
154
                IF_VERBOSE_ASCODING_ERRORS(
 
155
                std::stringstream ss; fn.dump_args(ss);
 
156
                log_aserror("Point.add(%s): %s", ss.str(),
 
157
                    _("first argument cast to object doesn't contain an 'y' member"));
 
158
                );
 
159
            }
 
160
        }
 
161
    }
 
162
 
 
163
    x.newAdd(x1);
 
164
    y.newAdd(y1);
 
165
 
 
166
    boost::intrusive_ptr<as_object> ret = new Point_as;
 
167
    ret->set_member(NSV::PROP_X, x);
 
168
    ret->set_member(NSV::PROP_Y, y);
 
169
 
 
170
    return as_value(ret.get());
168
171
}
169
172
 
170
173
static as_value
171
174
Point_clone(const fn_call& fn)
172
175
{
173
 
        boost::intrusive_ptr<as_object> ptr = ensureType<as_object>(fn.this_ptr);
174
 
 
175
 
        as_value x, y;
176
 
        ptr->get_member(NSV::PROP_X, &x);
177
 
        ptr->get_member(NSV::PROP_Y, &y);
178
 
 
179
 
        boost::intrusive_ptr<as_object> ret = new Point_as;
180
 
        ret->set_member(NSV::PROP_X, x);
181
 
        ret->set_member(NSV::PROP_Y, y);
182
 
 
183
 
        return as_value(ret.get());
 
176
    boost::intrusive_ptr<as_object> ptr = ensureType<as_object>(fn.this_ptr);
 
177
 
 
178
    as_value x, y;
 
179
    ptr->get_member(NSV::PROP_X, &x);
 
180
    ptr->get_member(NSV::PROP_Y, &y);
 
181
 
 
182
    boost::intrusive_ptr<as_object> ret = new Point_as;
 
183
    ret->set_member(NSV::PROP_X, x);
 
184
    ret->set_member(NSV::PROP_Y, y);
 
185
 
 
186
    return as_value(ret.get());
184
187
}
185
188
 
186
189
static as_value
187
190
Point_equals(const fn_call& fn)
188
191
{
189
 
        boost::intrusive_ptr<as_object> ptr = ensureType<as_object>(fn.this_ptr);
190
 
 
191
 
        if ( ! fn.nargs )
192
 
        {
193
 
                IF_VERBOSE_ASCODING_ERRORS(
194
 
                log_aserror(_("%s: missing arguments"), "Point.equals()");
195
 
                );
196
 
                return as_value(false);
197
 
        }
198
 
 
199
 
        const as_value& arg1 = fn.arg(0);
200
 
        if ( ! arg1.is_object() )
201
 
        {
202
 
                IF_VERBOSE_ASCODING_ERRORS(
203
 
                std::stringstream ss; fn.dump_args(ss);
204
 
                log_aserror("Point.equals(%s): %s", ss.str(), _("First arg must be an object"));
205
 
                );
206
 
                return as_value(false);
207
 
        }
208
 
        as_object* o = arg1.to_object().get();
209
 
        assert(o);
210
 
        if ( ! o->instanceOf(getFlashGeomPointConstructor()) )
211
 
        {
212
 
                IF_VERBOSE_ASCODING_ERRORS(
213
 
                std::stringstream ss; fn.dump_args(ss);
214
 
                log_aserror("Point.equals(%s): %s %s", ss.str(), _("First arg must be an instance of"), "flash.geom.Point");
215
 
                );
216
 
                return as_value(false);
217
 
        }
218
 
 
219
 
        as_value x, y;
220
 
        ptr->get_member(NSV::PROP_X, &x);
221
 
        ptr->get_member(NSV::PROP_Y, &y);
222
 
 
223
 
        as_value x1, y1;
224
 
        o->get_member(NSV::PROP_X, &x1);
225
 
        o->get_member(NSV::PROP_Y, &y1);
226
 
 
227
 
        return as_value(x.equals(x1) && y.equals(y1));
 
192
    boost::intrusive_ptr<as_object> ptr = ensureType<as_object>(fn.this_ptr);
 
193
 
 
194
    if ( ! fn.nargs )
 
195
    {
 
196
        IF_VERBOSE_ASCODING_ERRORS(
 
197
        log_aserror(_("%s: missing arguments"), "Point.equals()");
 
198
        );
 
199
        return as_value(false);
 
200
    }
 
201
 
 
202
    const as_value& arg1 = fn.arg(0);
 
203
    if ( ! arg1.is_object() )
 
204
    {
 
205
        IF_VERBOSE_ASCODING_ERRORS(
 
206
        std::stringstream ss; fn.dump_args(ss);
 
207
        log_aserror("Point.equals(%s): %s", ss.str(),
 
208
            _("First arg must be an object"));
 
209
        );
 
210
        return as_value(false);
 
211
    }
 
212
    as_object* o = arg1.to_object(*getGlobal(fn)).get();
 
213
    assert(o);
 
214
    if ( ! o->instanceOf(getFlashGeomPointConstructor(fn)) )
 
215
    {
 
216
        IF_VERBOSE_ASCODING_ERRORS(
 
217
        std::stringstream ss; fn.dump_args(ss);
 
218
        log_aserror("Point.equals(%s): %s %s", ss.str(),
 
219
            _("First arg must be an instance of"), "flash.geom.Point");
 
220
        );
 
221
        return as_value(false);
 
222
    }
 
223
 
 
224
    as_value x, y;
 
225
    ptr->get_member(NSV::PROP_X, &x);
 
226
    ptr->get_member(NSV::PROP_Y, &y);
 
227
 
 
228
    as_value x1, y1;
 
229
    o->get_member(NSV::PROP_X, &x1);
 
230
    o->get_member(NSV::PROP_Y, &y1);
 
231
 
 
232
    return as_value(x.equals(x1) && y.equals(y1));
228
233
}
229
234
 
230
235
static as_value
231
236
Point_normalize(const fn_call& fn)
232
237
{
233
 
        boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
234
 
 
235
 
        as_value argval;
236
 
 
237
 
        if ( ! fn.nargs )
238
 
        {
239
 
                IF_VERBOSE_ASCODING_ERRORS(
240
 
                log_aserror(_("%s: missing arguments"), "Point.normalize()");
241
 
                );
242
 
                return as_value();
243
 
        }
244
 
        else
245
 
        {
246
 
                IF_VERBOSE_ASCODING_ERRORS(
247
 
                if ( fn.nargs > 1 )
248
 
                {
249
 
                        std::stringstream ss; fn.dump_args(ss);
250
 
                        log_aserror("Point.normalize(%s): %s", ss.str(), _("arguments after first discarded"));
251
 
                }
252
 
                );
253
 
 
254
 
                argval = fn.arg(0);
255
 
        }
256
 
 
257
 
        // newlen may be NaN, and we'd still be updating x/y
258
 
        // see actionscript.all/Point.as
259
 
        double newlen = argval.to_number();
260
 
 
261
 
        as_value xval, yval;
262
 
        ptr->get_member(NSV::PROP_X, &xval);
263
 
        ptr->get_member(NSV::PROP_Y, &yval);
264
 
 
265
 
        double x = xval.to_number();
266
 
        if ( ! utility::isFinite(x) ) return as_value();
267
 
        double y = yval.to_number();
268
 
        if ( ! utility::isFinite(y) ) return as_value();
269
 
 
270
 
        if ( x == 0 && y == 0 ) return as_value();
271
 
 
272
 
        double curlen = std::sqrt(x*x+y*y);
273
 
        double fact = newlen/curlen;
274
 
 
275
 
 
276
 
        xval.set_double( xval.to_number() * fact );
277
 
        yval.set_double( yval.to_number() * fact );
278
 
        ptr->set_member(NSV::PROP_X, xval);
279
 
        ptr->set_member(NSV::PROP_Y, yval);
280
 
 
281
 
        return as_value();
 
238
    boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
 
239
 
 
240
    as_value argval;
 
241
 
 
242
    if ( ! fn.nargs )
 
243
    {
 
244
        IF_VERBOSE_ASCODING_ERRORS(
 
245
        log_aserror(_("%s: missing arguments"), "Point.normalize()");
 
246
        );
 
247
        return as_value();
 
248
    }
 
249
    else
 
250
    {
 
251
        IF_VERBOSE_ASCODING_ERRORS(
 
252
        if ( fn.nargs > 1 )
 
253
        {
 
254
            std::stringstream ss; fn.dump_args(ss);
 
255
            log_aserror("Point.normalize(%s): %s", ss.str(), _("arguments after first discarded"));
 
256
        }
 
257
        );
 
258
 
 
259
        argval = fn.arg(0);
 
260
    }
 
261
 
 
262
    // newlen may be NaN, and we'd still be updating x/y
 
263
    // see actionscript.all/Point.as
 
264
    double newlen = argval.to_number();
 
265
 
 
266
    as_value xval, yval;
 
267
    ptr->get_member(NSV::PROP_X, &xval);
 
268
    ptr->get_member(NSV::PROP_Y, &yval);
 
269
 
 
270
    double x = xval.to_number();
 
271
    if (!isFinite(x)) return as_value();
 
272
    double y = yval.to_number();
 
273
    if (!isFinite(y)) return as_value();
 
274
 
 
275
    if ( x == 0 && y == 0 ) return as_value();
 
276
 
 
277
    double curlen = std::sqrt(x*x+y*y);
 
278
    double fact = newlen/curlen;
 
279
 
 
280
 
 
281
    xval.set_double( xval.to_number() * fact );
 
282
    yval.set_double( yval.to_number() * fact );
 
283
    ptr->set_member(NSV::PROP_X, xval);
 
284
    ptr->set_member(NSV::PROP_Y, yval);
 
285
 
 
286
    return as_value();
282
287
}
283
288
 
284
289
static as_value
285
290
Point_offset(const fn_call& fn)
286
291
{
287
 
        boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
288
 
 
289
 
        as_value x, y;
290
 
        ptr->get_member(NSV::PROP_X, &x);
291
 
        ptr->get_member(NSV::PROP_Y, &y);
292
 
 
293
 
        as_value xoff, yoff;
294
 
 
295
 
        if ( fn.nargs ) {
296
 
                xoff = fn.arg(0);
297
 
                if ( fn.nargs > 1 ) yoff = fn.arg(1);
298
 
        }
299
 
 
300
 
        x.newAdd(xoff);
301
 
        y.newAdd(yoff);
302
 
 
303
 
        ptr->set_member(NSV::PROP_X, x);
304
 
        ptr->set_member(NSV::PROP_Y, y);
305
 
 
306
 
        return as_value();
 
292
    boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
 
293
 
 
294
    as_value x, y;
 
295
    ptr->get_member(NSV::PROP_X, &x);
 
296
    ptr->get_member(NSV::PROP_Y, &y);
 
297
 
 
298
    as_value xoff, yoff;
 
299
 
 
300
    if ( fn.nargs ) {
 
301
        xoff = fn.arg(0);
 
302
        if ( fn.nargs > 1 ) yoff = fn.arg(1);
 
303
    }
 
304
 
 
305
    x.newAdd(xoff);
 
306
    y.newAdd(yoff);
 
307
 
 
308
    ptr->set_member(NSV::PROP_X, x);
 
309
    ptr->set_member(NSV::PROP_Y, y);
 
310
 
 
311
    return as_value();
307
312
}
308
313
 
309
314
static as_value
310
315
Point_subtract(const fn_call& fn)
311
316
{
312
 
        boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
313
 
 
314
 
        as_value x, y;
315
 
        ptr->get_member(NSV::PROP_X, &x);
316
 
        ptr->get_member(NSV::PROP_Y, &y);
317
 
 
318
 
        as_value x1, y1;
319
 
 
320
 
        if ( ! fn.nargs )
321
 
        {
322
 
                IF_VERBOSE_ASCODING_ERRORS(
323
 
                log_aserror(_("%s: missing arguments"), "Point.add()");
324
 
                );
325
 
        }
326
 
        else
327
 
        {
328
 
                IF_VERBOSE_ASCODING_ERRORS(
329
 
                if ( fn.nargs > 1 )
330
 
                {
331
 
                        std::stringstream ss; fn.dump_args(ss);
332
 
                        log_aserror("Point.add(%s): %s", ss.str(), _("arguments after first discarded"));
333
 
                }
334
 
                );
335
 
                const as_value& arg1 = fn.arg(0);
336
 
                as_object* o = arg1.to_object().get();
337
 
                if ( ! o )
338
 
                {
339
 
                        IF_VERBOSE_ASCODING_ERRORS(
340
 
                        std::stringstream ss; fn.dump_args(ss);
341
 
                        log_aserror("Point.add(%s): %s", ss.str(), _("first argument doesn't cast to object"));
342
 
                        );
343
 
                }
344
 
                else
345
 
                {
346
 
                        if ( ! o->get_member(NSV::PROP_X, &x1) )
347
 
                        {
348
 
                                IF_VERBOSE_ASCODING_ERRORS(
349
 
                                std::stringstream ss; fn.dump_args(ss);
350
 
                                log_aserror("Point.add(%s): %s", ss.str(),
351
 
                                        _("first argument casted to object doesn't contain an 'x' member"));
352
 
                                );
353
 
                        }
354
 
                        if ( ! o->get_member(NSV::PROP_Y, &y1) )
355
 
                        {
356
 
                                IF_VERBOSE_ASCODING_ERRORS(
357
 
                                std::stringstream ss; fn.dump_args(ss);
358
 
                                log_aserror("Point.add(%s): %s", ss.str(),
359
 
                                        _("first argument casted to object doesn't contain an 'y' member"));
360
 
                                );
361
 
                        }
362
 
                }
363
 
        }
364
 
 
365
 
        x.set_double(x.to_number() - x1.to_number());
366
 
        y.set_double(y.to_number() - y1.to_number());
367
 
 
368
 
        boost::intrusive_ptr<as_object> ret = new Point_as;
369
 
        ret->set_member(NSV::PROP_X, x);
370
 
        ret->set_member(NSV::PROP_Y, y);
371
 
 
372
 
        return as_value(ret.get());
 
317
    boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
 
318
 
 
319
    as_value x, y;
 
320
    ptr->get_member(NSV::PROP_X, &x);
 
321
    ptr->get_member(NSV::PROP_Y, &y);
 
322
 
 
323
    as_value x1, y1;
 
324
 
 
325
    if ( ! fn.nargs )
 
326
    {
 
327
        IF_VERBOSE_ASCODING_ERRORS(
 
328
        log_aserror(_("%s: missing arguments"), "Point.add()");
 
329
        );
 
330
    }
 
331
    else
 
332
    {
 
333
        IF_VERBOSE_ASCODING_ERRORS(
 
334
        if ( fn.nargs > 1 )
 
335
        {
 
336
            std::stringstream ss; fn.dump_args(ss);
 
337
            log_aserror("Point.add(%s): %s", ss.str(), _("arguments after first discarded"));
 
338
        }
 
339
        );
 
340
        const as_value& arg1 = fn.arg(0);
 
341
        as_object* o = arg1.to_object(*getGlobal(fn)).get();
 
342
        if ( ! o )
 
343
        {
 
344
            IF_VERBOSE_ASCODING_ERRORS(
 
345
            std::stringstream ss; fn.dump_args(ss);
 
346
            log_aserror("Point.add(%s): %s", ss.str(), _("first argument doesn't cast to object"));
 
347
            );
 
348
        }
 
349
        else
 
350
        {
 
351
            if ( ! o->get_member(NSV::PROP_X, &x1) )
 
352
            {
 
353
                IF_VERBOSE_ASCODING_ERRORS(
 
354
                std::stringstream ss; fn.dump_args(ss);
 
355
                log_aserror("Point.add(%s): %s", ss.str(),
 
356
                    _("first argument casted to object doesn't contain an 'x' member"));
 
357
                );
 
358
            }
 
359
            if ( ! o->get_member(NSV::PROP_Y, &y1) )
 
360
            {
 
361
                IF_VERBOSE_ASCODING_ERRORS(
 
362
                std::stringstream ss; fn.dump_args(ss);
 
363
                log_aserror("Point.add(%s): %s", ss.str(),
 
364
                    _("first argument casted to object doesn't contain an 'y' member"));
 
365
                );
 
366
            }
 
367
        }
 
368
    }
 
369
 
 
370
    x.set_double(x.to_number() - x1.to_number());
 
371
    y.set_double(y.to_number() - y1.to_number());
 
372
 
 
373
    boost::intrusive_ptr<as_object> ret = new Point_as;
 
374
    ret->set_member(NSV::PROP_X, x);
 
375
    ret->set_member(NSV::PROP_Y, y);
 
376
 
 
377
    return as_value(ret.get());
373
378
}
374
379
 
375
380
static as_value
376
381
Point_toString(const fn_call& fn)
377
382
{
378
 
        boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
379
 
 
380
 
        as_value x, y;
381
 
        ptr->get_member(NSV::PROP_X, &x);
382
 
        ptr->get_member(NSV::PROP_Y, &y);
383
 
 
384
 
        std::stringstream ss;
385
 
        ss << "(x=" << x.to_string()
386
 
                << ", y=" << y.to_string()
387
 
                << ")";
388
 
 
389
 
        return as_value(ss.str());
 
383
    boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
 
384
 
 
385
    as_value x, y;
 
386
    ptr->get_member(NSV::PROP_X, &x);
 
387
    ptr->get_member(NSV::PROP_Y, &y);
 
388
 
 
389
    int version = getSWFVersion(fn);
 
390
 
 
391
    std::stringstream ss;
 
392
    ss << "(x=" << x.to_string_versioned(version)
 
393
        << ", y=" << y.to_string_versioned(version)
 
394
        << ")";
 
395
 
 
396
    return as_value(ss.str());
390
397
}
391
398
 
392
399
static as_value
393
400
Point_length_getset(const fn_call& fn)
394
401
{
395
 
        boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
396
 
 
397
 
        if ( ! fn.nargs ) // getter
398
 
        {
399
 
                as_value xval, yval;
400
 
                ptr->get_member(NSV::PROP_X, &xval);
401
 
                ptr->get_member(NSV::PROP_Y, &yval);
402
 
                double x = xval.to_number();
403
 
                double y = yval.to_number();
404
 
 
405
 
                double l = std::sqrt(x*x+y*y);
406
 
                return as_value(l);
407
 
        }
408
 
        else // setter
409
 
        {
410
 
                IF_VERBOSE_ASCODING_ERRORS(
411
 
                log_aserror(_("Attempt to set read-only property %s"), "Point.length");
412
 
                );
413
 
                return as_value();
414
 
        }
 
402
    boost::intrusive_ptr<Point_as> ptr = ensureType<Point_as>(fn.this_ptr);
 
403
 
 
404
    if ( ! fn.nargs ) // getter
 
405
    {
 
406
        as_value xval, yval;
 
407
        ptr->get_member(NSV::PROP_X, &xval);
 
408
        ptr->get_member(NSV::PROP_Y, &yval);
 
409
        double x = xval.to_number();
 
410
        double y = yval.to_number();
 
411
 
 
412
        double l = std::sqrt(x*x+y*y);
 
413
        return as_value(l);
 
414
    }
 
415
    else // setter
 
416
    {
 
417
        IF_VERBOSE_ASCODING_ERRORS(
 
418
        log_aserror(_("Attempt to set read-only property %s"), "Point.length");
 
419
        );
 
420
        return as_value();
 
421
    }
415
422
}
416
423
 
417
424
static as_value
418
425
Point_distance(const fn_call& fn)
419
426
{
420
 
        if ( fn.nargs < 2 )
421
 
        {
422
 
                IF_VERBOSE_ASCODING_ERRORS(
423
 
                std::stringstream ss; fn.dump_args(ss);
424
 
                log_aserror("Point.distance(%s): %s", ss.str(), _("missing arguments"));
425
 
                );
426
 
                return as_value();
427
 
        }
428
 
 
429
 
        IF_VERBOSE_ASCODING_ERRORS(
430
 
        if ( fn.nargs > 2 )
431
 
        {
432
 
                std::stringstream ss; fn.dump_args(ss);
433
 
                log_aserror("Point.distance(%s): %s", ss.str(), _("arguments after first two discarded"));
434
 
        }
435
 
        );
436
 
 
437
 
        const as_value& arg1 = fn.arg(0);
438
 
        if ( ! arg1.is_object() )
439
 
        {
440
 
                IF_VERBOSE_ASCODING_ERRORS(
441
 
                std::stringstream ss; fn.dump_args(ss);
442
 
                log_aserror("Point.distance(%s): %s", ss.str(), _("First arg must be an object"));
443
 
                );
444
 
                return as_value();
445
 
        }
446
 
        as_object* o1 = arg1.to_object().get();
447
 
        assert(o1);
448
 
        if ( ! o1->instanceOf(getFlashGeomPointConstructor()) )
449
 
        {
450
 
                IF_VERBOSE_ASCODING_ERRORS(
451
 
                std::stringstream ss; fn.dump_args(ss);
452
 
                log_aserror("Point.equals(%s): %s %s", ss.str(), _("First arg must be an instance of"), "flash.geom.Point");
453
 
                );
454
 
                return as_value();
455
 
        }
456
 
 
457
 
        const as_value& arg2 = fn.arg(1);
458
 
        as_object* o2 = arg2.to_object().get();
459
 
        assert(o2);
460
 
        // it seems there's no need to check arg2 (see actionscript.all/Point.as)
461
 
 
462
 
        as_value x1val;
463
 
        o1->get_member(NSV::PROP_X, &x1val);
464
 
        double x1 = x1val.to_number();
465
 
        //if ( ! utility::isFinite(x1) ) return as_value(NaN);
466
 
 
467
 
        as_value y1val;
468
 
        o1->get_member(NSV::PROP_Y, &y1val);
469
 
        double y1 = y1val.to_number();
470
 
        //if ( ! utility::isFinite(y1) ) return as_value(NaN);
471
 
 
472
 
        as_value x2val;
473
 
        o2->get_member(NSV::PROP_X, &x2val);
474
 
        double x2 = x2val.to_number();
475
 
        //if ( ! utility::isFinite(x2) ) return as_value(NaN);
476
 
 
477
 
        as_value y2val;
478
 
        o2->get_member(NSV::PROP_Y, &y2val);
479
 
        double y2 = y2val.to_number();
480
 
        //if ( ! utility::isFinite(y2) ) return as_value(NaN);
481
 
 
482
 
        double hside = x2 - x1; // p1.x - p0.x;
483
 
        double vside = y2 - y1; // p1.y - p0.y;
484
 
 
485
 
        double sqdist = hside*hside + vside*vside;
486
 
        double dist = std::sqrt(sqdist);
487
 
 
488
 
        return as_value(dist);
 
427
    if ( fn.nargs < 2 )
 
428
    {
 
429
        IF_VERBOSE_ASCODING_ERRORS(
 
430
        std::stringstream ss; fn.dump_args(ss);
 
431
        log_aserror("Point.distance(%s): %s", ss.str(), _("missing arguments"));
 
432
        );
 
433
        return as_value();
 
434
    }
 
435
 
 
436
    IF_VERBOSE_ASCODING_ERRORS(
 
437
    if ( fn.nargs > 2 )
 
438
    {
 
439
        std::stringstream ss; fn.dump_args(ss);
 
440
        log_aserror("Point.distance(%s): %s", ss.str(), _("arguments after first two discarded"));
 
441
    }
 
442
    );
 
443
 
 
444
    const as_value& arg1 = fn.arg(0);
 
445
    if ( ! arg1.is_object() )
 
446
    {
 
447
        IF_VERBOSE_ASCODING_ERRORS(
 
448
        std::stringstream ss; fn.dump_args(ss);
 
449
        log_aserror("Point.distance(%s): %s", ss.str(), _("First arg must be an object"));
 
450
        );
 
451
        return as_value();
 
452
    }
 
453
    as_object* o1 = arg1.to_object(*getGlobal(fn)).get();
 
454
    assert(o1);
 
455
    if ( ! o1->instanceOf(getFlashGeomPointConstructor(fn)) )
 
456
    {
 
457
        IF_VERBOSE_ASCODING_ERRORS(
 
458
        std::stringstream ss; fn.dump_args(ss);
 
459
        log_aserror("Point.equals(%s): %s %s", ss.str(), _("First arg must be an instance of"), "flash.geom.Point");
 
460
        );
 
461
        return as_value();
 
462
    }
 
463
 
 
464
    const as_value& arg2 = fn.arg(1);
 
465
    as_object* o2 = arg2.to_object(*getGlobal(fn)).get();
 
466
    assert(o2);
 
467
    // it seems there's no need to check arg2 (see actionscript.all/Point.as)
 
468
 
 
469
    as_value x1val;
 
470
    o1->get_member(NSV::PROP_X, &x1val);
 
471
    double x1 = x1val.to_number();
 
472
    //if ( ! isFinite(x1) ) return as_value(NaN);
 
473
 
 
474
    as_value y1val;
 
475
    o1->get_member(NSV::PROP_Y, &y1val);
 
476
    double y1 = y1val.to_number();
 
477
    //if ( ! isFinite(y1) ) return as_value(NaN);
 
478
 
 
479
    as_value x2val;
 
480
    o2->get_member(NSV::PROP_X, &x2val);
 
481
    double x2 = x2val.to_number();
 
482
    //if ( ! isFinite(x2) ) return as_value(NaN);
 
483
 
 
484
    as_value y2val;
 
485
    o2->get_member(NSV::PROP_Y, &y2val);
 
486
    double y2 = y2val.to_number();
 
487
    //if ( ! utility::isFinite(y2) ) return as_value(NaN);
 
488
 
 
489
    double hside = x2 - x1; // p1.x - p0.x;
 
490
    double vside = y2 - y1; // p1.y - p0.y;
 
491
 
 
492
    double sqdist = hside*hside + vside*vside;
 
493
    double dist = std::sqrt(sqdist);
 
494
 
 
495
    return as_value(dist);
489
496
}
490
497
 
491
498
static as_value
492
499
Point_interpolate(const fn_call& fn)
493
500
{
494
 
        as_value x0val;
495
 
        as_value y0val;
496
 
        as_value x1val;
497
 
        as_value y1val;
498
 
        as_value muval;
499
 
 
500
 
        if ( fn.nargs < 3 )
501
 
        {
502
 
                IF_VERBOSE_ASCODING_ERRORS(
503
 
                std::stringstream ss; fn.dump_args(ss);
504
 
                log_aserror("Point.interpolate(%s): %s", ss.str(), _("missing arguments"));
505
 
                );
506
 
        }
507
 
        else
508
 
        {
509
 
                IF_VERBOSE_ASCODING_ERRORS(
510
 
                if ( fn.nargs > 3 )
511
 
                {
512
 
                std::stringstream ss; fn.dump_args(ss);
513
 
                log_aserror("Point.interpolate(%s): %s", ss.str(), _("arguments after first three discarded"));
514
 
                }
515
 
                );
516
 
 
517
 
                const as_value& p0val = fn.arg(0);
518
 
                as_object* p0 = p0val.to_object().get();
519
 
                if ( ! p0 )
520
 
                {
521
 
                        IF_VERBOSE_ASCODING_ERRORS(
522
 
                        std::stringstream ss; fn.dump_args(ss);
523
 
                        log_aserror("Point.interpolate(%s): %s", ss.str(), _("first argument doesn't cast to object"));
524
 
                        );
525
 
                }
526
 
                else
527
 
                {
528
 
                        p0->get_member(NSV::PROP_X, &x0val);
529
 
                        p0->get_member(NSV::PROP_Y, &y0val);
530
 
                }
531
 
 
532
 
                const as_value& p1val = fn.arg(1);
533
 
                as_object* p1 = p1val.to_object().get();
534
 
                if ( ! p1 )
535
 
                {
536
 
                        IF_VERBOSE_ASCODING_ERRORS(
537
 
                        std::stringstream ss; fn.dump_args(ss);
538
 
                        log_aserror("Point.interpolate(%s): %s", ss.str(), _("second argument doesn't cast to object"));
539
 
                        );
540
 
                }
541
 
                else
542
 
                {
543
 
                        p1->get_member(NSV::PROP_X, &x1val);
544
 
                        p1->get_member(NSV::PROP_Y, &y1val);
545
 
                }
546
 
 
547
 
                muval = fn.arg(2);
548
 
        }
549
 
 
550
 
 
551
 
        double x0 = x0val.to_number();
552
 
        double y0 = y0val.to_number();
553
 
        double x1 = x1val.to_number();
554
 
        double y1 = y1val.to_number();
555
 
        double mu = muval.to_number();
556
 
 
557
 
        // newX = b.x + ( muval * (a.x - b.x) );
558
 
        // newY = b.y + ( muval * (a.y - b.y) );
559
 
 
560
 
        as_value xoff = mu * (x0 - x1);
561
 
        as_value yoff = mu * (y0 - y1);
562
 
 
563
 
        //log_debug("xoff:%s, yoff:%s, x1val:%s, y1val:%s", xoff, yoff, x1val, y1val);
564
 
 
565
 
        as_value x = x1val; // copy to avoid changing stack value
566
 
        x.newAdd(xoff);
567
 
        as_value y = y1val; // copy to avoid changing stack value
568
 
        y.newAdd(yoff);
569
 
 
570
 
        boost::intrusive_ptr<as_object> ret = new Point_as;
571
 
        ret->set_member(NSV::PROP_X, as_value(x));
572
 
        ret->set_member(NSV::PROP_Y, as_value(y));
573
 
 
574
 
        return as_value(ret.get());
 
501
    as_value x0val;
 
502
    as_value y0val;
 
503
    as_value x1val;
 
504
    as_value y1val;
 
505
    as_value muval;
 
506
 
 
507
    if ( fn.nargs < 3 )
 
508
    {
 
509
        IF_VERBOSE_ASCODING_ERRORS(
 
510
        std::stringstream ss; fn.dump_args(ss);
 
511
        log_aserror("Point.interpolate(%s): %s", ss.str(), _("missing arguments"));
 
512
        );
 
513
    }
 
514
    else
 
515
    {
 
516
        IF_VERBOSE_ASCODING_ERRORS(
 
517
        if ( fn.nargs > 3 )
 
518
        {
 
519
        std::stringstream ss; fn.dump_args(ss);
 
520
        log_aserror("Point.interpolate(%s): %s", ss.str(), _("arguments after first three discarded"));
 
521
        }
 
522
        );
 
523
 
 
524
        const as_value& p0val = fn.arg(0);
 
525
        as_object* p0 = p0val.to_object(*getGlobal(fn)).get();
 
526
        if ( ! p0 )
 
527
        {
 
528
            IF_VERBOSE_ASCODING_ERRORS(
 
529
            std::stringstream ss; fn.dump_args(ss);
 
530
            log_aserror("Point.interpolate(%s): %s", ss.str(), _("first argument doesn't cast to object"));
 
531
            );
 
532
        }
 
533
        else
 
534
        {
 
535
            p0->get_member(NSV::PROP_X, &x0val);
 
536
            p0->get_member(NSV::PROP_Y, &y0val);
 
537
        }
 
538
 
 
539
        const as_value& p1val = fn.arg(1);
 
540
        as_object* p1 = p1val.to_object(*getGlobal(fn)).get();
 
541
        if ( ! p1 )
 
542
        {
 
543
            IF_VERBOSE_ASCODING_ERRORS(
 
544
            std::stringstream ss; fn.dump_args(ss);
 
545
            log_aserror("Point.interpolate(%s): %s", ss.str(), _("second argument doesn't cast to object"));
 
546
            );
 
547
        }
 
548
        else
 
549
        {
 
550
            p1->get_member(NSV::PROP_X, &x1val);
 
551
            p1->get_member(NSV::PROP_Y, &y1val);
 
552
        }
 
553
 
 
554
        muval = fn.arg(2);
 
555
    }
 
556
 
 
557
 
 
558
    double x0 = x0val.to_number();
 
559
    double y0 = y0val.to_number();
 
560
    double x1 = x1val.to_number();
 
561
    double y1 = y1val.to_number();
 
562
    double mu = muval.to_number();
 
563
 
 
564
    // newX = b.x + ( muval * (a.x - b.x) );
 
565
    // newY = b.y + ( muval * (a.y - b.y) );
 
566
 
 
567
    as_value xoff = mu * (x0 - x1);
 
568
    as_value yoff = mu * (y0 - y1);
 
569
 
 
570
    //log_debug("xoff:%s, yoff:%s, x1val:%s, y1val:%s", xoff, yoff, x1val, y1val);
 
571
 
 
572
    as_value x = x1val; // copy to avoid changing stack value
 
573
    x.newAdd(xoff);
 
574
    as_value y = y1val; // copy to avoid changing stack value
 
575
    y.newAdd(yoff);
 
576
 
 
577
    boost::intrusive_ptr<as_object> ret = new Point_as;
 
578
    ret->set_member(NSV::PROP_X, as_value(x));
 
579
    ret->set_member(NSV::PROP_Y, as_value(y));
 
580
 
 
581
    return as_value(ret.get());
575
582
}
576
583
 
577
584
static as_value
578
585
Point_polar(const fn_call& fn)
579
586
{
580
 
        as_value lval; // length
581
 
        as_value aval; // angle (radians)
582
 
 
583
 
        if ( fn.nargs )
584
 
        {
585
 
                lval=fn.arg(0);
586
 
                if ( fn.nargs > 1 ) aval=fn.arg(1);
587
 
                else
588
 
                {
589
 
                        IF_VERBOSE_ASCODING_ERRORS(
590
 
                        std::stringstream ss; fn.dump_args(ss);
591
 
                        log_aserror("Point.polar(%s): %s", ss.str(), _("missing arguments"));
592
 
                        );
593
 
                }
594
 
        }
595
 
        else
596
 
        {
597
 
                IF_VERBOSE_ASCODING_ERRORS(
598
 
                std::stringstream ss; fn.dump_args(ss);
599
 
                log_aserror("Point.polar(%s): %s", ss.str(), _("missing arguments"));
600
 
                );
601
 
        }
602
 
        
603
 
        double len = lval.to_number();
604
 
        double angle = aval.to_number();
605
 
 
606
 
        double x = len * std::cos(angle);
607
 
        double y = len * std::sin(angle);
608
 
 
609
 
        as_value xval(x);
610
 
        as_value yval(y);
611
 
        boost::intrusive_ptr<as_object> obj = new Point_as;
612
 
 
613
 
        obj->set_member(NSV::PROP_X, x);
614
 
        obj->set_member(NSV::PROP_Y, y);
615
 
        
616
 
        return as_value(obj.get());
 
587
    as_value lval; // length
 
588
    as_value aval; // angle (radians)
 
589
 
 
590
    if ( fn.nargs )
 
591
    {
 
592
        lval=fn.arg(0);
 
593
        if ( fn.nargs > 1 ) aval=fn.arg(1);
 
594
        else
 
595
        {
 
596
            IF_VERBOSE_ASCODING_ERRORS(
 
597
            std::stringstream ss; fn.dump_args(ss);
 
598
            log_aserror("Point.polar(%s): %s", ss.str(), _("missing arguments"));
 
599
            );
 
600
        }
 
601
    }
 
602
    else
 
603
    {
 
604
        IF_VERBOSE_ASCODING_ERRORS(
 
605
        std::stringstream ss; fn.dump_args(ss);
 
606
        log_aserror("Point.polar(%s): %s", ss.str(), _("missing arguments"));
 
607
        );
 
608
    }
 
609
    
 
610
    double len = lval.to_number();
 
611
    double angle = aval.to_number();
 
612
 
 
613
    double x = len * std::cos(angle);
 
614
    double y = len * std::sin(angle);
 
615
 
 
616
    as_value xval(x);
 
617
    as_value yval(y);
 
618
    boost::intrusive_ptr<as_object> obj = new Point_as;
 
619
 
 
620
    obj->set_member(NSV::PROP_X, x);
 
621
    obj->set_member(NSV::PROP_Y, y);
 
622
    
 
623
    return as_value(obj.get());
617
624
}
618
625
 
619
626
 
620
627
as_value
621
628
Point_ctor(const fn_call& fn)
622
629
{
623
 
        boost::intrusive_ptr<as_object> obj = new Point_as;
624
 
 
625
 
        as_value x;
626
 
        as_value y;
627
 
 
628
 
        if ( ! fn.nargs )
629
 
        {
630
 
                x.set_double(0);
631
 
                y.set_double(0);
632
 
        }
633
 
        else
634
 
        {
635
 
                do {
636
 
                        x = fn.arg(0);
637
 
                        if ( fn.nargs < 2 ) break;
638
 
                        y = fn.arg(1);
639
 
                        if ( fn.nargs < 3 ) break;
640
 
                        IF_VERBOSE_ASCODING_ERRORS(
641
 
                                std::stringstream ss;
642
 
                                fn.dump_args(ss);
643
 
                                log_aserror("flash.geom.Point(%s): %s", ss.str(), _("arguments after the first two discarded"));
644
 
                        );
645
 
                } while(0);
646
 
        }
647
 
 
648
 
        obj->set_member(NSV::PROP_X, x);
649
 
        obj->set_member(NSV::PROP_Y, y);
650
 
 
651
 
        return as_value(obj.get()); // will keep alive
652
 
}
653
 
 
654
 
// extern 
655
 
as_function* getFlashGeomPointConstructor()
656
 
{
657
 
        static builtin_function* cl=NULL;
658
 
        if ( ! cl )
659
 
        {
660
 
                cl=new builtin_function(&Point_ctor, getPointInterface());
661
 
                VM::get().addStatic(cl);
662
 
                attachPointStaticProperties(*cl);
663
 
        }
664
 
        return cl;
665
 
}
666
 
 
667
 
static as_value get_flash_geom_point_constructor(const fn_call& /*fn*/)
668
 
{
669
 
        log_debug("Loading flash.geom.Point class");
670
 
 
671
 
        return getFlashGeomPointConstructor();
672
 
}
673
 
 
674
 
boost::intrusive_ptr<as_object> init_Point_instance()
675
 
{
676
 
    return boost::intrusive_ptr<as_object>(new Point_as);
677
 
}
678
 
 
679
 
// extern 
680
 
void Point_class_init(as_object& where)
681
 
{
682
 
        // Register _global.Point
683
 
        string_table& st = where.getVM().getStringTable();
684
 
        where.init_destructive_property(st.find("Point"), get_flash_geom_point_constructor);
 
630
    boost::intrusive_ptr<as_object> obj = new Point_as;
 
631
 
 
632
    as_value x;
 
633
    as_value y;
 
634
 
 
635
    if ( ! fn.nargs )
 
636
    {
 
637
        x.set_double(0);
 
638
        y.set_double(0);
 
639
    }
 
640
    else
 
641
    {
 
642
        do {
 
643
            x = fn.arg(0);
 
644
            if ( fn.nargs < 2 ) break;
 
645
            y = fn.arg(1);
 
646
            if ( fn.nargs < 3 ) break;
 
647
            IF_VERBOSE_ASCODING_ERRORS(
 
648
                std::stringstream ss;
 
649
                fn.dump_args(ss);
 
650
                log_aserror("flash.geom.Point(%s): %s", ss.str(), _("arguments after the first two discarded"));
 
651
            );
 
652
        } while(0);
 
653
    }
 
654
 
 
655
    obj->set_member(NSV::PROP_X, x);
 
656
    obj->set_member(NSV::PROP_Y, y);
 
657
 
 
658
    return as_value(obj.get()); // will keep alive
 
659
}
 
660
 
 
661
// extern 
 
662
as_function*
 
663
getFlashGeomPointConstructor(const fn_call& fn)
 
664
{
 
665
    as_value point(fn.env().find_object("flash.geom.Point"));
 
666
    return point.to_as_function();
 
667
}
 
668
 
 
669
static
 
670
as_value get_flash_geom_point_constructor(const fn_call& fn)
 
671
{
 
672
    log_debug("Loading flash.geom.Point class");
 
673
    Global_as* gl = getGlobal(fn);
 
674
    as_object* proto = getPointInterface();
 
675
    as_object* cl = gl->createClass(&Point_ctor, proto);
 
676
    attachPointStaticProperties(*cl);
 
677
    return cl;
 
678
}
 
679
 
 
680
// extern 
 
681
void
 
682
point_class_init(as_object& where, const ObjectURI& uri)
 
683
{
 
684
    // TODO: this may not be correct, but it should be enumerable.
 
685
    const int flags = 0;
 
686
    where.init_destructive_property(getName(uri),
 
687
            get_flash_geom_point_constructor, flags, getNamespace(uri));
685
688
}
686
689
 
687
690
} // end of gnash namespace