1
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
3
* plugin-class.cpp: MoonLight browser plugin.
6
* Moonlight List (moonlight-list@lists.ximian.com)
8
* Copyright 2007 Novell, Inc. (http://www.novell.com)
10
* See the LICENSE file included with the distribution for details.
20
#include "plugin-class.h"
21
#include "browser-bridge.h"
25
#define DEBUG_WARN_NOTIMPLEMENTED(x) printf ("not implemented: (%s)\n" G_STRLOC, x)
28
#define DEBUG_WARN_NOTIMPLEMENTED(x)
32
// debug scriptable object
36
#define DEBUG_JAVASCRIPT 1
41
#define IS_METHOD(id) (((id) & 0x8000) != 0)
42
#define IS_PROPERTY(id) (((id) & 0x4000) != 0)
44
enum PluginPropertyId {
48
MoonId_ErrorCode = 0x4000,
65
MoonId_PlatformKeyCode,
73
MoonId_EnableFramerateCounter,
74
MoonId_EnableRedrawRegions,
75
MoonId_EnableHtmlAccess,
89
// event names (handled by the property setters)
90
MoonId_BufferingProgressChanged,
92
MoonId_CurrentStateChanged,
93
MoonId_DownloadProgressChanged,
100
MoonId_MarkerReached,
107
MoonId_MouseLeftButtonDown,
108
MoonId_MouseLeftButtonUp,
110
MoonId_OnFullScreenChange,
115
MoonId_GetPosition = 0x8000,
117
MoonId_IsVersionSupported,
119
MoonId_CreateFromXaml,
120
MoonId_CreateFromXamlDownloader,
124
MoonId_GetStylusInfo,
125
MoonId_GetStylusPoints,
127
MoonId_ReleaseMouseCapture,
128
MoonId_AddEventListener,
129
MoonId_RemoveEventListener,
135
MoonId_DumpNameScope,
143
MoonId_GetItemByName,
151
MoonId_SetFontSource,
154
MoonId_GetResponseText,
156
MoonId_AddStylusPoints,
162
npidentifier_to_downstr (NPIdentifier id)
164
if (!NPN_IdentifierIsString (id))
167
NPUTF8 *strname = NPN_UTF8FromIdentifier (id);
170
*p = g_ascii_tolower (*p);
178
MethodArgTypeNone = (0),
179
MethodArgTypeVoid = (1 << NPVariantType_Void),
180
MethodArgTypeNull = (1 << NPVariantType_Null),
181
MethodArgTypeBool = (1 << NPVariantType_Bool),
182
MethodArgTypeInt32 = (1 << NPVariantType_Int32),
183
MethodArgTypeDouble = (1 << NPVariantType_Double),
184
MethodArgTypeString = (1 << NPVariantType_String),
185
MethodArgTypeObject = (1 << NPVariantType_Object),
186
MethodArgTypeAny = (0xff)
190
decode_arg_ctype (char c)
193
case 'v': return MethodArgTypeVoid;
194
case 'n': return MethodArgTypeNull;
195
case 'b': return MethodArgTypeBool;
196
case 'i': return MethodArgTypeInt32;
197
case 'd': return MethodArgTypeDouble;
198
case 's': return MethodArgTypeString;
199
case 'o': return MethodArgTypeObject;
200
case '*': return MethodArgTypeAny;
202
return MethodArgTypeNone;
207
decode_arg_type (const char **in)
209
MethodArgType t, type = MethodArgTypeNone;
210
register const char *inptr = *in;
214
while (*inptr && *inptr != ')') {
215
t = decode_arg_ctype (*inptr);
216
type = (MethodArgType) ((int) type | (int) t);
220
type = decode_arg_ctype (*inptr);
231
* @arglist: a string representing an arg-list token (see grammar below)
232
* @args: NPVariant argument count
233
* @argv: NPVariant argument vector
235
* Checks that the NPVariant arguments satisfy the argument count and
236
* types expected (provided via @typestr).
238
* The @typestr argument should follow the following syntax:
240
* simple-arg-type ::= "v" / "n" / "b" / "i" / "d" / "s" / "o" / "*"
241
* ; each char represents one of the following
242
* ; NPVariant types: Void, Null, Bool, Int32,
243
* ; Double, String, Object and wildcard
245
* arg-type ::= simple-arg-type / "(" 1*(simple-arg-type) ")"
247
* optional-args ::= "[" *(arg-type) "]"
249
* arg-list ::= *(arg-type) (optional-args)
252
* Returns: %true if @argv matches the arg-list criteria specified in
253
* @arglist or %false otherwise.
256
check_arg_list (const char *arglist, uint32_t argc, const NPVariant *argv)
258
const char *inptr = arglist;
262
// check all of the required arguments
263
while (*inptr && *inptr != '[' && i < argc) {
264
mask = decode_arg_type (&inptr);
265
if (!(mask & (1 << argv[i].type))) {
266
// argv[i] does not match any of the expected types
273
if (*inptr && *inptr != '[' && i < argc) {
274
// we were not provided enough arguments
278
// now check all of the optional arguments
280
while (*inptr && *inptr != ']' && i < argc) {
281
mask = decode_arg_type (&inptr);
282
if (!(mask & (1 << argv[i].type))) {
283
// argv[i] does not match any of the expected types
291
// we were provided too many arguments
299
#define STRDUP_FROM_VARIANT(v) (g_strndup ((char *) NPVARIANT_TO_STRING (v).utf8characters, NPVARIANT_TO_STRING (v).utf8length))
300
#define STRLEN_FROM_VARIANT(v) ((size_t) NPVARIANT_TO_STRING (v).utf8length)
302
#define DEPENDENCY_OBJECT_FROM_VARIANT(obj) (((MoonlightDependencyObjectObject*) NPVARIANT_TO_OBJECT (obj))->GetDependencyObject ())
304
#define THROW_JS_EXCEPTION(meth) \
306
char *message = g_strdup_printf ("Error calling method: %s", meth); \
307
NPN_SetException (this, message); \
312
/* for use with bsearch & qsort */
314
compare_mapping (const void *m1, const void *m2)
316
MoonNameIdMapping *map1 = (MoonNameIdMapping*) m1;
317
MoonNameIdMapping *map2 = (MoonNameIdMapping*) m2;
318
return strcmp(map1->name, map2->name);
322
map_name_to_id (NPIdentifier name, const MoonNameIdMapping mapping[], int count, bool include_silverlight2)
324
char *strname = npidentifier_to_downstr (name);
328
MoonNameIdMapping key, *result;
331
result = (MoonNameIdMapping*)bsearch(&key, mapping, count,
332
sizeof(MoonNameIdMapping), compare_mapping);
335
NPN_MemFree (strname);
339
if (result->flags != 0) {
340
if (include_silverlight2) {
341
if ((result->flags & MAPPING_FLAG_SL2) == 0)
345
if ((result->flags & MAPPING_FLAG_SL1) == 0)
354
map_moon_id_to_event_name (int moon_id)
356
const char *name = NULL;
359
case MoonId_BufferingProgressChanged: name = "BufferingProgressChanged"; break;
360
case MoonId_CurrentStateChanged: name = "CurrentStateChanged"; break;
361
case MoonId_DownloadProgressChanged: name = "DownloadProgressChanged"; break;
362
case MoonId_GotFocus: name = "GotFocus"; break;
363
case MoonId_KeyDown: name = "KeyDown"; break;
364
case MoonId_KeyUp: name = "KeyUp"; break;
365
case MoonId_LostFocus: name = "LostFocus"; break;
366
case MoonId_Loaded: name = "Loaded"; break;
367
case MoonId_MarkerReached: name = "MarkerReached"; break;
368
case MoonId_MediaEnded: name = "MediaEnded"; break;
369
case MoonId_MediaFailed: name = "MediaFailed"; break;
370
case MoonId_MediaOpened: name = "MediaOpened"; break;
371
case MoonId_MouseEnter: name = "MouseEnter"; break;
372
case MoonId_MouseLeave: name = "MouseLeave"; break;
373
case MoonId_MouseMove: name = "MouseMove"; break;
374
case MoonId_MouseLeftButtonDown: name = "MouseLeftButtonDown"; break;
375
case MoonId_MouseLeftButtonUp: name = "MouseLeftButtonUp"; break;
376
case MoonId_OnResize: name = "Resize"; break;
377
case MoonId_OnFullScreenChange: name = "FullScreenChange"; break;
378
case MoonId_OnError: name = "Error"; break;
379
case MoonId_OnLoad: name = "Load"; break;
387
string_to_npvariant (const char *value, NPVariant *result)
392
retval = NPN_strdup ((char *)value);
394
retval = NPN_strdup ("");
396
STRINGZ_TO_NPVARIANT (retval, *result);
400
value_to_variant (NPObject *npobj, Value *v, NPVariant *result, DependencyObject *parent_obj = NULL, DependencyProperty *parent_property = NULL)
402
switch (v->GetKind ()) {
404
BOOLEAN_TO_NPVARIANT (v->AsBool(), *result);
407
INT32_TO_NPVARIANT (v->AsInt32(), *result);
410
DOUBLE_TO_NPVARIANT (v->AsDouble(), *result);
413
string_to_npvariant (v->AsString(), result);
416
MoonlightPoint *point = (MoonlightPoint *) NPN_CreateObject (((MoonlightObject *) npobj)->instance, MoonlightPointClass);
417
point->point = *v->AsPoint ();
418
OBJECT_TO_NPVARIANT (point, *result);
422
MoonlightRect *rect = (MoonlightRect *) NPN_CreateObject (((MoonlightObject *) npobj)->instance, MoonlightRectClass);
423
rect->rect = *v->AsRect ();
424
OBJECT_TO_NPVARIANT (rect, *result);
427
case Type::DURATION: {
428
MoonlightDuration *duration = (MoonlightDuration *) NPN_CreateObject (((MoonlightObject *) npobj)->instance, MoonlightDurationClass);
429
duration->SetParentInfo (parent_obj, parent_property);
430
OBJECT_TO_NPVARIANT (duration, *result);
433
case Type::TIMESPAN: {
434
MoonlightTimeSpan *timespan = (MoonlightTimeSpan *) NPN_CreateObject (((MoonlightObject *) npobj)->instance, MoonlightTimeSpanClass);
435
timespan->SetParentInfo (parent_obj, parent_property);
436
OBJECT_TO_NPVARIANT (timespan, *result);
440
Color *c = v->AsColor ();
441
gint32 color = ((((gint32)(c->a * 255.0)) << 24) | (((gint32)(c->r * 255.0)) << 16) |
442
(((gint32)(c->g * 255.0)) << 8) | ((gint32)(c->b * 255.0)));
443
INT32_TO_NPVARIANT (color, *result);
446
case Type::KEYTIME: {
447
MoonlightKeyTime *keytime = (MoonlightKeyTime *) NPN_CreateObject (((MoonlightObject *) npobj)->instance, MoonlightKeyTimeClass);
448
keytime->SetParentInfo (parent_obj, parent_property);
449
OBJECT_TO_NPVARIANT (keytime, *result);
453
/* more builtins.. */
454
if (v->Is (Type::DEPENDENCY_OBJECT)) {
455
MoonlightEventObjectObject *depobj =
456
EventObjectCreateWrapper (((MoonlightObject *) npobj)->instance, v->AsDependencyObject ());
457
OBJECT_TO_NPVARIANT (depobj, *result);
464
variant_to_value (const NPVariant *v, Value **result)
467
case NPVariantType_Bool:
468
*result = new Value (NPVARIANT_TO_BOOLEAN (*v));
470
case NPVariantType_Int32:
471
*result = new Value ((int32_t) NPVARIANT_TO_INT32 (*v));
473
case NPVariantType_Double:
474
*result = new Value (NPVARIANT_TO_DOUBLE (*v));
476
case NPVariantType_String: {
477
char *value = STRDUP_FROM_VARIANT (*v);
478
*result = new Value (value);
482
case NPVariantType_Void:
483
DEBUG_WARN_NOTIMPLEMENTED ("void variant type");
486
case NPVariantType_Null:
487
DEBUG_WARN_NOTIMPLEMENTED ("null variant type");
488
*result = new Value (Type::DEPENDENCY_OBJECT);
490
case NPVariantType_Object:
491
// This should never happen, we should do type checking of the
492
// arguments before this point and refuse arguments we don't understand.
493
//d(printf ("Got invalid value from javascript.\n"));
494
*result = new Value ();
499
enum DependencyObjectClassNames {
502
DEPENDENCY_OBJECT_CLASS,
509
STYLUS_POINT_COLLECTION_CLASS,
510
STROKE_COLLECTION_CLASS,
514
ROUTED_EVENT_ARGS_CLASS,
515
ERROR_EVENT_ARGS_CLASS,
516
KEY_EVENT_ARGS_CLASS,
517
MARKER_REACHED_EVENT_ARGS_CLASS,
518
MOUSE_EVENT_ARGS_CLASS,
520
DEPENDENCY_OBJECT_CLASS_NAMES_LAST
523
NPClass *dependency_object_classes[DEPENDENCY_OBJECT_CLASS_NAMES_LAST];
526
npobject_is_dependency_object (NPObject *obj)
528
for (int i = 0; i < DEPENDENCY_OBJECT_CLASS_NAMES_LAST; i++) {
529
if (dependency_object_classes [i] == obj->_class)
536
npvariant_is_dependency_object (NPVariant var)
538
if (!NPVARIANT_IS_OBJECT (var))
541
return npobject_is_dependency_object (NPVARIANT_TO_OBJECT (var));
545
npvariant_is_object_class (NPVariant var, int type)
549
if (type < 0 || type >= DEPENDENCY_OBJECT_CLASS_NAMES_LAST)
552
if (!NPVARIANT_IS_OBJECT (var))
555
obj = NPVARIANT_TO_OBJECT (var);
557
return obj->_class == dependency_object_classes[type];
560
#define npvariant_is_downloader(v) npvariant_is_object_class (v, DOWNLOADER_CLASS)
563
npvariant_is_moonlight_object (NPVariant var)
565
NPClass *moonlight_types[] = {
566
MoonlightContentClass,
567
MoonlightDurationClass,
568
MoonlightObjectClass,
570
MoonlightScriptableObjectClass,
571
MoonlightScriptControlClass,
572
MoonlightSettingsClass,
573
MoonlightTimeSpanClass
578
if (!NPVARIANT_IS_OBJECT (var))
581
obj = NPVARIANT_TO_OBJECT (var);
582
if (npobject_is_dependency_object (obj))
585
for (i = 0; i < G_N_ELEMENTS (moonlight_types); i++) {
586
if (obj->_class == moonlight_types[i])
593
EventListenerProxy::EventListenerProxy (NPP instance, const char *event_name, const char *cb_name)
595
this->instance = instance;
596
this->event_name = g_strdup (event_name);
598
this->target_object = NULL;
600
this->one_shot = false;
601
this->is_func = false;
602
if (!strncmp (cb_name, "javascript:", strlen ("javascript:")))
603
cb_name += strlen ("javascript:");
604
this->callback = g_strdup (cb_name);
607
EventListenerProxy::EventListenerProxy (NPP instance, const char *event_name, const NPVariant *cb)
609
this->instance = instance;
610
this->event_name = g_strdup (event_name);
612
this->target_object = NULL;
614
this->one_shot = false;
616
if (NPVARIANT_IS_OBJECT (*cb)) {
617
this->is_func = true;
618
this->callback = NPVARIANT_TO_OBJECT (*cb);
619
NPN_RetainObject ((NPObject *) this->callback);
621
this->is_func = false;
622
this->callback = STRDUP_FROM_VARIANT (*cb);
626
EventListenerProxy::~EventListenerProxy ()
629
// XXX we *want* to be able to do this, we really do, but we have no
630
// good means to invalidate EventListenerProxy, and thereby set the
633
// instead we do it in ::RemoveHandler, which is only invoked via JS's removeEventListener
635
// if (callback != NULL)
636
// NPN_ReleaseObject ((NPObject *) callback);
646
EventListenerProxy::GetCallbackAsString ()
651
return (const char *)callback;
655
EventListenerProxy::SetOwner (MoonlightObject *owner)
661
EventListenerProxy::AddHandler (EventObject *obj)
665
event_id = obj->GetType()->LookupEvent (event_name);
667
if (event_id == -1) {
668
d(printf ("object of type `%s' does not provide an event named `%s'\n",
669
obj->GetTypeName(), event_name));
673
token = obj->AddHandler (event_id, proxy_listener_to_javascript, this, on_handler_removed);
678
EventListenerProxy::AddXamlHandler (EventObject *obj)
682
event_id = obj->GetType()->LookupEvent (event_name);
684
if (event_id == -1) {
685
d(printf ("object of type `%s' does not provide an event named `%s'\n",
686
obj->GetTypeName(), event_name));
690
token = obj->AddXamlHandler (event_id, proxy_listener_to_javascript, this, on_handler_removed);
696
EventListenerProxy::RemoveHandler ()
698
if (target_object && event_id != -1) {
699
target_object->RemoveHandler (event_id, token);
700
if (callback != NULL)
701
NPN_ReleaseObject ((NPObject *) callback);
704
on_handler_removed (this);
709
EventListenerProxy::on_handler_removed (gpointer closure)
711
// by the time we get here, the target_object has disclaimed
712
// all knowledge of this proxy.
714
EventListenerProxy *proxy = (EventListenerProxy *) closure;
717
proxy->owner->ClearEventProxy (proxy);
720
// we don't have an owner, so there's nothing special
721
// for us to do here.
724
proxy->target_object = NULL;
725
proxy->event_id = -1;
726
proxy->unref_delayed();
730
EventListenerProxy::proxy_listener_to_javascript (EventObject *sender, EventArgs *calldata, gpointer closure)
732
EventListenerProxy *proxy = (EventListenerProxy *) closure;
733
EventObject *js_sender = sender;
738
if (proxy->instance->pdata == NULL) {
739
// Firefox can invalidate our NPObjects after the plugin itself
740
// has been destroyed. During this invalidation our NPObjects call
741
// into the moonlight runtime, which then emits events.
742
d(printf ("Moonlight: The plugin has been deleted, but we're still emitting events?\n"));
746
PluginInstance *plugin = (PluginInstance*) proxy->instance->pdata;
748
if (js_sender->GetObjectType () == Type::SURFACE) {
749
// This is somewhat hackish, but is required for
750
// the FullScreenChanged event (js expects the
751
// sender to be the toplevel canvas, not the surface,
753
js_sender = ((Surface*) js_sender)->GetToplevel ();
756
MoonlightEventObjectObject *depobj = NULL;
758
depobj = EventObjectCreateWrapper (proxy->instance, js_sender);
759
plugin->AddCleanupPointer (&depobj);
760
OBJECT_TO_NPVARIANT (depobj, args[0]);
762
NULL_TO_NPVARIANT (args[0]);
765
//printf ("proxying event %s to javascript, sender = %p (%s)\n", proxy->event_name, sender, sender->GetTypeName ());
766
MoonlightEventObjectObject *depargs = NULL;
768
depargs = EventObjectCreateWrapper (proxy->instance, calldata);
769
plugin->AddCleanupPointer (&depargs);
770
OBJECT_TO_NPVARIANT (depargs, args[1]);
774
if (proxy->is_func && proxy->callback) {
775
/* the event listener was added with a JS function object */
776
if (NPN_InvokeDefault (proxy->instance, (NPObject *) proxy->callback, args, argcount, &result))
777
NPN_ReleaseVariantValue (&result);
779
/* the event listener was added with a JS string (the function name) */
780
NPObject *object = NULL;
782
if (NPN_GetValue (proxy->instance, NPNVWindowNPObject, &object) == NPERR_NO_ERROR) {
783
if (NPN_Invoke (proxy->instance, object, NPID ((char *) proxy->callback), args, argcount, &result))
784
NPN_ReleaseVariantValue (&result);
789
plugin->RemoveCleanupPointer (&depobj);
790
NPN_ReleaseObject (depobj);
793
plugin->RemoveCleanupPointer (&depargs);
794
NPN_ReleaseObject (depargs);
797
proxy->RemoveHandler();
801
event_object_add_xaml_listener (EventObject *obj, PluginInstance *plugin, const char *event_name, const char *cb_name)
803
EventListenerProxy *proxy = new EventListenerProxy (plugin->GetInstance (), event_name, cb_name);
804
proxy->AddXamlHandler (obj);
807
class NamedProxyPredicate {
809
NamedProxyPredicate (char *name) { this->name = g_strdup (name); }
810
~NamedProxyPredicate () { g_free (name); }
812
static bool matches (EventHandler cb_handler, gpointer cb_data, gpointer data)
814
if (cb_handler != EventListenerProxy::proxy_listener_to_javascript)
818
EventListenerProxy *proxy = (EventListenerProxy*)cb_data;
819
NamedProxyPredicate *pred = (NamedProxyPredicate*)data;
821
return !strcasecmp (proxy->GetCallbackAsString(), pred->name);
830
event_args_allocate (NPP instance, NPClass *klass)
832
return new MoonlightEventArgs (instance);
835
MoonlightEventArgsType::MoonlightEventArgsType ()
837
allocate = event_args_allocate;
840
MoonlightEventArgsType *MoonlightEventArgsClass;
842
/*** RoutedEventArgs ***/
844
routedeventargs_allocate (NPP instance, NPClass *klass)
846
return new MoonlightRoutedEventArgs (instance);
849
static const MoonNameIdMapping
850
routedeventargs_mapping[] = {
851
{ "source", MoonId_Source, MAPPING_FLAG_SL2 },
855
MoonlightRoutedEventArgs::GetProperty (int id, NPIdentifier name, NPVariant *result)
857
RoutedEventArgs *args = GetRoutedEventArgs ();
860
case MoonId_Source: {
861
DependencyObject *source = args->GetSource ();
863
MoonlightEventObjectObject *source_obj = EventObjectCreateWrapper (instance, source);
864
OBJECT_TO_NPVARIANT (source_obj, *result);
867
NULL_TO_NPVARIANT (*result);
874
return MoonlightEventArgs::GetProperty (id, name, result);
878
MoonlightRoutedEventArgsType::MoonlightRoutedEventArgsType ()
880
allocate = routedeventargs_allocate;
882
AddMapping (routedeventargs_mapping, G_N_ELEMENTS (routedeventargs_mapping));
885
MoonlightRoutedEventArgsType *MoonlightRoutedEventArgsClass;
888
/*** ErrorEventArgs ***/
890
erroreventargs_allocate (NPP instance, NPClass *klass)
892
return new MoonlightErrorEventArgs (instance);
895
static const MoonNameIdMapping
896
erroreventargs_mapping[] = {
897
{ "charposition", MoonId_CharPosition },
898
{ "errorcode", MoonId_ErrorCode },
899
{ "errormessage", MoonId_ErrorMessage },
900
{ "errortype", MoonId_ErrorType },
901
{ "linenumber", MoonId_LineNumber },
902
{ "methodname", MoonId_MethodName },
903
{ "xamlfile", MoonId_XamlFile },
907
MoonlightErrorEventArgs::GetProperty (int id, NPIdentifier name, NPVariant *result)
909
ErrorEventArgs *args = GetErrorEventArgs ();
912
case MoonId_ErrorCode:
913
INT32_TO_NPVARIANT (args->error_code, *result);
916
case MoonId_ErrorType:
917
switch (args->error_type) {
918
case NoError: string_to_npvariant ("NoError", result); break;
919
case UnknownError: string_to_npvariant ("UnknownError", result); break;
920
case InitializeError: string_to_npvariant ("InitializeError", result); break;
921
case ParserError: string_to_npvariant ("ParserError", result); break;
922
case ObjectModelError: string_to_npvariant ("ObjectModelError", result); break;
923
case RuntimeError: string_to_npvariant ("RuntimeError", result); break;
924
case DownloadError: string_to_npvariant ("DownloadError", result); break;
925
case MediaError: string_to_npvariant ("MediaError", result); break;
926
case ImageError: string_to_npvariant ("ImageError", result); break;
929
case MoonId_ErrorMessage:
930
string_to_npvariant (args->error_message, result);
932
case MoonId_LineNumber:
933
if (args->error_type == ParserError) {
934
INT32_TO_NPVARIANT (((ParserErrorEventArgs*)args)->line_number, *result);
936
DEBUG_WARN_NOTIMPLEMENTED ("ErrorEventArgs.lineNumber");
937
INT32_TO_NPVARIANT (0, *result);
940
case MoonId_CharPosition:
941
if (args->error_type == ParserError) {
942
INT32_TO_NPVARIANT (((ParserErrorEventArgs*)args)->char_position, *result);
944
DEBUG_WARN_NOTIMPLEMENTED ("ErrorEventArgs.charPosition");
945
INT32_TO_NPVARIANT (0, *result);
948
case MoonId_MethodName:
949
DEBUG_WARN_NOTIMPLEMENTED ("ErrorEventArgs.methodName");
950
INT32_TO_NPVARIANT (0, *result);
952
case MoonId_XamlFile:
953
if (args->error_type == ParserError) {
954
string_to_npvariant (((ParserErrorEventArgs*)args)->xaml_file, result);
956
DEBUG_WARN_NOTIMPLEMENTED ("ErrorEventArgs.xamlFile");
957
NULL_TO_NPVARIANT (*result);
961
return MoonlightEventArgs::GetProperty (id, name, result);
965
MoonlightErrorEventArgsType::MoonlightErrorEventArgsType ()
967
allocate = erroreventargs_allocate;
969
AddMapping (erroreventargs_mapping, G_N_ELEMENTS (erroreventargs_mapping));
972
MoonlightErrorEventArgsType *MoonlightErrorEventArgsClass;
976
point_allocate (NPP instance, NPClass *klass)
978
return new MoonlightPoint (instance);
981
static const MoonNameIdMapping
989
MoonlightPoint::GetProperty (int id, NPIdentifier name, NPVariant *result)
993
DOUBLE_TO_NPVARIANT (point.x, *result);
997
DOUBLE_TO_NPVARIANT (point.y, *result);
1001
return MoonlightObject::GetProperty (id, name, result);
1006
MoonlightPoint::SetProperty (int id, NPIdentifier name, const NPVariant *value)
1010
point.x = NPVARIANT_TO_DOUBLE (*value);
1013
point.y = NPVARIANT_TO_DOUBLE (*value);
1016
return MoonlightObject::SetProperty (id, name, value);
1020
MoonlightPointType::MoonlightPointType ()
1022
allocate = point_allocate;
1024
AddMapping (point_mapping, G_N_ELEMENTS (point_mapping));
1027
MoonlightPointType *MoonlightPointClass;
1031
rect_allocate (NPP instance, NPClass *klass)
1033
return new MoonlightRect (instance);
1036
static const MoonNameIdMapping
1038
{ "height", MoonId_Height },
1039
{ "width", MoonId_Width },
1045
MoonlightRect::GetProperty (int id, NPIdentifier name, NPVariant *result)
1049
DOUBLE_TO_NPVARIANT (rect.x, *result);
1053
DOUBLE_TO_NPVARIANT (rect.y, *result);
1057
DOUBLE_TO_NPVARIANT (rect.width, *result);
1061
DOUBLE_TO_NPVARIANT (rect.height, *result);
1065
return MoonlightObject::GetProperty (id, name, result);
1070
MoonlightRect::SetProperty (int id, NPIdentifier name, const NPVariant *value)
1074
rect.x = NPVARIANT_TO_DOUBLE (*value);
1078
rect.y = NPVARIANT_TO_DOUBLE (*value);
1082
rect.width = NPVARIANT_TO_DOUBLE (*value);
1086
rect.height = NPVARIANT_TO_DOUBLE (*value);
1090
return MoonlightObject::SetProperty (id, name, value);;
1095
MoonlightRectType::MoonlightRectType ()
1097
allocate = rect_allocate;
1099
AddMapping (rect_mapping, G_N_ELEMENTS (rect_mapping));
1102
MoonlightRectType *MoonlightRectClass;
1107
duration_allocate (NPP instance, NPClass *klass)
1109
return new MoonlightDuration (instance);
1112
static const MoonNameIdMapping
1113
duration_mapping[] = {
1114
{ "name", MoonId_Name },
1115
{ "seconds", MoonId_Seconds }
1119
MoonlightDuration::SetParentInfo (DependencyObject *parent_obj, DependencyProperty *parent_property)
1121
this->parent_obj = parent_obj;
1122
this->parent_property = parent_property;
1127
MoonlightDuration::GetValue()
1129
Value *v = parent_obj->GetValue (parent_property);
1130
return v ? v->AsDuration()->ToSecondsFloat () : 0.0;
1134
MoonlightDuration::GetProperty (int id, NPIdentifier name, NPVariant *result)
1138
string_to_npvariant ("", result);
1141
case MoonId_Seconds:
1142
DOUBLE_TO_NPVARIANT (GetValue(), *result);
1146
return MoonlightObject::GetProperty (id, name, result);
1151
MoonlightDuration::SetProperty (int id, NPIdentifier name, const NPVariant *value)
1157
case MoonId_Seconds:
1158
parent_obj->SetValue (parent_property, Value(Duration::FromSecondsFloat (NPVARIANT_TO_DOUBLE (*value))));
1162
return MoonlightObject::SetProperty (id, name, value);
1166
MoonlightDuration::~MoonlightDuration ()
1169
parent_obj->unref();
1172
MoonlightDurationType::MoonlightDurationType ()
1174
allocate = duration_allocate;
1176
AddMapping (duration_mapping, G_N_ELEMENTS (duration_mapping));
1179
MoonlightDurationType *MoonlightDurationClass;
1184
timespan_allocate (NPP instance, NPClass *klass)
1186
return new MoonlightTimeSpan (instance);
1189
static const MoonNameIdMapping
1190
timespan_mapping[] = {
1191
{ "name", MoonId_Name },
1192
{ "seconds", MoonId_Seconds }
1196
MoonlightTimeSpan::SetParentInfo (DependencyObject *parent_obj, DependencyProperty *parent_property)
1198
this->parent_obj = parent_obj;
1199
this->parent_property = parent_property;
1204
MoonlightTimeSpan::GetValue()
1206
Value *v = parent_obj->GetValue (parent_property);
1207
return v ? v->AsTimeSpan() : (TimeSpan)0;
1211
MoonlightTimeSpan::GetProperty (int id, NPIdentifier name, NPVariant *result)
1215
string_to_npvariant ("", result);
1217
case MoonId_Seconds:
1218
DOUBLE_TO_NPVARIANT (TimeSpan_ToSecondsFloat (GetValue ()), *result);
1221
return MoonlightObject::GetProperty (id, name, result);
1226
MoonlightTimeSpan::SetProperty (int id, NPIdentifier name, const NPVariant *value)
1232
case MoonId_Seconds:
1233
if (NPVARIANT_IS_INT32 (*value)) {
1234
parent_obj->SetValue (parent_property, Value(TimeSpan_FromSecondsFloat (NPVARIANT_TO_INT32 (*value)), Type::TIMESPAN));
1235
} else if (NPVARIANT_IS_DOUBLE (*value)) {
1236
parent_obj->SetValue (parent_property, Value(TimeSpan_FromSecondsFloat (NPVARIANT_TO_DOUBLE (*value)), Type::TIMESPAN));
1243
return MoonlightObject::SetProperty (id, name, value);
1247
MoonlightTimeSpan::~MoonlightTimeSpan ()
1250
parent_obj->unref ();
1253
MoonlightTimeSpanType::MoonlightTimeSpanType ()
1255
allocate = timespan_allocate;
1257
AddMapping (timespan_mapping, G_N_ELEMENTS (timespan_mapping));
1260
MoonlightTimeSpanType *MoonlightTimeSpanClass;
1264
keytime_allocate (NPP instance, NPClass *klass)
1266
return new MoonlightKeyTime (instance);
1269
static const MoonNameIdMapping
1270
keytime_mapping[] = {
1271
{ "name", MoonId_Name },
1272
{ "seconds", MoonId_Seconds }
1276
MoonlightKeyTime::SetParentInfo (DependencyObject *parent_obj, DependencyProperty *parent_property)
1278
this->parent_obj = parent_obj;
1279
this->parent_property = parent_property;
1284
MoonlightKeyTime::GetValue()
1286
Value *v = parent_obj->GetValue (parent_property);
1287
return (v ? v->AsKeyTime() : NULL);
1291
MoonlightKeyTime::GetProperty (int id, NPIdentifier name, NPVariant *result)
1295
string_to_npvariant ("", result);
1297
case MoonId_Seconds:
1298
DOUBLE_TO_NPVARIANT (TimeSpan_ToSecondsFloat (GetValue ()->GetTimeSpan ()), *result);
1301
return MoonlightObject::GetProperty (id, name, result);
1306
MoonlightKeyTime::SetProperty (int id, NPIdentifier name, const NPVariant *value)
1312
case MoonId_Seconds:
1313
if (NPVARIANT_IS_INT32 (*value))
1314
parent_obj->SetValue (parent_property, Value(KeyTime::FromTimeSpan (TimeSpan_FromSecondsFloat (NPVARIANT_TO_INT32 (*value)))));
1315
else if (NPVARIANT_IS_DOUBLE (*value))
1316
parent_obj->SetValue (parent_property, Value(KeyTime::FromTimeSpan (TimeSpan_FromSecondsFloat (NPVARIANT_TO_DOUBLE (*value)))));
1320
return MoonlightObject::SetProperty (id, name, value);
1324
MoonlightKeyTime::~MoonlightKeyTime ()
1327
parent_obj->unref ();
1330
MoonlightKeyTimeType::MoonlightKeyTimeType ()
1332
allocate = keytime_allocate;
1334
AddMapping (keytime_mapping, G_N_ELEMENTS (keytime_mapping));
1337
MoonlightKeyTimeType *MoonlightKeyTimeClass;
1339
/*** MoonlightMouseEventArgsClass **************************************************************/
1342
mouse_event_allocate (NPP instance, NPClass *klass)
1344
return new MoonlightMouseEventArgsObject (instance);
1347
static const MoonNameIdMapping
1348
mouse_event_mapping[] = {
1349
{ "ctrl", MoonId_Ctrl },
1350
{ "handled", MoonId_Handled, MAPPING_FLAG_SL2 },
1351
{ "getposition", MoonId_GetPosition },
1352
{ "getstylusinfo", MoonId_GetStylusInfo },
1353
{ "getstyluspoints", MoonId_GetStylusPoints },
1354
{ "shift", MoonId_Shift },
1358
MoonlightMouseEventArgsObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
1360
MouseEventArgs *event_args = GetMouseEventArgs ();
1361
int state = event_args->GetState ();
1365
BOOLEAN_TO_NPVARIANT ((state & GDK_SHIFT_MASK) != 0, *result);
1369
BOOLEAN_TO_NPVARIANT ((state & GDK_CONTROL_MASK) != 0, *result);
1372
case MoonId_Handled:
1373
BOOLEAN_TO_NPVARIANT (event_args->GetHandled(), *result);
1377
return MoonlightRoutedEventArgs::GetProperty (id, name, result);
1382
MoonlightMouseEventArgsObject::SetProperty (int id, NPIdentifier name, const NPVariant *value)
1384
MouseEventArgs *event_args = GetMouseEventArgs ();
1387
case MoonId_Handled:
1388
if (NPVARIANT_IS_BOOLEAN (*value))
1389
event_args->SetHandled (NPVARIANT_TO_BOOLEAN (*value));
1392
return MoonlightRoutedEventArgs::SetProperty (id, name, value);
1397
MoonlightMouseEventArgsObject::Invoke (int id, NPIdentifier name,
1398
const NPVariant *args, uint32_t argCount,
1401
MouseEventArgs *event_args = GetMouseEventArgs ();
1404
case MoonId_GetPosition: {
1405
if (!check_arg_list ("(no)", argCount, args) && (!NPVARIANT_IS_NULL(args[0]) || !npvariant_is_dependency_object (args[0])))
1411
// The argument is an element
1412
// to calculate the position with respect to (or null
1413
// for screen space)
1415
UIElement *el = NULL;
1417
if (npvariant_is_dependency_object (args[0])) {
1418
DependencyObject *dob = DEPENDENCY_OBJECT_FROM_VARIANT (args [0]);
1419
if (dob->Is (Type::UIELEMENT))
1420
el = (UIElement *)dob;
1423
event_args->GetPosition (el, &x, &y);
1425
MoonlightPoint *point = (MoonlightPoint*)NPN_CreateObject (instance, MoonlightPointClass);
1426
point->point = Point (x, y);
1428
OBJECT_TO_NPVARIANT (point, *result);
1432
case MoonId_GetStylusInfo: {
1434
THROW_JS_EXCEPTION ("getStylusInfo");
1436
StylusInfo *info = event_args->GetStylusInfo ();
1437
MoonlightEventObjectObject *info_obj = EventObjectCreateWrapper (instance, info);
1439
OBJECT_TO_NPVARIANT (info_obj, *result);
1443
case MoonId_GetStylusPoints: {
1444
if (!check_arg_list ("o", argCount, args))
1445
THROW_JS_EXCEPTION ("getStylusPoints");
1447
if (npvariant_is_dependency_object (args[0])) {
1448
DependencyObject *dob = DEPENDENCY_OBJECT_FROM_VARIANT (args [0]);
1449
if (!dob->Is (Type::INKPRESENTER))
1450
THROW_JS_EXCEPTION ("getStylusPoints");
1452
StylusPointCollection *points = event_args->GetStylusPoints ((UIElement*)dob);
1453
MoonlightEventObjectObject *col_obj = EventObjectCreateWrapper (instance, points);
1455
OBJECT_TO_NPVARIANT (col_obj, *result);
1461
return MoonlightRoutedEventArgs::Invoke (id, name, args, argCount, result);
1466
MoonlightMouseEventArgsType::MoonlightMouseEventArgsType ()
1468
allocate = mouse_event_allocate;
1470
AddMapping (mouse_event_mapping, G_N_ELEMENTS (mouse_event_mapping));
1473
MoonlightMouseEventArgsType *MoonlightMouseEventArgsClass;
1476
/*** MoonlightMarkerReachedEventArgsClass **************************************************************/
1479
marker_reached_event_allocate (NPP instance, NPClass *klass)
1481
return new MoonlightMarkerReachedEventArgsObject (instance);
1484
static const MoonNameIdMapping
1485
marker_reached_event_mapping[] = {
1486
{ "marker", MoonId_Marker }
1490
MoonlightMarkerReachedEventArgsObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
1492
MarkerReachedEventArgs *args = GetMarkerReachedEventArgs ();
1493
TimelineMarker *marker = args ? args->GetMarker () : NULL;
1496
case MoonId_Marker: {
1497
MoonlightEventObjectObject *meoo = EventObjectCreateWrapper (instance, marker);
1498
OBJECT_TO_NPVARIANT (meoo, *result);
1502
return MoonlightEventArgs::GetProperty (id, name, result);;
1506
MoonlightMarkerReachedEventArgsType::MoonlightMarkerReachedEventArgsType ()
1508
allocate = marker_reached_event_allocate;
1510
AddMapping (marker_reached_event_mapping, G_N_ELEMENTS (marker_reached_event_mapping));
1513
MoonlightMarkerReachedEventArgsType *MoonlightMarkerReachedEventArgsClass;
1515
/*** MoonlightKeyEventArgsClass **************************************************************/
1518
keyboard_event_allocate (NPP instance, NPClass *klass)
1520
return new MoonlightKeyEventArgsObject (instance);
1523
static const MoonNameIdMapping
1524
keyboard_event_mapping[] = {
1525
{ "ctrl", MoonId_Ctrl },
1526
{ "handled", MoonId_Handled, MAPPING_FLAG_SL2 },
1527
{ "key", MoonId_Key },
1528
{ "platformkeycode", MoonId_PlatformKeyCode },
1529
{ "shift", MoonId_Shift },
1534
MoonlightKeyEventArgsObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
1536
KeyEventArgs *args = GetKeyEventArgs ();
1540
BOOLEAN_TO_NPVARIANT ((args->GetState () & GDK_SHIFT_MASK) != 0, *result);
1544
BOOLEAN_TO_NPVARIANT ((args->GetState () & GDK_CONTROL_MASK) != 0, *result);
1547
case MoonId_Handled:
1548
BOOLEAN_TO_NPVARIANT (args->GetHandled(), *result);
1552
INT32_TO_NPVARIANT (args->GetKey (), *result);
1555
case MoonId_PlatformKeyCode:
1556
INT32_TO_NPVARIANT (args->GetPlatformKeyCode (), *result);
1560
return MoonlightEventArgs::GetProperty (id, name, result);
1564
MoonlightKeyEventArgsType::MoonlightKeyEventArgsType ()
1566
allocate = keyboard_event_allocate;
1568
AddMapping (keyboard_event_mapping, G_N_ELEMENTS (keyboard_event_mapping));
1571
MoonlightKeyEventArgsType *MoonlightKeyEventArgsClass;
1573
/*** our object base class */
1575
_allocate (NPP instance, NPClass *klass)
1577
return new MoonlightObject (instance);
1581
_deallocate (NPObject *npobj)
1583
MoonlightObject *obj = (MoonlightObject *) npobj;
1589
detach_xaml_proxy (gpointer key, gpointer value, gpointer closure)
1591
EventListenerProxy *proxy = (EventListenerProxy*)value;
1592
proxy->SetOwner (NULL);
1595
MoonlightObject::~MoonlightObject ()
1597
if (event_listener_proxies) {
1598
g_hash_table_foreach (event_listener_proxies, detach_xaml_proxy, NULL);
1599
g_hash_table_destroy (event_listener_proxies);
1600
event_listener_proxies = NULL;
1605
MoonlightObject::destroy_proxy (gpointer data)
1607
EventListenerProxy *proxy = (EventListenerProxy*)data;
1608
proxy->RemoveHandler ();
1612
MoonlightObject::HasProperty (NPIdentifier name)
1614
return IS_PROPERTY (LookupName (name));
1618
MoonlightObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
1620
NULL_TO_NPVARIANT (*result);
1621
THROW_JS_EXCEPTION ("AG_E_RUNTIME_GETVALUE");
1626
MoonlightObject::SetProperty (int id, NPIdentifier name, const NPVariant *value)
1628
THROW_JS_EXCEPTION ("AG_E_RUNTIME_SETVALUE");
1633
MoonlightObject::HasMethod (NPIdentifier name)
1635
return IS_METHOD (LookupName (name));
1639
MoonlightObject::Invoke (int id, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result)
1641
PluginInstance *plugin = (PluginInstance*) instance->pdata;
1644
case MoonId_ToString:
1648
if (moonlight_type != Type::INVALID) {
1649
if (plugin->IsSilverlight2 ()) {
1650
string_to_npvariant (Type::Find (moonlight_type)->name, result);
1652
switch (moonlight_type) {
1653
case Type::KEYEVENTARGS:
1654
string_to_npvariant ("KeyboardEventArgs", result);
1657
string_to_npvariant (Type::Find (moonlight_type)->name, result);
1663
//string_to_npvariant ("", result);
1664
NULL_TO_NPVARIANT (*result);
1674
EventListenerProxy *
1675
MoonlightObject::LookupEventProxy (int event_id)
1677
return (EventListenerProxy*)g_hash_table_lookup (event_listener_proxies, GINT_TO_POINTER (event_id));
1681
MoonlightObject::SetEventProxy (EventListenerProxy *proxy)
1683
g_hash_table_insert (event_listener_proxies, GINT_TO_POINTER (proxy->GetEventId()), proxy);
1687
MoonlightObject::ClearEventProxy (EventListenerProxy *proxy)
1689
proxy->SetOwner (NULL);
1692
EventListenerProxy *p = LookupEventProxy (proxy->GetEventId());
1696
g_hash_table_remove (event_listener_proxies, GINT_TO_POINTER (proxy->GetEventId()));
1701
_invalidate (NPObject *npobj)
1703
MoonlightObject *obj = (MoonlightObject *) npobj;
1709
_has_method (NPObject *npobj, NPIdentifier name)
1711
MoonlightObject *obj = (MoonlightObject *) npobj;
1712
return obj->HasMethod (name);
1716
_has_property (NPObject *npobj, NPIdentifier name)
1718
MoonlightObject *obj = (MoonlightObject *) npobj;
1719
return obj->HasProperty (name);
1723
_get_property (NPObject *npobj, NPIdentifier name, NPVariant *result)
1725
MoonlightObject *obj = (MoonlightObject *) npobj;
1726
int id = obj->LookupName (name);
1727
return obj->GetProperty (id, name, result);
1731
_set_property (NPObject *npobj, NPIdentifier name, const NPVariant *value)
1733
MoonlightObject *obj = (MoonlightObject *) npobj;
1734
int id = obj->LookupName (name);
1735
return obj->SetProperty (id, name, value);
1739
_remove_property (NPObject *npobj, NPIdentifier name)
1741
g_warning ("moonlight_object_remove_property reached");
1746
_enumerate (NPObject *npobj, NPIdentifier **value, uint32_t *count)
1748
return ((MoonlightObjectType*)npobj->_class)->Enumerate (value, count);
1752
_invoke (NPObject *npobj, NPIdentifier name,
1753
const NPVariant *args, uint32_t argCount,
1756
MoonlightObject *obj = (MoonlightObject *) npobj;
1757
int id = obj->LookupName (name);
1758
return obj->Invoke (id, name, args, argCount, result);
1762
_invoke_default (NPObject *npobj,
1763
const NPVariant *args, uint32_t argCount,
1766
g_warning ("moonlight_object_invoke_default reached");
1770
static const MoonNameIdMapping
1771
object_mapping[] = {
1772
{ "tostring", MoonId_ToString },
1775
MoonlightObjectType::MoonlightObjectType ()
1777
allocate = _allocate;
1779
deallocate = _deallocate;
1780
invalidate = _invalidate;
1781
hasMethod = _has_method;
1783
invokeDefault = _invoke_default;
1784
hasProperty = _has_property;
1785
getProperty = _get_property;
1786
setProperty = _set_property;
1787
removeProperty = _remove_property;
1788
enumerate = _enumerate;
1793
AddMapping (object_mapping, G_N_ELEMENTS (object_mapping));
1800
MoonlightObjectType::Enumerate (NPIdentifier **value, uint32_t *count)
1802
if (mapping_count == 0) {
1808
// caller frees this
1809
NPIdentifier *ids = (NPIdentifier*)NPN_MemAlloc (sizeof (NPIdentifier) * mapping_count);
1811
for (int i = 0; i < mapping_count; i ++)
1812
ids[i] = NPN_GetStringIdentifier (mapping[i].name);
1814
*count = mapping_count;
1821
MoonlightObjectType::AddMapping (const MoonNameIdMapping *mapping, int count)
1823
if (this->mapping) {
1824
MoonNameIdMapping *new_mapping = (MoonNameIdMapping *) g_new (MoonNameIdMapping, count + mapping_count);
1826
memmove (new_mapping, this->mapping, mapping_count * sizeof (MoonNameIdMapping));
1827
memmove ((char *) new_mapping + (mapping_count * sizeof (MoonNameIdMapping)), mapping, count * sizeof (MoonNameIdMapping));
1828
g_free (this->mapping);
1829
this->mapping = new_mapping;
1830
mapping_count += count;
1832
this->mapping = (MoonNameIdMapping *) g_new (MoonNameIdMapping, count);
1834
memmove (this->mapping, mapping, count * sizeof (MoonNameIdMapping));
1835
mapping_count = count;
1838
qsort (this->mapping, mapping_count, sizeof (MoonNameIdMapping), compare_mapping);
1842
MoonlightObjectType::LookupName (NPIdentifier name, bool include_silverlight2)
1844
if (last_lookup == name)
1847
int id = map_name_to_id (name, mapping, mapping_count, include_silverlight2);
1850
/* only cache hits */
1858
MoonlightObjectType *MoonlightObjectClass;
1860
/*** MoonlightScriptControlClass **********************************************************/
1862
moonlight_scriptable_control_allocate (NPP instance, NPClass *klass)
1864
return new MoonlightScriptControlObject (instance);
1867
static const MoonNameIdMapping
1868
scriptable_control_mapping[] = {
1869
{ "content", MoonId_Content },
1870
{ "isloaded", MoonId_IsLoaded },
1871
{ "createobject", MoonId_CreateObject },
1872
{ "initparams", MoonId_InitParams },
1873
{ "id", MoonId_Id },
1874
{ "isversionsupported", MoonId_IsVersionSupported },
1875
{ "onerror", MoonId_OnError },
1876
{ "onload", MoonId_OnLoad },
1877
{ "settings", MoonId_Settings },
1878
{ "source", MoonId_Source },
1881
MoonlightScriptControlObject::~MoonlightScriptControlObject ()
1884
NPN_ReleaseObject (settings);
1889
NPN_ReleaseObject (content);
1895
MoonlightScriptControlObject::Invalidate ()
1897
MoonlightObject::Invalidate ();
1904
MoonlightScriptControlObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
1906
PluginInstance *plugin = (PluginInstance*) instance->pdata;
1909
case MoonId_Settings:
1910
NPN_RetainObject (settings);
1911
OBJECT_TO_NPVARIANT (settings, *result);
1913
case MoonId_Content:
1914
NPN_RetainObject (content);
1915
OBJECT_TO_NPVARIANT (content, *result);
1917
case MoonId_InitParams:
1918
string_to_npvariant (plugin->GetInitParams (), result);
1920
case MoonId_IsLoaded:
1921
if (!plugin->GetSurface ()) {
1922
BOOLEAN_TO_NPVARIANT (false, *result);
1924
BOOLEAN_TO_NPVARIANT (plugin->GetSurface()->IsLoaded(), *result);
1927
case MoonId_OnError:
1928
case MoonId_OnLoad: {
1929
const char *event_name = map_moon_id_to_event_name (id);
1930
EventObject *obj = plugin->GetSurface ();
1933
int event_id = obj->GetType()->LookupEvent (event_name);
1934
EventListenerProxy *proxy = LookupEventProxy (event_id);
1935
string_to_npvariant (proxy == NULL ? "" : proxy->GetCallbackAsString (), result);
1937
string_to_npvariant ("", result);
1942
string_to_npvariant (plugin->GetSource (), result);
1946
char *id = plugin->GetId ();
1948
string_to_npvariant (id, result);
1950
NULL_TO_NPVARIANT (*result);
1956
return MoonlightObject::GetProperty (id, name, result);
1961
MoonlightScriptControlObject::SetProperty (int id, NPIdentifier name, const NPVariant *value)
1963
PluginInstance *plugin = (PluginInstance*) instance->pdata;
1966
case MoonId_Source: {
1967
char *source = STRDUP_FROM_VARIANT (*value);
1968
plugin->SetSource (source);
1972
case MoonId_OnError:
1973
case MoonId_OnLoad: {
1974
const char *event_name = map_moon_id_to_event_name (id);
1975
EventObject *obj = plugin->GetSurface ();
1978
int event_id = obj->GetType()->LookupEvent (event_name);
1980
if (event_id != -1) {
1981
EventListenerProxy *proxy = LookupEventProxy (event_id);
1983
proxy->RemoveHandler ();
1985
if (!NPVARIANT_IS_NULL (*value)) {
1986
EventListenerProxy *proxy = new EventListenerProxy (instance,
1989
proxy->SetOwner (this);
1990
proxy->AddHandler (plugin->GetSurface());
1991
// we only emit that event once, when
1992
// the plugin is initialized, so don't
1993
// leave it in the event list
1995
if (id == MoonId_OnLoad)
1996
proxy->SetOneShot ();
1997
SetEventProxy (proxy);
2006
return MoonlightObject::SetProperty (id, name, value);
2011
MoonlightScriptControlObject::Invoke (int id, NPIdentifier name,
2012
const NPVariant *args, uint32_t argCount,
2016
case MoonId_CreateObject: {
2017
if (!check_arg_list ("s", argCount, args)) {
2018
NULL_TO_NPVARIANT (*result);
2022
NPObject *obj = NULL;
2023
char *object_type = STRDUP_FROM_VARIANT (args [0]);
2024
if (!g_ascii_strcasecmp ("downloader", object_type)) {
2025
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2026
Downloader *dl = PluginInstance::CreateDownloader (plugin);
2028
obj = EventObjectCreateWrapper (instance, dl);
2031
OBJECT_TO_NPVARIANT (obj, *result);
2032
g_free (object_type);
2035
NULL_TO_NPVARIANT (*result);
2036
g_free (object_type);
2038
THROW_JS_EXCEPTION ("createObject");
2043
case MoonId_IsVersionSupported: {
2044
/* we support all 0.*, 1.0.* and 1.1.* versions. */
2045
if (!check_arg_list ("s", argCount, args))
2048
bool supported = true;
2049
gchar *version_list = STRDUP_FROM_VARIANT (args [0]);
2050
gchar **versions = g_strsplit (version_list, ".", 4);
2051
char *version = NULL;
2054
supported = versions [0] != NULL && versions [1] != NULL;
2057
for (int k = 0; k < 4; k++) {
2059
version = versions [k];
2061
if (version == NULL)
2064
// Only allow ascii 0-9 characters in the numbers
2065
for (int i = 0; version [i] != 0; i++) {
2066
if (version [i] < '0' || version [i] > '9') {
2072
numbers [k] = atoll (version);
2075
switch (numbers [0]) {
2076
case 0: // We support all versions of the format "0.*"
2080
supported &= numbers [1] <= 1; // 1.0* or 1.1*
2084
supported &= numbers [1] == 0; // 1.0*
2093
// d(printf ("version requested = '%s' (%s)\n", version_list, supported ? "yes" : "no"));
2095
BOOLEAN_TO_NPVARIANT (supported, *result);
2097
g_strfreev (versions);
2098
g_free (version_list);
2104
return MoonlightObject::Invoke (id, name, args, argCount, result);
2108
MoonlightScriptControlType::MoonlightScriptControlType ()
2110
allocate = moonlight_scriptable_control_allocate;
2112
AddMapping (scriptable_control_mapping, G_N_ELEMENTS (scriptable_control_mapping));
2115
MoonlightScriptControlType *MoonlightScriptControlClass;
2117
/*** MoonlightSettingsClass ***********************************************************/
2120
moonlight_settings_allocate (NPP instance, NPClass *klass)
2122
return new MoonlightSettingsObject (instance);
2125
static const MoonNameIdMapping
2126
moonlight_settings_mapping [] = {
2127
{ "background", MoonId_Background },
2128
{ "enableframeratecounter", MoonId_EnableFramerateCounter },
2129
{ "enablehtmlaccess", MoonId_EnableHtmlAccess },
2130
{ "enableredrawregions", MoonId_EnableRedrawRegions },
2131
{ "maxframerate", MoonId_MaxFrameRate },
2132
{ "version", MoonId_Version },
2133
{ "windowless", MoonId_Windowless }
2137
MoonlightSettingsObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
2139
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2142
case MoonId_Background:
2143
string_to_npvariant (plugin->GetBackground (), result);
2146
case MoonId_EnableFramerateCounter:
2147
BOOLEAN_TO_NPVARIANT (plugin->GetEnableFramerateCounter (), *result);
2150
case MoonId_EnableRedrawRegions:
2151
BOOLEAN_TO_NPVARIANT (plugin->GetEnableRedrawRegions (), *result);
2154
case MoonId_EnableHtmlAccess:
2155
BOOLEAN_TO_NPVARIANT (plugin->GetEnableHtmlAccess (), *result);
2158
// not implemented yet, just return 0.
2159
case MoonId_MaxFrameRate:
2160
INT32_TO_NPVARIANT (0, *result);
2163
case MoonId_Version:
2164
string_to_npvariant (PLUGIN_VERSION, result);
2167
case MoonId_Windowless:
2168
BOOLEAN_TO_NPVARIANT (plugin->GetWindowless (), *result);
2172
return MoonlightObject::GetProperty (id, name, result);
2177
MoonlightSettingsObject::SetProperty (int id, NPIdentifier name, const NPVariant *value)
2179
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2183
case MoonId_Background: {
2184
char *color = STRDUP_FROM_VARIANT (*value);
2185
if (!plugin->SetBackground (color)) {
2187
THROW_JS_EXCEPTION ("AG_E_RUNTIME_SETVALUE");
2193
// Cant be set after initialization so return true
2194
case MoonId_EnableFramerateCounter:
2197
case MoonId_EnableRedrawRegions:
2198
plugin->SetEnableRedrawRegions (NPVARIANT_TO_BOOLEAN (*value));
2201
// Cant be set after initialization so return true
2202
case MoonId_EnableHtmlAccess:
2205
// not implemented yet.
2206
case MoonId_MaxFrameRate:
2207
plugin->SetMaxFrameRate (NPVARIANT_TO_INT32 (*value));
2210
// Cant be set after initialization so return true
2211
case MoonId_Windowless:
2214
return MoonlightObject::SetProperty (id, name, value);
2219
MoonlightSettingsObject::Invoke (int id, NPIdentifier name,
2220
const NPVariant *args, uint32_t argCount, NPVariant *result)
2223
case MoonId_ToString:
2227
string_to_npvariant ("Settings", result);
2230
return MoonlightObject::Invoke (id, name, args, argCount, result);
2234
MoonlightSettingsType::MoonlightSettingsType ()
2236
allocate = moonlight_settings_allocate;
2237
AddMapping (moonlight_settings_mapping, G_N_ELEMENTS (moonlight_settings_mapping));
2240
MoonlightSettingsType *MoonlightSettingsClass;
2243
/*** MoonlightContentClass ************************************************************/
2245
moonlight_content_allocate (NPP instance, NPClass *klass)
2247
return new MoonlightContentObject (instance);
2250
MoonlightContentObject::~MoonlightContentObject ()
2252
// FIXME: need to free registered scriptable objects
2253
if (registered_scriptable_objects) {
2254
g_hash_table_destroy (registered_scriptable_objects);
2255
registered_scriptable_objects = NULL;
2259
static const MoonNameIdMapping
2260
moonlight_content_mapping[] = {
2261
{ "actualheight", MoonId_ActualHeight },
2262
{ "actualwidth", MoonId_ActualWidth },
2263
{ "createfromxaml", MoonId_CreateFromXaml },
2264
{ "createfromxamldownloader", MoonId_CreateFromXamlDownloader },
2265
{ "createobject", MoonId_CreateObject },
2266
{ "findname", MoonId_FindName },
2267
{ "fullscreen", MoonId_FullScreen },
2268
{ "onfullscreenchange", MoonId_OnFullScreenChange },
2269
{ "onresize", MoonId_OnResize },
2270
{ "root", MoonId_Root },
2274
MoonlightContentObject::HasProperty (NPIdentifier name)
2276
if (MoonlightObject::HasProperty (name))
2279
// FIXME: this is still case sensitive (uses a direct hash on the NPIdentifier)
2280
return g_hash_table_lookup (registered_scriptable_objects, name) != NULL;
2284
MoonlightContentObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
2286
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2289
case MoonId_ActualHeight:
2290
INT32_TO_NPVARIANT (plugin->GetActualHeight (), *result);
2292
case MoonId_ActualWidth:
2293
INT32_TO_NPVARIANT (plugin->GetActualWidth (), *result);
2295
case MoonId_FullScreen:
2296
if (!plugin->GetSurface ()) {
2297
BOOLEAN_TO_NPVARIANT (false, *result);
2299
BOOLEAN_TO_NPVARIANT (plugin->GetSurface()->GetFullScreen (), *result);
2302
case MoonId_OnResize:
2303
case MoonId_OnFullScreenChange: {
2304
Surface *surface = plugin->GetSurface ();
2305
const char *event_name;
2308
if (surface == NULL) {
2309
string_to_npvariant ("", result);
2311
event_name = map_moon_id_to_event_name (id);
2312
event_id = surface->GetType()->LookupEvent (event_name);
2313
EventListenerProxy *proxy = LookupEventProxy (event_id);
2314
string_to_npvariant (proxy == NULL ? "" : proxy->GetCallbackAsString (), result);
2319
Surface *surface = plugin->GetSurface ();
2320
DependencyObject *top;
2322
if (surface == NULL) {
2323
NULL_TO_NPVARIANT (*result);
2324
} else if ((top = surface->GetToplevel ()) == NULL) {
2325
NULL_TO_NPVARIANT (*result);
2327
MoonlightEventObjectObject *topobj = EventObjectCreateWrapper (instance, top);
2329
OBJECT_TO_NPVARIANT (topobj, *result);
2334
MoonlightScriptableObjectObject *obj;
2337
if (!(val = g_hash_table_lookup (registered_scriptable_objects, name)))
2340
obj = (MoonlightScriptableObjectObject *) val;
2342
NPN_RetainObject (obj);
2343
OBJECT_TO_NPVARIANT (obj, *result);
2347
return MoonlightObject::GetProperty (id, name, result);
2352
MoonlightContentObject::SetProperty (int id, NPIdentifier name, const NPVariant *value)
2354
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2355
Surface *surface = NULL;
2358
case MoonId_FullScreen:
2359
surface = plugin->GetSurface ();
2360
if (surface != NULL)
2361
surface->SetFullScreen (NPVARIANT_TO_BOOLEAN (*value));
2363
case MoonId_OnFullScreenChange:
2364
case MoonId_OnResize: {
2365
const char *event_name = map_moon_id_to_event_name (id);
2368
surface = plugin->GetSurface ();
2369
if (surface == NULL)
2372
event_id = surface->GetType()->LookupEvent (event_name);
2374
if (event_id != -1) {
2375
EventListenerProxy *proxy = LookupEventProxy (event_id);
2377
proxy->RemoveHandler();
2379
if (!NPVARIANT_IS_NULL (*value)) {
2380
EventListenerProxy *proxy = new EventListenerProxy (instance,
2383
proxy->SetOwner (this);
2384
proxy->AddHandler (plugin->GetSurface());
2385
SetEventProxy (proxy);
2392
return MoonlightObject::SetProperty (id, name, value);
2397
MoonlightContentObject::Invoke (int id, NPIdentifier name,
2398
const NPVariant *args, uint32_t argCount, NPVariant *result)
2400
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2403
case MoonId_FindName: {
2404
if (!check_arg_list ("s", argCount, args))
2405
THROW_JS_EXCEPTION ("AG_E_RUNTIME_FINDNAME");
2407
if (!plugin->GetSurface() || !plugin->GetSurface()->GetToplevel ())
2410
char *name = STRDUP_FROM_VARIANT (args [0]);
2411
DependencyObject *element = plugin->GetSurface()->GetToplevel ()->FindName (name);
2415
NULL_TO_NPVARIANT (*result);
2419
OBJECT_TO_NPVARIANT (EventObjectCreateWrapper (instance, element), *result);
2423
case MoonId_CreateObject:
2424
// not implemented yet
2425
DEBUG_WARN_NOTIMPLEMENTED ("content.createObject");
2428
case MoonId_CreateFromXaml: {
2429
if (!check_arg_list ("s[b]", argCount, args))
2430
THROW_JS_EXCEPTION ("createFromXaml");
2432
bool create_namescope = argCount >= 2 ? NPVARIANT_TO_BOOLEAN (args[1]) : false;
2433
char *xaml = STRDUP_FROM_VARIANT (args[0]);
2436
THROW_JS_EXCEPTION ("createFromXaml");
2438
Type::Kind element_type;
2439
XamlLoader *loader = PluginXamlLoader::FromStr (xaml, plugin, plugin->GetSurface());
2440
DependencyObject *dep = loader->CreateFromString (xaml, create_namescope, &element_type);
2445
THROW_JS_EXCEPTION ("createFromXaml");
2447
MoonlightEventObjectObject *depobj = EventObjectCreateWrapper (instance, dep);
2450
OBJECT_TO_NPVARIANT (depobj, *result);
2454
case MoonId_CreateFromXamlDownloader: {
2455
if (!check_arg_list ("os", argCount, args))
2456
THROW_JS_EXCEPTION ("createFromXamlDownloader");
2458
Downloader *down = (Downloader*)((MoonlightDependencyObjectObject*) NPVARIANT_TO_OBJECT (args [0]))->GetDependencyObject ();
2459
DependencyObject *dep = NULL;
2460
Type::Kind element_type;
2462
char *path = STRDUP_FROM_VARIANT (args [1]);
2463
char *fname = down->GetDownloadedFilename (path);
2466
if (fname != NULL) {
2467
XamlLoader *loader = PluginXamlLoader::FromFilename (fname, plugin, plugin->GetSurface());
2468
dep = loader->CreateFromFile (fname, false, &element_type);
2475
THROW_JS_EXCEPTION ("createFromXamlDownloader");
2477
OBJECT_TO_NPVARIANT (EventObjectCreateWrapper (instance, dep), *result);
2482
case MoonId_ToString: {
2486
string_to_npvariant ("Content", result);
2491
return MoonlightObject::Invoke (id, name, args, argCount, result);
2495
MoonlightContentType::MoonlightContentType ()
2497
allocate = moonlight_content_allocate;
2499
AddMapping (moonlight_content_mapping, G_N_ELEMENTS (moonlight_content_mapping));
2502
MoonlightContentType *MoonlightContentClass;
2506
/*** MoonlightDependencyObjectClass ***************************************************/
2508
static const MoonNameIdMapping
2509
moonlight_dependency_object_mapping [] = {
2510
{ "addeventlistener", MoonId_AddEventListener },
2511
{ "capturemouse", MoonId_CaptureMouse },
2512
#if DEBUG_JAVASCRIPT
2513
{ "dumpnamescope", MoonId_DumpNameScope },
2515
{ "equals", MoonId_Equals },
2516
{ "findname", MoonId_FindName },
2517
{ "gethost", MoonId_GetHost },
2518
{ "getparent", MoonId_GetParent },
2519
{ "getvalue", MoonId_GetValue },
2520
{ "gotfocus", MoonId_GotFocus },
2521
{ "keydown", MoonId_KeyDown },
2522
{ "keyup", MoonId_KeyUp },
2523
{ "loaded", MoonId_Loaded },
2524
{ "lostfocus", MoonId_LostFocus },
2525
{ "mouseenter", MoonId_MouseEnter },
2526
{ "mouseleave", MoonId_MouseLeave },
2527
{ "mouseleftbuttondown", MoonId_MouseLeftButtonDown },
2528
{ "mouseleftbuttonup", MoonId_MouseLeftButtonUp },
2529
{ "mousemove", MoonId_MouseMove },
2530
#if DEBUG_JAVASCRIPT
2531
{ "printf", MoonId_Printf },
2533
{ "releasemousecapture", MoonId_ReleaseMouseCapture },
2534
{ "removeeventlistener", MoonId_RemoveEventListener },
2535
{ "setvalue", MoonId_SetValue },
2539
moonlight_dependency_object_allocate (NPP instance, NPClass *klass)
2541
return new MoonlightDependencyObjectObject (instance);
2544
static DependencyProperty *
2545
_get_dependency_property (DependencyObject *obj, char *attrname)
2547
// don't need to downcase here since dependency property lookup is already case insensitive
2548
DependencyProperty *p = obj->GetDependencyProperty (attrname);
2553
char *period = strchr (attrname, '.');
2555
char *type_name = g_strndup (attrname, period-attrname);
2556
attrname = period + 1;
2558
Type *type = Type::Find (type_name);
2561
p = DependencyProperty::GetDependencyProperty (type->type, attrname);
2570
_set_dependency_property_value (DependencyObject *dob, DependencyProperty *prop, const NPVariant *value, bool sl2)
2572
if (npvariant_is_moonlight_object (*value)) {
2573
MoonlightObject *obj = (MoonlightObject *) NPVARIANT_TO_OBJECT (*value);
2574
MoonlightDuration *duration;
2575
MoonlightTimeSpan *ts;
2576
MoonlightPoint *point;
2577
MoonlightRect *rect;
2579
if (Type::IsSubclassOf (obj->moonlight_type, Type::DEPENDENCY_OBJECT) && obj->moonlight_type != Type::INVALID) {
2580
MoonlightDependencyObjectObject *depobj = (MoonlightDependencyObjectObject*) NPVARIANT_TO_OBJECT (*value);
2581
dob->SetValue (prop, Value (depobj->GetDependencyObject ()));
2586
switch (obj->moonlight_type) {
2587
case Type::TIMESPAN:
2588
ts = (MoonlightTimeSpan *) obj;
2589
dob->SetValue (prop, Value (ts->GetValue (), Type::TIMESPAN));
2591
case Type::DURATION:
2592
duration = (MoonlightDuration *) obj;
2593
dob->SetValue (prop, Value (duration->GetValue ()));
2596
rect = (MoonlightRect *) obj;
2597
dob->SetValue (prop, Value (rect->rect));
2600
point = (MoonlightPoint *) obj;
2601
dob->SetValue (prop, Value (point->point));
2604
d(printf ("unhandled object type %d - %s in do.set_property\n",
2605
obj->moonlight_type, Type::Find (obj->moonlight_type)->name));
2606
w(printf ("unhandled object type in do.set_property\n"));
2610
char *strval = NULL;
2614
if (NPVARIANT_IS_BOOLEAN (*value)) {
2615
if (NPVARIANT_TO_BOOLEAN (*value))
2616
strcpy (strbuf, "true");
2618
strcpy (strbuf, "false");
2621
} else if (NPVARIANT_IS_INT32 (*value)) {
2622
g_snprintf (strbuf, sizeof (strbuf), "%d", NPVARIANT_TO_INT32 (*value));
2625
} else if (NPVARIANT_IS_DOUBLE (*value)) {
2626
g_snprintf (strbuf, sizeof (strbuf), "%g", NPVARIANT_TO_DOUBLE (*value));
2629
} else if (NPVARIANT_IS_STRING (*value)) {
2630
strval = STRDUP_FROM_VARIANT (*value);
2631
} else if (NPVARIANT_IS_NULL (*value)) {
2632
if (Type::IsSubclassOf (prop->GetPropertyType(), Type::DEPENDENCY_OBJECT)) {
2633
DependencyObject *val = NULL;
2635
dob->SetValue (prop, Value (val));
2636
} else if (prop->GetPropertyType() == Type::STRING) {
2639
dob->SetValue (prop, Value (val));
2641
dob->SetValue (prop, NULL);
2644
} else if (NPVARIANT_IS_VOID (*value)) {
2645
d(printf ("unhandled variant type VOID in do.set_property for (%s::%s)\n",
2646
dob->GetTypeName (), prop->GetName()));
2649
d(printf ("unhandled variant type in do.set_property for (%s::%s)\n",
2650
dob->GetTypeName (), prop->GetName()));
2654
rv = xaml_set_property_from_str (dob, prop, strval, sl2);
2656
if (strval != strbuf)
2667
MoonlightDependencyObjectObject::HasProperty (NPIdentifier name)
2669
if (MoonlightObject::HasProperty (name))
2672
DependencyObject *dob = GetDependencyObject ();
2674
// don't need to downcase here since dependency property lookup is already case insensitive
2675
NPUTF8 *strname = NPN_UTF8FromIdentifier (name);
2679
DependencyProperty *p = _get_dependency_property (dob, strname);
2680
NPN_MemFree (strname);
2686
MoonlightDependencyObjectObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
2688
// don't need to downcase here since dependency property lookup is already case insensitive
2689
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2690
NPUTF8 *strname = NPN_UTF8FromIdentifier (name);
2691
DependencyObject *dob = GetDependencyObject ();
2692
DependencyProperty *prop;
2693
const char *event_name;
2700
prop = _get_dependency_property (dob, strname);
2701
NPN_MemFree (strname);
2704
if (!(value = dob->GetValue (prop))) {
2705
// strings aren't null, they seem to just be empty strings
2706
if (prop->GetPropertyType() == Type::STRING) {
2707
string_to_npvariant ("", result);
2711
NULL_TO_NPVARIANT (*result);
2715
if (value->GetKind () == Type::INT32) {
2716
const char *s = enums_int_to_str (prop->GetName(), value->AsInt32 (), plugin->IsSilverlight2());
2718
string_to_npvariant (s, result);
2720
value_to_variant (this, value, result, dob, prop);
2722
value_to_variant (this, value, result, dob, prop);
2727
// it wasn't a dependency property. let's see if it's an
2728
// event, and hook it up if it is valid on this object.
2729
if (!(event_name = map_moon_id_to_event_name (id)))
2730
return MoonlightObject::GetProperty (id, name, result);
2732
if ((event_id = dob->GetType()->LookupEvent (event_name)) == -1) {
2734
EventListenerProxy *proxy = LookupEventProxy (event_id);
2735
string_to_npvariant (proxy == NULL ? "" : proxy->GetCallbackAsString (), result);
2738
// on silverlight, these seem to always return ""
2739
// regardless of how we attempt to set them.
2740
string_to_npvariant ("", result);
2745
return MoonlightObject::GetProperty (id, name, result);
2749
MoonlightDependencyObjectObject::SetProperty (int id, NPIdentifier name, const NPVariant *value)
2751
// don't need to downcase here since dependency property lookup is already case insensitive
2752
NPUTF8 *strname = NPN_UTF8FromIdentifier (name);
2753
DependencyObject *dob = GetDependencyObject ();
2754
DependencyProperty *prop;
2759
prop = _get_dependency_property (dob, strname);
2760
NPN_MemFree (strname);
2763
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2764
if (_set_dependency_property_value (dob, prop, value, plugin->IsSilverlight2())) {
2767
THROW_JS_EXCEPTION ("AG_E_RUNTIME_SETVALUE");
2771
return MoonlightObject::SetProperty (id, name, value);
2775
MoonlightDependencyObjectObject::Invoke (int id, NPIdentifier name,
2776
const NPVariant *args, uint32_t argCount,
2779
DependencyObject *dob = GetDependencyObject ();
2782
#if DEBUG_JAVASCRIPT
2783
// Some debug code...
2784
// with this it is possible to do obj.printf ("msg") from js
2785
case MoonId_Printf: {
2786
char *message = STRDUP_FROM_VARIANT (args [0]);
2787
fprintf (stderr, "JS message: %s\n", message);
2789
VOID_TO_NPVARIANT (*result);
2792
case MoonId_DumpNameScope: {
2793
fprintf (stderr, "dumping namescope for object %p (%s)\n", dob, dob->GetTypeName());
2794
DependencyObject *ns_dob = dob;
2796
while (!(ns = NameScope::GetNameScope(ns_dob)))
2797
ns_dob = ns_dob->GetLogicalParent();
2799
fprintf (stderr, " no namescope in logical hierarchy!\n");
2802
fprintf (stderr, "namescope is actually on object %p (%s)\n", ns_dob, ns_dob->GetTypeName());
2808
case MoonId_Equals: {
2809
if (!check_arg_list ("o", argCount, args))
2810
THROW_JS_EXCEPTION ("equals");
2812
NPObject *o = NPVARIANT_TO_OBJECT (args[0]);
2813
if (npobject_is_dependency_object (o)) {
2814
MoonlightDependencyObjectObject *obj = (MoonlightDependencyObjectObject *) o;
2816
BOOLEAN_TO_NPVARIANT (obj->GetDependencyObject() == dob, *result);
2818
BOOLEAN_TO_NPVARIANT (false, *result);
2824
case MoonId_SetValue: {
2825
/* obj.setValue (prop, val) is another way of writing obj[prop] = val (or obj.prop = val) */
2826
if (!check_arg_list ("s*", argCount, args))
2827
THROW_JS_EXCEPTION ("setValue");
2829
char *value = STRDUP_FROM_VARIANT (args [0]);
2830
_class->setProperty (this, NPID (value), &args[1]);
2833
VOID_TO_NPVARIANT (*result);
2837
case MoonId_GetValue: {
2838
if (!check_arg_list ("s", argCount, args))
2839
THROW_JS_EXCEPTION ("getValue");
2841
char *value = STRDUP_FROM_VARIANT (args [0]);
2842
_class->getProperty (this, NPID (value), result);
2848
case MoonId_FindName: {
2849
if (!check_arg_list ("s", argCount, args))
2850
THROW_JS_EXCEPTION ("AG_E_RUNTIME_FINDNAME");
2852
char *name = STRDUP_FROM_VARIANT (args [0]);
2854
DependencyObject *element = dob->FindName (name);
2857
NULL_TO_NPVARIANT (*result);
2861
OBJECT_TO_NPVARIANT (EventObjectCreateWrapper (instance, element), *result);
2865
case MoonId_GetHost: {
2866
PluginInstance *plugin = (PluginInstance*) instance->pdata;
2869
THROW_JS_EXCEPTION ("AG_E_RUNTIME_GETHOST");
2871
OBJECT_TO_NPVARIANT (plugin->GetHost (), *result);
2876
case MoonId_GetParent: {
2877
if (argCount != 0 || !dob->GetType ()->IsSubclassOf (Type::UIELEMENT))
2878
THROW_JS_EXCEPTION ("AG_E_RUNTIME_GETPARENT");
2880
DependencyObject *parent = dob->GetLogicalParent ();
2882
OBJECT_TO_NPVARIANT (EventObjectCreateWrapper (instance, parent), *result);
2884
NULL_TO_NPVARIANT (*result);
2889
case MoonId_AddEventListener: {
2890
/* FIXME: how do we check if args[1] is a function? */
2891
if (!check_arg_list ("s(so)", argCount, args))
2892
THROW_JS_EXCEPTION ("addEventListener");
2894
char *name = STRDUP_FROM_VARIANT (args [0]);
2895
name[0] = toupper(name[0]);
2897
EventListenerProxy *proxy = new EventListenerProxy (instance, name, &args[1]);
2898
int token = proxy->AddHandler (dob);
2902
THROW_JS_EXCEPTION ("AG_E_RUNTIME_ADDEVENT");
2904
INT32_TO_NPVARIANT (token, *result);
2907
case MoonId_RemoveEventListener: {
2908
if (!check_arg_list ("s(is)", argCount, args))
2909
THROW_JS_EXCEPTION ("removeEventListener");
2911
char *event = STRDUP_FROM_VARIANT (args[0]);
2912
int id = dob->GetType()->LookupEvent (event);
2916
THROW_JS_EXCEPTION ("AG_E_RUNTIME_DELEVENT");
2917
} else if (NPVARIANT_IS_INT32 (args [1])) {
2918
dob->RemoveHandler (id, NPVARIANT_TO_INT32 (args[1]));
2919
} else if (NPVARIANT_IS_STRING (args[1])) {
2920
char *value = STRDUP_FROM_VARIANT (args[1]);
2921
NamedProxyPredicate predicate (value);
2924
dob->RemoveMatchingHandlers (id, NamedProxyPredicate::matches, &predicate);
2930
// FIXME: these next two methods should live in a UIElement
2931
// wrapper class, not in the DependencyObject wrapper.
2932
case MoonId_CaptureMouse:
2933
BOOLEAN_TO_NPVARIANT (((UIElement*)dob)->CaptureMouse (), *result);
2935
case MoonId_ReleaseMouseCapture:
2936
((UIElement*)dob)->ReleaseMouseCapture ();
2938
VOID_TO_NPVARIANT (*result);
2941
return MoonlightObject::Invoke (id, name, args, argCount, result);
2946
MoonlightDependencyObjectType::MoonlightDependencyObjectType ()
2948
allocate = moonlight_dependency_object_allocate;
2950
AddMapping (moonlight_dependency_object_mapping, G_N_ELEMENTS (moonlight_dependency_object_mapping));
2955
/*** MoonlightEventObjectClass ***************************************************/
2958
moonlight_event_object_allocate (NPP instance, NPClass *klass)
2960
return new MoonlightEventObjectObject (instance);
2963
MoonlightEventObjectObject::~MoonlightEventObjectObject ()
2966
PluginInstance *plugin;
2967
if ((plugin = (PluginInstance *) instance->pdata))
2968
plugin->RemoveWrappedObject (eo);
2970
moonlight_type = Type::INVALID;
2977
MoonlightEventObjectType::MoonlightEventObjectType ()
2979
allocate = moonlight_event_object_allocate;
2982
MoonlightEventObjectType *MoonlightEventObjectClass;
2984
MoonlightEventObjectObject *
2985
EventObjectCreateWrapper (NPP instance, EventObject *obj)
2987
PluginInstance *plugin = (PluginInstance *) instance->pdata;
2988
MoonlightEventObjectObject *depobj;
2991
depobj = (MoonlightEventObjectObject *) plugin->LookupWrappedObject (obj);
2994
NPN_RetainObject (depobj);
2998
/* for EventObject subclasses which have special plugin classes, check here */
2999
Type::Kind kind = obj->GetObjectType ();
3001
case Type::STORYBOARD:
3002
np_class = dependency_object_classes [STORYBOARD_CLASS];
3004
case Type::MEDIAELEMENT:
3005
np_class = dependency_object_classes [MEDIA_ELEMENT_CLASS];
3007
case Type::DOWNLOADER:
3008
np_class = dependency_object_classes [DOWNLOADER_CLASS];
3011
np_class = dependency_object_classes [CONTROL_CLASS];
3014
np_class = dependency_object_classes [IMAGE_CLASS];
3016
case Type::IMAGEBRUSH:
3017
np_class = dependency_object_classes [IMAGE_BRUSH_CLASS];
3019
case Type::TEXTBLOCK:
3020
np_class = dependency_object_classes [TEXT_BLOCK_CLASS];
3022
case Type::EVENTOBJECT:
3024
np_class = MoonlightEventObjectClass;
3025
case Type::STYLUSINFO:
3026
np_class = dependency_object_classes [STYLUS_INFO_CLASS];
3028
case Type::STYLUSPOINT_COLLECTION:
3029
np_class = dependency_object_classes [STYLUS_POINT_COLLECTION_CLASS];
3031
case Type::STROKE_COLLECTION:
3032
np_class = dependency_object_classes [STROKE_COLLECTION_CLASS];
3035
np_class = dependency_object_classes [STROKE_CLASS];
3037
case Type::ROUTEDEVENTARGS:
3038
np_class = dependency_object_classes [ROUTED_EVENT_ARGS_CLASS];
3040
case Type::MOUSEEVENTARGS:
3041
np_class = dependency_object_classes [MOUSE_EVENT_ARGS_CLASS];
3043
case Type::KEYEVENTARGS:
3044
np_class = dependency_object_classes [KEY_EVENT_ARGS_CLASS];
3046
case Type::MARKERREACHEDEVENTARGS:
3047
np_class = dependency_object_classes [MARKER_REACHED_EVENT_ARGS_CLASS];
3049
case Type::ERROREVENTARGS:
3050
case Type::PARSERERROREVENTARGS:
3051
case Type::IMAGEERROREVENTARGS:
3052
case Type::MEDIAERROREVENTARGS:
3053
np_class = dependency_object_classes [ERROR_EVENT_ARGS_CLASS];
3056
if (Type::Find (kind)->IsSubclassOf (Type::COLLECTION))
3057
np_class = dependency_object_classes [COLLECTION_CLASS];
3058
else if (Type::Find (kind)->IsSubclassOf (Type::EVENTARGS))
3059
np_class = dependency_object_classes [EVENT_ARGS_CLASS];
3061
np_class = dependency_object_classes [DEPENDENCY_OBJECT_CLASS];
3064
depobj = (MoonlightEventObjectObject *) NPN_CreateObject (instance, np_class);
3065
depobj->moonlight_type = obj->GetObjectType ();
3069
plugin->AddWrappedObject (obj, depobj);
3076
/*** MoonlightCollectionClass ***************************************************/
3079
moonlight_collection_allocate (NPP instance, NPClass *klass)
3081
return new MoonlightCollectionObject (instance);
3084
static const MoonNameIdMapping
3085
moonlight_collection_mapping [] = {
3086
{ "add", MoonId_Add },
3087
{ "clear", MoonId_Clear },
3088
{ "count", MoonId_Count },
3089
{ "getitem", MoonId_GetItem },
3090
{ "getitembyname", MoonId_GetItemByName },
3091
{ "insert", MoonId_Insert },
3092
{ "remove", MoonId_Remove },
3093
{ "removeat", MoonId_RemoveAt },
3097
MoonlightCollectionObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
3099
Collection *col = (Collection *) GetDependencyObject ();
3103
INT32_TO_NPVARIANT (col->GetCount (), *result);
3106
return MoonlightDependencyObjectObject::GetProperty (id, name, result);
3111
MoonlightCollectionObject::Invoke (int id, NPIdentifier name,
3112
const NPVariant *args, uint32_t argCount,
3115
Collection *col = (Collection *) GetDependencyObject ();
3119
if (!check_arg_list ("o", argCount, args) ||
3120
!npvariant_is_dependency_object (args[0]))
3121
THROW_JS_EXCEPTION ("add");
3123
MoonlightDependencyObjectObject *el = (MoonlightDependencyObjectObject *) NPVARIANT_TO_OBJECT (args[0]);
3124
int n = col->Add (Value (el->GetDependencyObject ()));
3127
THROW_JS_EXCEPTION ("add");
3129
INT32_TO_NPVARIANT (n, *result);
3133
case MoonId_Remove: {
3134
if (!check_arg_list ("o", argCount, args) ||
3135
!npvariant_is_dependency_object (args[0]))
3136
THROW_JS_EXCEPTION ("remove");
3138
MoonlightDependencyObjectObject *el = (MoonlightDependencyObjectObject *) NPVARIANT_TO_OBJECT (args[0]);
3139
bool res = col->Remove (Value (el->GetDependencyObject ()));
3141
BOOLEAN_TO_NPVARIANT (res, *result);
3145
case MoonId_RemoveAt: {
3146
if (!check_arg_list ("i", argCount, args))
3147
THROW_JS_EXCEPTION ("removeAt");
3149
int index = NPVARIANT_TO_INT32 (args [0]);
3151
if (index < 0 || index >= col->GetCount ())
3152
THROW_JS_EXCEPTION ("removeAt");
3154
DependencyObject *obj = col->GetValueAt (index)->AsDependencyObject ();
3155
OBJECT_TO_NPVARIANT (EventObjectCreateWrapper (instance, obj), *result);
3157
col->RemoveAt (index);
3161
case MoonId_Insert: {
3162
if (!check_arg_list ("i[o]", argCount, args))
3163
THROW_JS_EXCEPTION ("insert");
3166
VOID_TO_NPVARIANT (*result);
3170
if (!npvariant_is_dependency_object (args[1]))
3171
THROW_JS_EXCEPTION ("insert");
3173
MoonlightDependencyObjectObject *el = (MoonlightDependencyObjectObject*) NPVARIANT_TO_OBJECT (args[1]);
3174
int index = NPVARIANT_TO_INT32 (args[0]);
3176
if (!col->Insert (index, Value (el->GetDependencyObject ())))
3177
THROW_JS_EXCEPTION ("insert");
3179
VOID_TO_NPVARIANT (*result);
3183
case MoonId_Clear: {
3185
THROW_JS_EXCEPTION ("clear");
3189
VOID_TO_NPVARIANT (*result);
3193
case MoonId_GetItem: {
3194
if (!check_arg_list ("i", argCount, args))
3195
THROW_JS_EXCEPTION ("getItem");
3197
int index = NPVARIANT_TO_INT32 (args[0]);
3200
THROW_JS_EXCEPTION ("getItem");
3202
if (index >= col->GetCount ()) {
3203
NULL_TO_NPVARIANT (*result);
3207
DependencyObject *obj = col->GetValueAt (index)->AsDependencyObject ();
3208
OBJECT_TO_NPVARIANT (EventObjectCreateWrapper (instance, obj), *result);
3212
case MoonId_GetItemByName: {
3213
if (col->GetObjectType () != Type::MEDIAATTRIBUTE_COLLECTION ||
3214
!check_arg_list ("s", argCount, args))
3215
THROW_JS_EXCEPTION ("getItemByName");
3217
char *name = STRDUP_FROM_VARIANT (args[0]);
3218
DependencyObject *obj = ((MediaAttributeCollection *) col)->GetItemByName (name);
3221
OBJECT_TO_NPVARIANT (EventObjectCreateWrapper (instance, obj), *result);
3226
return MoonlightDependencyObjectObject::Invoke (id, name, args, argCount, result);
3231
MoonlightCollectionType::MoonlightCollectionType ()
3233
AddMapping (moonlight_collection_mapping, G_N_ELEMENTS (moonlight_collection_mapping));
3235
allocate = moonlight_collection_allocate;
3239
/*** MoonlightStoryboardClass ***************************************************/
3242
moonlight_storyboard_allocate (NPP instance, NPClass *klass)
3244
return new MoonlightStoryboardObject (instance);
3247
static const MoonNameIdMapping
3248
moonlight_storyboard_mapping [] = {
3249
{ "begin", MoonId_Begin },
3250
{ "completed", MoonId_Completed },
3251
{ "pause", MoonId_Pause },
3252
{ "resume", MoonId_Resume },
3253
{ "seek", MoonId_Seek },
3254
{ "stop", MoonId_Stop }
3258
MoonlightStoryboardObject::Invoke (int id, NPIdentifier name,
3259
const NPVariant *args, uint32_t argCount,
3262
Storyboard *sb = (Storyboard*)GetDependencyObject ();
3266
if (argCount != 0 || !sb->Begin ())
3267
THROW_JS_EXCEPTION ("begin");
3269
VOID_TO_NPVARIANT (*result);
3274
THROW_JS_EXCEPTION ("pause");
3278
VOID_TO_NPVARIANT (*result);
3283
THROW_JS_EXCEPTION ("resume");
3287
VOID_TO_NPVARIANT (*result);
3291
if (!check_arg_list ("(is)", argCount, args))
3292
THROW_JS_EXCEPTION ("seek");
3297
if (NPVARIANT_IS_INT32 (args[0])) {
3298
ts = (TimeSpan) NPVARIANT_TO_INT32 (args[0]);
3299
} else if (NPVARIANT_IS_STRING (args[0])) {
3300
char *span = STRDUP_FROM_VARIANT (args[0]);
3301
ok = time_span_from_str (span, &ts);
3305
THROW_JS_EXCEPTION ("seek");
3310
VOID_TO_NPVARIANT (*result);
3316
THROW_JS_EXCEPTION ("stop");
3320
VOID_TO_NPVARIANT (*result);
3324
return MoonlightDependencyObjectObject::Invoke (id, name, args, argCount, result);
3328
MoonlightStoryboardType::MoonlightStoryboardType ()
3330
AddMapping (moonlight_storyboard_mapping, G_N_ELEMENTS (moonlight_storyboard_mapping));
3332
allocate = moonlight_storyboard_allocate;
3336
/*** MoonlightMediaElementClass ***************************************************/
3339
moonlight_media_element_allocate (NPP instance, NPClass *)
3341
return new MoonlightMediaElementObject (instance);
3344
static const MoonNameIdMapping
3345
moonlight_media_element_mapping [] = {
3346
{ "bufferingprogresschanged", MoonId_BufferingProgressChanged },
3347
{ "currentstatechanged", MoonId_CurrentStateChanged },
3348
{ "downloadprogresschanged", MoonId_DownloadProgressChanged },
3349
{ "markerreached", MoonId_MarkerReached },
3350
{ "mediaended", MoonId_MediaEnded },
3351
{ "mediafailed", MoonId_MediaFailed },
3352
{ "mediaopened", MoonId_MediaOpened },
3353
{ "pause", MoonId_Pause },
3354
{ "play", MoonId_Play },
3355
{ "setsource", MoonId_SetSource },
3356
{ "stop", MoonId_Stop },
3360
MoonlightMediaElementObject::Invoke (int id, NPIdentifier name,
3361
const NPVariant *args, uint32_t argCount,
3364
MediaElement *media = (MediaElement*)GetDependencyObject ();
3369
THROW_JS_EXCEPTION ("play");
3373
VOID_TO_NPVARIANT (*result);
3379
THROW_JS_EXCEPTION ("pause");
3383
VOID_TO_NPVARIANT (*result);
3389
THROW_JS_EXCEPTION ("stop");
3393
VOID_TO_NPVARIANT (*result);
3397
case MoonId_SetSource: {
3398
if (!check_arg_list ("os", argCount, args) ||
3399
!npvariant_is_downloader (args[0]))
3400
THROW_JS_EXCEPTION ("AG_E_RUNTIME_METHOD");
3402
DependencyObject *downloader = ((MoonlightDependencyObjectObject *) NPVARIANT_TO_OBJECT (args[0]))->GetDependencyObject ();
3404
char *part = STRDUP_FROM_VARIANT (args [1]);
3405
media->SetSource ((Downloader *) downloader, part);
3408
VOID_TO_NPVARIANT (*result);
3414
return MoonlightDependencyObjectObject::Invoke (id, name, args, argCount, result);
3418
MoonlightMediaElementType::MoonlightMediaElementType ()
3420
AddMapping (moonlight_media_element_mapping, G_N_ELEMENTS (moonlight_media_element_mapping));
3422
allocate = moonlight_media_element_allocate;
3426
/*** MoonlightImageClass ***************************************************/
3429
moonlight_image_allocate (NPP instance, NPClass *klass)
3431
return new MoonlightImageObject (instance);
3434
static const MoonNameIdMapping
3435
moonlight_image_mapping [] = {
3436
{ "downloadprogresschanged", MoonId_DownloadProgressChanged },
3437
{ "imagefailed", MoonId_ImageFailed },
3438
{ "setsource", MoonId_SetSource }
3443
MoonlightImageObject::Invoke (int id, NPIdentifier name,
3444
const NPVariant *args, uint32_t argCount,
3447
Image *img = (Image *) GetDependencyObject ();
3448
DependencyObject *downloader;
3452
case MoonId_SetSource:
3453
if (!check_arg_list ("os", argCount, args) ||
3454
!npvariant_is_downloader (args[0]))
3455
THROW_JS_EXCEPTION ("AG_E_RUNTIME_METHOD");
3457
downloader = ((MoonlightDependencyObjectObject *) NPVARIANT_TO_OBJECT (args[0]))->GetDependencyObject ();
3459
part = STRDUP_FROM_VARIANT (args [1]);
3460
img->SetSource ((Downloader *) downloader, part);
3463
VOID_TO_NPVARIANT (*result);
3467
return MoonlightDependencyObjectObject::Invoke (id, name, args, argCount, result);
3471
MoonlightImageType::MoonlightImageType ()
3473
AddMapping (moonlight_image_mapping, G_N_ELEMENTS (moonlight_image_mapping));
3475
allocate = moonlight_image_allocate;
3479
/*** MoonlightImageBrushClass ***************************************************/
3482
moonlight_image_brush_allocate (NPP instance, NPClass *klass)
3484
return new MoonlightImageBrushObject (instance);
3488
static const MoonNameIdMapping
3489
moonlight_image_brush_mapping [] = {
3490
{ "downloadprogresschanged", MoonId_DownloadProgressChanged },
3491
{ "setsource", MoonId_SetSource }
3496
MoonlightImageBrushObject::Invoke (int id, NPIdentifier name,
3497
const NPVariant *args, uint32_t argCount,
3500
ImageBrush *img = (ImageBrush *) GetDependencyObject ();
3501
DependencyObject *downloader;
3504
case MoonId_SetSource: {
3505
if (!check_arg_list ("os", argCount, args) ||
3506
!npvariant_is_downloader (args[0]))
3507
THROW_JS_EXCEPTION ("setSource");
3509
downloader = ((MoonlightDependencyObjectObject *) NPVARIANT_TO_OBJECT (args[0]))->GetDependencyObject ();
3511
char *part = STRDUP_FROM_VARIANT (args [1]);
3512
img->SetSource ((Downloader *) downloader, part);
3515
VOID_TO_NPVARIANT (*result);
3521
return MoonlightDependencyObjectObject::Invoke (id, name, args, argCount, result);
3525
MoonlightImageBrushType::MoonlightImageBrushType ()
3527
AddMapping (moonlight_image_brush_mapping, G_N_ELEMENTS (moonlight_image_brush_mapping));
3529
allocate = moonlight_image_brush_allocate;
3533
/*** MoonlightTextBlockClass ***************************************************/
3536
moonlight_text_block_allocate (NPP instance, NPClass *klass)
3538
return new MoonlightTextBlockObject (instance);
3542
static const MoonNameIdMapping moonlight_text_block_mapping[] = {
3543
{ "setfontsource", MoonId_SetFontSource }
3548
MoonlightTextBlockObject::Invoke (int id, NPIdentifier name,
3549
const NPVariant *args, uint32_t argCount,
3552
TextBlock *tb = (TextBlock *) GetDependencyObject ();
3553
DependencyObject *downloader = NULL;
3556
case MoonId_SetFontSource:
3557
if (!check_arg_list ("(no)", argCount, args) && (!NPVARIANT_IS_NULL(args[0]) || !npvariant_is_downloader (args[0])))
3558
THROW_JS_EXCEPTION ("setFontSource");
3560
if (NPVARIANT_IS_OBJECT (args[0]))
3561
downloader = ((MoonlightDependencyObjectObject *) NPVARIANT_TO_OBJECT (args[0]))->GetDependencyObject ();
3563
tb->SetFontSource ((Downloader *) downloader);
3565
VOID_TO_NPVARIANT (*result);
3569
return MoonlightDependencyObjectObject::Invoke (id, name, args, argCount, result);
3573
MoonlightTextBlockType::MoonlightTextBlockType ()
3575
AddMapping (moonlight_text_block_mapping, G_N_ELEMENTS (moonlight_text_block_mapping));
3577
allocate = moonlight_text_block_allocate;
3581
/*** MoonlightStylusInfoClass ***************************************************/
3584
moonlight_stylus_info_allocate (NPP instance, NPClass *klass)
3586
return new MoonlightStylusInfoObject (instance);
3589
static const MoonNameIdMapping
3590
moonlight_stylus_info_mapping [] = {
3591
{ "devicetype", MoonId_DeviceType },
3592
{ "isinverted", MoonId_IsInverted },
3596
MoonlightStylusInfoObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
3598
StylusInfo *info = (StylusInfo *) GetDependencyObject ();
3601
case MoonId_DeviceType: {
3602
switch (info->GetDeviceType ()) {
3603
case TabletDeviceTypeMouse:
3604
string_to_npvariant ("Mouse", result);
3606
case TabletDeviceTypeStylus:
3607
string_to_npvariant ("Stylus", result);
3609
case TabletDeviceTypeTouch:
3610
string_to_npvariant ("Touch", result);
3613
THROW_JS_EXCEPTION ("deviceType");
3617
case MoonId_IsInverted: {
3618
BOOLEAN_TO_NPVARIANT (info->GetIsInverted (), *result);
3623
return MoonlightDependencyObjectObject::GetProperty (id, name, result);
3627
MoonlightStylusInfoType::MoonlightStylusInfoType ()
3629
AddMapping (moonlight_stylus_info_mapping, G_N_ELEMENTS (moonlight_stylus_info_mapping));
3631
allocate = moonlight_stylus_info_allocate;
3635
/*** MoonlightStylusPointCollectionClass ****************************************/
3638
moonlight_stylus_point_collection_allocate (NPP instance, NPClass *klass)
3640
return new MoonlightStylusPointCollectionObject (instance);
3643
static const MoonNameIdMapping
3644
moonlight_stylus_point_collection_mapping [] = {
3645
{ "addstyluspoints", MoonId_AddStylusPoints },
3649
MoonlightStylusPointCollectionObject::Invoke (int id, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result)
3651
StylusPointCollection *col = (StylusPointCollection *) GetDependencyObject ();
3654
case MoonId_AddStylusPoints: {
3655
if (!col || !check_arg_list ("o", argCount, args))
3658
MoonlightStylusPointCollectionObject *spco = (MoonlightStylusPointCollectionObject*) NPVARIANT_TO_OBJECT(args[0]);
3659
double ret = col->AddStylusPoints ((StylusPointCollection*) spco->GetDependencyObject ());
3660
DOUBLE_TO_NPVARIANT (ret, *result);
3664
return MoonlightCollectionObject::Invoke (id, name, args, argCount, result);
3668
MoonlightStylusPointCollectionType::MoonlightStylusPointCollectionType ()
3670
AddMapping (moonlight_stylus_point_collection_mapping, G_N_ELEMENTS (moonlight_stylus_point_collection_mapping));
3672
allocate = moonlight_stylus_point_collection_allocate;
3676
/*** MoonlightStrokeCollectionClass ****************************************/
3679
moonlight_stroke_collection_allocate (NPP instance, NPClass *klass)
3681
return new MoonlightStrokeCollectionObject (instance);
3684
static const MoonNameIdMapping
3685
moonlight_stroke_collection_mapping [] = {
3686
{ "getbounds", MoonId_GetBounds },
3687
{ "hittest", MoonId_HitTest }
3691
MoonlightStrokeCollectionObject::Invoke (int id, NPIdentifier name,
3692
const NPVariant *args, uint32_t argCount, NPVariant *result)
3694
StrokeCollection *col = (StrokeCollection *) GetDependencyObject ();
3697
case MoonId_GetBounds: {
3698
Rect r = col->GetBounds ();
3700
value_to_variant (this, &v, result);
3704
case MoonId_HitTest: {
3705
if (!check_arg_list ("o", argCount, args) ||
3706
!npvariant_is_dependency_object (args[0]))
3707
THROW_JS_EXCEPTION ("hitTest");
3709
DependencyObject *dob = DEPENDENCY_OBJECT_FROM_VARIANT (args [0]);
3710
if (!dob->Is (Type::STYLUSPOINT_COLLECTION))
3711
THROW_JS_EXCEPTION ("hitTest");
3713
StrokeCollection *hit_col = col->HitTest ((StylusPointCollection*)dob);
3715
OBJECT_TO_NPVARIANT (EventObjectCreateWrapper (instance, hit_col), *result);
3721
return MoonlightCollectionObject::Invoke (id, name, args, argCount, result);
3725
MoonlightStrokeCollectionType::MoonlightStrokeCollectionType ()
3727
AddMapping (moonlight_stroke_collection_mapping, G_N_ELEMENTS (moonlight_stroke_collection_mapping));
3729
allocate = moonlight_stroke_collection_allocate;
3733
/*** MoonlightStrokeClass ****************************************/
3736
moonlight_stroke_allocate (NPP instance, NPClass *klass)
3738
return new MoonlightStrokeObject (instance);
3741
static const MoonNameIdMapping
3742
moonlight_stroke_mapping [] = {
3743
{ "getbounds", MoonId_GetBounds },
3744
{ "hittest", MoonId_HitTest }
3748
MoonlightStrokeObject::Invoke (int id, NPIdentifier name,
3749
const NPVariant *args, uint32_t argCount, NPVariant *result)
3751
Stroke *stroke = (Stroke *) GetDependencyObject ();
3754
case MoonId_GetBounds: {
3755
Rect r = stroke->GetBounds ();
3757
value_to_variant (this, &v, result);
3761
case MoonId_HitTest: {
3762
if (!check_arg_list ("o", argCount, args) ||
3763
!npvariant_is_dependency_object (args[0]))
3764
THROW_JS_EXCEPTION ("hitTest");
3766
DependencyObject *dob = DEPENDENCY_OBJECT_FROM_VARIANT (args [0]);
3767
if (!dob->Is (Type::STYLUSPOINT_COLLECTION))
3768
THROW_JS_EXCEPTION ("hitTest");
3770
BOOLEAN_TO_NPVARIANT (stroke->HitTest ((StylusPointCollection*)dob), *result);
3775
return MoonlightDependencyObjectObject::Invoke (id, name, args, argCount, result);
3779
MoonlightStrokeType::MoonlightStrokeType ()
3781
AddMapping (moonlight_stroke_mapping, G_N_ELEMENTS (moonlight_stroke_mapping));
3783
allocate = moonlight_stroke_allocate;
3787
/*** MoonlightDownloaderClass ***************************************************/
3790
moonlight_downloader_allocate (NPP instance, NPClass *klass)
3792
return new MoonlightDownloaderObject (instance);
3796
static const MoonNameIdMapping
3797
moonlight_downloader_mapping [] = {
3798
{ "abort", MoonId_Abort },
3799
{ "completed", MoonId_Completed },
3800
{ "downloadprogresschanged", MoonId_DownloadProgressChanged },
3801
{ "getresponsetext", MoonId_GetResponseText },
3802
{ "open", MoonId_Open },
3803
{ "responsetext", MoonId_ResponseText },
3804
{ "send", MoonId_Send }
3808
MoonlightDownloaderObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
3810
Downloader *downloader = (Downloader *) GetDependencyObject ();
3815
case MoonId_ResponseText:
3816
if ((text = downloader->GetResponseText (NULL, &size))) {
3817
char *s = (char *) NPN_MemAlloc (size + 1);
3818
memcpy (s, text, size + 1);
3821
STRINGN_TO_NPVARIANT (s, (uint32_t) size, *result);
3823
NULL_TO_NPVARIANT (*result);
3828
return MoonlightDependencyObjectObject::GetProperty (id, name, result);
3833
MoonlightDownloaderObject::Invoke (int id, NPIdentifier name,
3834
const NPVariant *args, uint32_t argCount,
3837
Downloader *downloader = (Downloader *) GetDependencyObject ();
3838
char *part, *verb, *uri, *text;
3844
THROW_JS_EXCEPTION ("abort");
3846
downloader->Abort ();
3848
VOID_TO_NPVARIANT (*result);
3852
if (!check_arg_list ("s(ns)", argCount, args))
3853
THROW_JS_EXCEPTION ("open");
3855
verb = STRDUP_FROM_VARIANT (args[0]);
3857
if (NPVARIANT_IS_STRING (args[1]))
3858
uri = STRDUP_FROM_VARIANT (args[1]);
3862
downloader->Open (verb, uri, DownloaderPolicy);
3866
VOID_TO_NPVARIANT (*result);
3870
if (argCount != 0 || downloader->GetSurface () == NULL)
3871
THROW_JS_EXCEPTION ("send");
3873
downloader->Send ();
3875
VOID_TO_NPVARIANT (*result);
3878
case MoonId_GetResponseText:
3879
if (!check_arg_list ("s", argCount, args))
3880
THROW_JS_EXCEPTION ("getResponseText");
3882
part = STRDUP_FROM_VARIANT (args[0]);
3883
if ((text = downloader->GetResponseText (part, &size))) {
3884
char *s = (char *) NPN_MemAlloc (size + 1);
3885
memcpy (s, text, size + 1);
3888
STRINGN_TO_NPVARIANT (s, (uint32_t) size, *result);
3890
NULL_TO_NPVARIANT (*result);
3896
return MoonlightDependencyObjectObject::Invoke (id, name, args, argCount, result);
3900
MoonlightDownloaderType::MoonlightDownloaderType ()
3902
AddMapping (moonlight_downloader_mapping, G_N_ELEMENTS (moonlight_downloader_mapping));
3904
allocate = moonlight_downloader_allocate;
3908
/*** MoonlightScriptableObjectClass ***************************************************/
3910
// FIXME: the property/method hashes here are case sensitive
3912
struct ScriptableProperty {
3913
gpointer property_handle;
3919
struct ScriptableEvent {
3920
gpointer event_handle;
3923
struct ScriptableMethod {
3924
gpointer method_handle;
3925
int method_return_type;
3926
int *method_parameter_types;
3927
int parameter_count;
3932
moonlight_scriptable_object_allocate (NPP instance, NPClass *klass)
3934
return new MoonlightScriptableObjectObject (instance);
3937
MoonlightScriptableObjectObject::~MoonlightScriptableObjectObject ()
3939
if (managed_scriptable) {
3940
// FIXME: unref the scriptable object however we need to.
3941
managed_scriptable = NULL;
3944
// FIXME: free the properties, events, and methods hashes.
3948
MoonlightScriptableObjectObject::HasProperty (NPIdentifier name)
3950
return (g_hash_table_lookup (properties, name) != NULL
3951
|| g_hash_table_lookup (events, name)) || MoonlightObject::HasProperty (name);
3955
MoonlightScriptableObjectObject::GetProperty (int id, NPIdentifier name, NPVariant *result)
3957
ScriptableProperty *prop = (ScriptableProperty*)g_hash_table_lookup (properties, name);
3959
return MoonlightObject::GetProperty (id, name, result);
3962
NPUTF8 *strname = NPN_UTF8FromIdentifier (name);
3963
printf ("getting scriptable object property %s\n", strname);
3964
NPN_MemFree (strname);
3969
getprop (managed_scriptable, prop->property_handle, &v);
3971
value_to_variant (this, &v, result);
3977
MoonlightScriptableObjectObject::SetProperty (int id, NPIdentifier name, const NPVariant *value)
3979
ScriptableProperty *prop;
3980
ScriptableEvent *event;
3983
// first we try the property hash
3984
if ((prop = (ScriptableProperty *) g_hash_table_lookup (properties, name))) {
3986
NPUTF8 *strname = NPN_UTF8FromIdentifier (name);
3987
printf ("setting scriptable object property %s\n", strname);
3988
NPN_MemFree (strname);
3991
variant_to_value (value, &v);
3992
setprop (managed_scriptable, prop->property_handle, v);
3998
// if that fails, look for the event of that name
3999
if ((event = (ScriptableEvent *) g_hash_table_lookup (events, name))) {
4001
NPUTF8 *strname = NPN_UTF8FromIdentifier (name);
4002
printf ("adding scriptable object event %s\n", strname);
4003
NPN_MemFree (strname);
4006
if (NPVARIANT_IS_OBJECT (*value)) {
4007
NPObject *cb_obj = NPVARIANT_TO_OBJECT (*value);
4009
NPN_RetainObject (cb_obj);
4011
addevent (managed_scriptable, event->event_handle, this, cb_obj);
4013
DEBUG_WARN_NOTIMPLEMENTED ("scriptableobject.register_event (non-object)");
4019
return MoonlightObject::SetProperty (id, name, value);
4023
MoonlightScriptableObjectObject::HasMethod (NPIdentifier name)
4025
return g_hash_table_lookup (methods, name) != NULL;
4029
MoonlightScriptableObjectObject::Invoke (int id, NPIdentifier name,
4030
const NPVariant *args, uint32_t argCount,
4033
ScriptableMethod *method = (ScriptableMethod*)g_hash_table_lookup (methods, name);
4034
Value rv, **vargs = NULL;
4038
return MoonlightObject::Invoke (id, name, args, argCount, result);
4041
NPUTF8 *strname = NPN_UTF8FromIdentifier (name);
4042
printf ("invoking scriptable object method %s\n", strname);
4043
NPN_MemFree (strname);
4047
vargs = new Value*[argCount];
4048
for (i = 0; i < argCount; i++)
4049
variant_to_value (&args[i], &vargs[i]);
4052
invoke (managed_scriptable, method->method_handle, vargs, argCount, &rv);
4055
for (i = 0; i < argCount; i++)
4061
/* Note: this 1 is "void" */
4062
if (method->method_return_type != 1)
4063
value_to_variant (this, &rv, result);
4069
MoonlightScriptableObjectType::MoonlightScriptableObjectType ()
4071
allocate = moonlight_scriptable_object_allocate;
4074
MoonlightScriptableObjectType *MoonlightScriptableObjectClass;
4076
MoonlightScriptableObjectObject *
4077
moonlight_scriptable_object_wrapper_create (PluginInstance *plugin, gpointer scriptable,
4078
InvokeDelegate invoke_func,
4079
SetPropertyDelegate setprop_func,
4080
GetPropertyDelegate getprop_func,
4081
EventHandlerDelegate addevent_func,
4082
EventHandlerDelegate removeevent_func)
4085
MoonlightScriptControlObject *root_object = plugin->GetRootObject ();
4087
MoonlightScriptableObjectObject *obj = (MoonlightScriptableObjectObject *)
4088
NPN_CreateObject (((MoonlightObject *) root_object)->instance,
4089
MoonlightScriptableObjectClass);
4091
obj->managed_scriptable = scriptable;
4092
obj->invoke = invoke_func;
4093
obj->setprop = setprop_func;
4094
obj->getprop = getprop_func;
4095
obj->addevent = addevent_func;
4096
obj->removeevent = removeevent_func;
4098
ds(printf ("creating scriptable object wrapper => %p\n", obj));
4104
moonlight_scriptable_object_add_property (PluginInstance *plugin,
4105
MoonlightScriptableObjectObject *obj,
4106
gpointer property_handle,
4107
char *property_name,
4112
ds(printf ("adding property named %s to scriptable object %p\n", property_name, obj));
4114
ScriptableProperty *prop = new ScriptableProperty ();
4115
prop->property_handle = property_handle;
4116
prop->property_type = property_type;
4117
prop->can_read = can_read;
4118
prop->can_write = can_write;
4120
g_hash_table_insert (obj->properties, NPID(property_name), prop);
4124
moonlight_scriptable_object_add_event (PluginInstance *plugin,
4125
MoonlightScriptableObjectObject *obj,
4126
gpointer event_handle,
4129
ds(printf ("adding event named %s to scriptable object %p\n", event_name, obj));
4131
ScriptableEvent *event = new ScriptableEvent ();
4132
event->event_handle = event_handle;
4134
g_hash_table_insert (obj->events, NPID(event_name), event);
4138
moonlight_scriptable_object_add_method (PluginInstance *plugin,
4139
MoonlightScriptableObjectObject *obj,
4140
gpointer method_handle,
4142
int method_return_type,
4143
int *method_parameter_types,
4144
int parameter_count)
4147
ds(printf ("adding method named %s (return type = %d) to scriptable object %p\n", method_name, method_return_type, obj));
4149
ScriptableMethod *method = new ScriptableMethod ();
4150
method->method_handle = method_handle;
4151
method->method_return_type = method_return_type;
4152
method->method_parameter_types = new int[parameter_count];
4153
memcpy (method->method_parameter_types, method_parameter_types, sizeof (int) * parameter_count);
4154
method->parameter_count = parameter_count;
4156
g_hash_table_insert (obj->methods, NPID(method_name), method);
4160
moonlight_scriptable_object_register (PluginInstance *plugin,
4162
MoonlightScriptableObjectObject *obj)
4164
ds(printf ("registering scriptable object '%s' => %p\n", name, obj));
4166
MoonlightContentObject *content = (MoonlightContentObject *) plugin->GetRootObject ()->content;
4168
g_hash_table_insert (content->registered_scriptable_objects, NPID (name), obj);
4170
ds(printf (" => done\n"));
4174
moonlight_scriptable_object_emit_event (PluginInstance *plugin,
4175
MoonlightScriptableObjectObject *sobj,
4176
MoonlightScriptableObjectObject *event_args,
4182
OBJECT_TO_NPVARIANT (sobj, args[0]);
4183
OBJECT_TO_NPVARIANT (event_args, args[1]);
4185
if (NPN_InvokeDefault (plugin->GetInstance (), cb_obj, args, 2, &result))
4186
NPN_ReleaseVariantValue (&result);
4190
/****************************** HtmlObject *************************/
4193
html_object_get_property (PluginInstance *plugin, NPObject *npobj, char *name, Value *result)
4196
NPObject *window = NULL;
4197
NPP npp = plugin->GetInstance ();
4198
NPIdentifier identifier = NPN_GetStringIdentifier (name);
4200
if (npobj == NULL) {
4201
NPN_GetValue (npp, NPNVWindowNPObject, &window);
4205
NPN_GetProperty (npp, npobj, identifier, &npresult);
4208
if (!NPVARIANT_IS_VOID (npresult) && !NPVARIANT_IS_NULL (npresult)) {
4209
variant_to_value (&npresult, &res);
4212
*result = Value (Type::INVALID);
4217
html_object_set_property (PluginInstance *plugin, NPObject *npobj, char *name, Value *value)
4220
NPObject *window = NULL;
4221
NPP npp = plugin->GetInstance ();
4222
NPIdentifier identifier = NPN_GetStringIdentifier (name);
4224
if (npobj == NULL) {
4225
NPN_GetValue (npp, NPNVWindowNPObject, &window);
4229
value_to_variant (npobj, value, &npvalue);
4231
NPN_SetProperty (npp, npobj, identifier, &npvalue);
4235
html_object_invoke (PluginInstance *plugin, NPObject *npobj, char *name,
4236
Value *args, uint32_t arg_count, Value *result)
4239
NPVariant *npargs = NULL;
4240
NPObject *window = NULL;
4241
NPP npp = plugin->GetInstance ();
4242
NPIdentifier identifier = NPN_GetStringIdentifier (name);
4244
if (npobj == NULL) {
4245
NPN_GetValue (npp, NPNVWindowNPObject, &window);
4250
npargs = new NPVariant [arg_count];
4251
for (uint32_t i = 0; i < arg_count; i++)
4252
value_to_variant (npobj, &args [i], &npargs [i]);
4255
NPN_Invoke (npp, npobj, identifier, npargs, arg_count, &npresult);
4258
for (uint32_t i = 0; i < arg_count; i++)
4259
NPN_ReleaseVariantValue (&npargs [i]);
4263
if (!NPVARIANT_IS_VOID (npresult) && !NPVARIANT_IS_NULL (npresult)) {
4264
variant_to_value (&npresult, &res);
4267
*result = Value (Type::INVALID);
4272
html_get_element_text (PluginInstance *plugin, const char *element_id)
4274
if (!plugin->GetBridge())
4276
return plugin->GetBridge()->HtmlElementGetText(plugin->GetInstance(), element_id);
4280
html_object_attach_event (PluginInstance *plugin, NPObject *npobj, char *name, callback_dom_event *cb)
4282
if (!plugin->GetBridge())
4284
return plugin->GetBridge()->HtmlObjectAttachEvent (plugin->GetInstance(), npobj, name, cb);
4288
html_object_detach_event (PluginInstance *plugin, const char *name, gpointer listener_ptr)
4290
if (!plugin->GetBridge())
4292
plugin->GetBridge()->HtmlObjectDetachEvent (plugin->GetInstance(), name, listener_ptr);
4296
html_object_release (PluginInstance *plugin, NPObject *npobj)
4298
NPN_ReleaseObject (npobj);
4302
browser_do_alert (PluginInstance *plugin, char *msg)
4305
NPVariant *npargs = new NPVariant [1];
4306
NPObject *window = NULL;
4307
NPP npp = plugin->GetInstance ();
4308
NPIdentifier identifier = NPN_GetStringIdentifier ("alert");
4310
NPN_GetValue (npp, NPNVWindowNPObject, &window);
4311
string_to_npvariant (msg, &npargs [0]);
4313
NPN_Invoke (npp, window, identifier, npargs, 1, &npresult);
4318
plugin_init_classes (void)
4321
* All classes that derive from MoonlightDependencyObject should be stored in the dependency_object_classes
4322
* array, so that we can verify arguments passed from JS code are valid dependency objects, and not random
4323
* JS objects. ie element.children.add (new Array ())
4326
dependency_object_classes [COLLECTION_CLASS] = new MoonlightCollectionType ();
4327
dependency_object_classes [DEPENDENCY_OBJECT_CLASS] = new MoonlightDependencyObjectType ();
4328
dependency_object_classes [DOWNLOADER_CLASS] = new MoonlightDownloaderType ();
4329
dependency_object_classes [IMAGE_BRUSH_CLASS] = new MoonlightImageBrushType ();
4330
dependency_object_classes [IMAGE_CLASS] = new MoonlightImageType ();
4331
dependency_object_classes [MEDIA_ELEMENT_CLASS] = new MoonlightMediaElementType ();
4332
dependency_object_classes [STORYBOARD_CLASS] = new MoonlightStoryboardType ();
4333
dependency_object_classes [STYLUS_INFO_CLASS] = new MoonlightStylusInfoType ();
4334
dependency_object_classes [STYLUS_POINT_COLLECTION_CLASS] = new MoonlightStylusPointCollectionType ();
4335
dependency_object_classes [STROKE_COLLECTION_CLASS] = new MoonlightStrokeCollectionType ();
4336
dependency_object_classes [STROKE_CLASS] = new MoonlightStrokeType ();
4337
dependency_object_classes [TEXT_BLOCK_CLASS] = new MoonlightTextBlockType ();
4338
/* Event Arg Types */
4339
dependency_object_classes [EVENT_ARGS_CLASS] = new MoonlightEventArgsType ();
4340
dependency_object_classes [ROUTED_EVENT_ARGS_CLASS] = new MoonlightRoutedEventArgsType ();
4341
dependency_object_classes [ERROR_EVENT_ARGS_CLASS] = new MoonlightErrorEventArgsType ();
4342
dependency_object_classes [KEY_EVENT_ARGS_CLASS] = new MoonlightKeyEventArgsType ();
4343
dependency_object_classes [MARKER_REACHED_EVENT_ARGS_CLASS] = new MoonlightMarkerReachedEventArgsType ();
4344
dependency_object_classes [MOUSE_EVENT_ARGS_CLASS] = new MoonlightMouseEventArgsType ();
4346
MoonlightContentClass = new MoonlightContentType ();
4347
MoonlightDurationClass = new MoonlightDurationType ();
4348
MoonlightEventObjectClass = new MoonlightEventObjectType ();
4349
MoonlightObjectClass = new MoonlightObjectType ();
4350
MoonlightPointClass = new MoonlightPointType ();
4351
MoonlightRectClass = new MoonlightRectType ();
4352
MoonlightScriptableObjectClass = new MoonlightScriptableObjectType ();
4353
MoonlightScriptControlClass = new MoonlightScriptControlType ();
4354
MoonlightSettingsClass = new MoonlightSettingsType ();
4355
MoonlightTimeSpanClass = new MoonlightTimeSpanType ();
4356
MoonlightKeyTimeClass = new MoonlightKeyTimeType ();
4360
plugin_destroy_classes (void)
4362
for (int i = 0; i < DEPENDENCY_OBJECT_CLASS_NAMES_LAST; i++) {
4363
delete dependency_object_classes [i];
4364
dependency_object_classes [i] = NULL;
4367
delete MoonlightContentClass; MoonlightContentClass = NULL;
4368
delete MoonlightEventObjectClass; MoonlightEventObjectClass = NULL;
4369
delete MoonlightErrorEventArgsClass; MoonlightErrorEventArgsClass = NULL;
4370
delete MoonlightMouseEventArgsClass; MoonlightMouseEventArgsClass = NULL;
4371
delete MoonlightKeyEventArgsClass; MoonlightKeyEventArgsClass = NULL;
4372
delete MoonlightObjectClass; MoonlightObjectClass = NULL;
4373
delete MoonlightScriptableObjectClass; MoonlightScriptableObjectClass = NULL;
4374
delete MoonlightScriptControlClass; MoonlightScriptControlClass = NULL;
4375
delete MoonlightSettingsClass; MoonlightSettingsClass = NULL;
4376
delete MoonlightRectClass; MoonlightRectClass = NULL;
4377
delete MoonlightPointClass; MoonlightPointClass = NULL;
4378
delete MoonlightDurationClass; MoonlightDurationClass = NULL;
4379
delete MoonlightTimeSpanClass; MoonlightTimeSpanClass = NULL;
4380
delete MoonlightKeyTimeClass; MoonlightKeyTimeClass = NULL;
4381
delete MoonlightMarkerReachedEventArgsClass; MoonlightMarkerReachedEventArgsClass = NULL;
added
removed
plugin/plugin-class.cpp
