git.sesse.net Git - vlc/blob - mozilla/control/npolibvlc.cpp

   1 /*****************************************************************************\r
   2  * vlc.cpp: support for NPRuntime API for Netscape Script-able plugins\r
   3  *                 FYI: http://www.mozilla.org/projects/plugins/npruntime.html\r
   4  *****************************************************************************\r
   5  * Copyright (C) 2005 the VideoLAN team\r
   6  *\r
   7  * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>\r
   8  *\r
   9  * This program is free software; you can redistribute it and/or modify\r
  10  * it under the terms of the GNU General Public License as published by\r
  11  * the Free Software Foundation; either version 2 of the License, or\r
  12  * (at your option) any later version.\r
  13  *\r
  14  * This program is distributed in the hope that it will be useful,\r
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  17  * GNU General Public License for more details.\r
  18  *\r
  19  * You should have received a copy of the GNU General Public License\r
  20  * along with this program; if not, write to the Free Software\r
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.\r
  22  *****************************************************************************/\r
  23 \r
  24 #include "config.h"\r
  25 \r
  26 #include <stdio.h>\r
  27 #include <string.h>\r
  28 #include <stdlib.h>\r
  29 \r
  30 /* Mozilla stuff */\r
  31 #ifdef HAVE_MOZILLA_CONFIG_H\r
  32 #   include <mozilla-config.h>\r
  33 #endif\r
  34 \r
  35 #include "npolibvlc.h"\r
  36 #include "vlcplugin.h"\r
  37 \r
  38 /*\r
  39 ** implementation of libvlc root object\r
  40 */\r
  41 \r
  42 LibvlcRootNPObject::LibvlcRootNPObject(NPP instance, const NPClass *aClass) :\r
  43         RuntimeNPObject(instance, aClass)\r
  44 {\r
  45     static NPClass *audioClass = new RuntimeNPClass<LibvlcAudioNPObject>();\r
  46     static NPClass *inputClass = new RuntimeNPClass<LibvlcInputNPObject>();\r
  47     static NPClass *playlistClass = new RuntimeNPClass<LibvlcPlaylistNPObject>();\r
  48     static NPClass *videoClass = new RuntimeNPClass<LibvlcVideoNPObject>();\r
  49 \r
  50     audioObj = NPN_CreateObject(instance, audioClass);\r
  51     inputObj = NPN_CreateObject(instance, inputClass);\r
  52     playlistObj = NPN_CreateObject(instance, playlistClass);\r
  53     videoObj = NPN_CreateObject(instance, videoClass);\r
  54 }\r
  55 \r
  56 LibvlcRootNPObject::~LibvlcRootNPObject()\r
  57 {\r
  58     NPN_ReleaseObject(audioObj);\r
  59     NPN_ReleaseObject(inputObj);\r
  60     NPN_ReleaseObject(playlistObj);\r
  61     NPN_ReleaseObject(videoObj);\r
  62 }\r
  63 \r
  64 const NPUTF8 * const LibvlcRootNPObject::propertyNames[] = \r
  65 {\r
  66     "audio",\r
  67     "input",\r
  68     "playlist",\r
  69     "video",\r
  70 };\r
  71 \r
  72 enum LibvlcRootNPObjectPropertyIds\r
  73 {\r
  74     ID_audio = 0,\r
  75     ID_input,\r
  76     ID_playlist,\r
  77     ID_video,\r
  78 };\r
  79 \r
  80 const int LibvlcRootNPObject::propertyCount = sizeof(LibvlcRootNPObject::propertyNames)/sizeof(NPUTF8 *);\r
  81 \r
  82 RuntimeNPObject::InvokeResult LibvlcRootNPObject::getProperty(int index, NPVariant *result)\r
  83 {\r
  84     switch( index )\r
  85     {\r
  86         case ID_audio:\r
  87             OBJECT_TO_NPVARIANT(NPN_RetainObject(audioObj), *result);\r
  88             return INVOKERESULT_NO_ERROR;\r
  89         case ID_input:\r
  90             OBJECT_TO_NPVARIANT(NPN_RetainObject(inputObj), *result);\r
  91             return INVOKERESULT_NO_ERROR;\r
  92         case ID_playlist:\r
  93             OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistObj), *result);\r
  94             return INVOKERESULT_NO_ERROR;\r
  95         case ID_video:\r
  96             OBJECT_TO_NPVARIANT(NPN_RetainObject(videoObj), *result);\r
  97             return INVOKERESULT_NO_ERROR;\r
  98     }\r
  99     return INVOKERESULT_GENERIC_ERROR;\r
 100 }\r
 101 \r
 102 const NPUTF8 * const LibvlcRootNPObject::methodNames[] =\r
 103 {\r
 104     /* no methods */\r
 105 };\r
 106 \r
 107 const int LibvlcRootNPObject::methodCount = sizeof(LibvlcRootNPObject::methodNames)/sizeof(NPUTF8 *);\r
 108 \r
 109 /*\r
 110 ** implementation of libvlc audio object\r
 111 */\r
 112 \r
 113 const NPUTF8 * const LibvlcAudioNPObject::propertyNames[] = \r
 114 {\r
 115     "mute",\r
 116     "volume",\r
 117 };\r
 118 \r
 119 enum LibvlcAudioNPObjectPropertyIds\r
 120 {\r
 121     ID_mute,\r
 122     ID_volume,\r
 123 };\r
 124 \r
 125 const int LibvlcAudioNPObject::propertyCount = sizeof(LibvlcAudioNPObject::propertyNames)/sizeof(NPUTF8 *);\r
 126 \r
 127 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::getProperty(int index, NPVariant *result)\r
 128 {\r
 129     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 130     if( p_plugin )\r
 131     {\r
 132         libvlc_exception_t ex;\r
 133         libvlc_exception_init(&ex);\r
 134 \r
 135         switch( index )\r
 136         {\r
 137             case ID_mute:\r
 138             {\r
 139                 vlc_bool_t muted = libvlc_audio_get_mute(p_plugin->getVLC(), &ex);\r
 140                 if( libvlc_exception_raised(&ex) )\r
 141                 {\r
 142                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 143                     libvlc_exception_clear(&ex);\r
 144                     return INVOKERESULT_GENERIC_ERROR;\r
 145                 }\r
 146                 BOOLEAN_TO_NPVARIANT(muted, *result);\r
 147                 return INVOKERESULT_NO_ERROR;\r
 148             }\r
 149             case ID_volume:\r
 150             {\r
 151                 int volume = libvlc_audio_get_volume(p_plugin->getVLC(), &ex);\r
 152                 if( libvlc_exception_raised(&ex) )\r
 153                 {\r
 154                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 155                     libvlc_exception_clear(&ex);\r
 156                     return INVOKERESULT_GENERIC_ERROR;\r
 157                 }\r
 158                 INT32_TO_NPVARIANT(volume, *result);\r
 159                 return INVOKERESULT_NO_ERROR;\r
 160             }\r
 161         }\r
 162     }\r
 163     return INVOKERESULT_GENERIC_ERROR;\r
 164 }\r
 165 \r
 166 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::setProperty(int index, const NPVariant *value)\r
 167 {\r
 168     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 169     if( p_plugin )\r
 170     {\r
 171         libvlc_exception_t ex;\r
 172         libvlc_exception_init(&ex);\r
 173 \r
 174         switch( index )\r
 175         {\r
 176             case ID_mute:\r
 177                 if( NPVARIANT_IS_BOOLEAN(*value) )\r
 178                 {\r
 179                     libvlc_audio_set_mute(p_plugin->getVLC(),\r
 180                                           NPVARIANT_TO_BOOLEAN(*value), &ex);\r
 181                     if( libvlc_exception_raised(&ex) )\r
 182                     {\r
 183                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 184                         libvlc_exception_clear(&ex);\r
 185                         return INVOKERESULT_GENERIC_ERROR;\r
 186                     }\r
 187                     return INVOKERESULT_NO_ERROR;\r
 188                 }\r
 189                 return INVOKERESULT_INVALID_VALUE;\r
 190             case ID_volume:\r
 191                 if( isNumberValue(*value) )\r
 192                 {\r
 193                     libvlc_audio_set_volume(p_plugin->getVLC(),\r
 194                                             numberValue(*value), &ex);\r
 195                     if( libvlc_exception_raised(&ex) )\r
 196                     {\r
 197                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 198                         libvlc_exception_clear(&ex);\r
 199                         return INVOKERESULT_GENERIC_ERROR;\r
 200                     }\r
 201                     return INVOKERESULT_NO_ERROR;\r
 202                 }\r
 203                 return INVOKERESULT_INVALID_VALUE;\r
 204         }\r
 205     }\r
 206     return INVOKERESULT_GENERIC_ERROR;\r
 207 }\r
 208 \r
 209 const NPUTF8 * const LibvlcAudioNPObject::methodNames[] =\r
 210 {\r
 211     "togglemute",\r
 212 };\r
 213 \r
 214 enum LibvlcAudioNPObjectMethodIds\r
 215 {\r
 216     ID_togglemute,\r
 217 };\r
 218 \r
 219 const int LibvlcAudioNPObject::methodCount = sizeof(LibvlcAudioNPObject::methodNames)/sizeof(NPUTF8 *);\r
 220 \r
 221 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result)\r
 222 {\r
 223     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 224     if( p_plugin )\r
 225     {\r
 226         libvlc_exception_t ex;\r
 227         libvlc_exception_init(&ex);\r
 228 \r
 229         switch( index )\r
 230         {\r
 231             case ID_togglemute:\r
 232                 if( argCount == 0 )\r
 233                 {\r
 234                     libvlc_audio_toggle_mute(p_plugin->getVLC(), &ex);\r
 235                     if( libvlc_exception_raised(&ex) )\r
 236                     {\r
 237                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 238                         libvlc_exception_clear(&ex);\r
 239                         return INVOKERESULT_GENERIC_ERROR;\r
 240                     }\r
 241                     else\r
 242                     {\r
 243                         VOID_TO_NPVARIANT(*result);\r
 244                         return INVOKERESULT_NO_ERROR;\r
 245                     }\r
 246                 }\r
 247                 return INVOKERESULT_NO_SUCH_METHOD;\r
 248             default:\r
 249                 return INVOKERESULT_NO_SUCH_METHOD;\r
 250         }\r
 251     }\r
 252     return INVOKERESULT_GENERIC_ERROR;\r
 253 }\r
 254 \r
 255 /*\r
 256 ** implementation of libvlc input object\r
 257 */\r
 258 \r
 259 const NPUTF8 * const LibvlcInputNPObject::propertyNames[] = \r
 260 {\r
 261     "length",\r
 262     "position",\r
 263     "time",\r
 264     "fps",\r
 265     "hasvout",\r
 266 };\r
 267 \r
 268 enum LibvlcInputNPObjectPropertyIds\r
 269 {\r
 270     ID_length,\r
 271     ID_position,\r
 272     ID_time,\r
 273     ID_fps,\r
 274     ID_hasvout,\r
 275 };\r
 276 \r
 277 const int LibvlcInputNPObject::propertyCount = sizeof(LibvlcInputNPObject::propertyNames)/sizeof(NPUTF8 *);\r
 278 \r
 279 RuntimeNPObject::InvokeResult LibvlcInputNPObject::getProperty(int index, NPVariant *result)\r
 280 {\r
 281     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 282     if( p_plugin )\r
 283     {\r
 284         libvlc_exception_t ex;\r
 285         libvlc_exception_init(&ex);\r
 286 \r
 287         libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);\r
 288         if( libvlc_exception_raised(&ex) )\r
 289         {\r
 290             NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 291             libvlc_exception_clear(&ex);\r
 292             return INVOKERESULT_GENERIC_ERROR;\r
 293         }\r
 294 \r
 295         switch( index )\r
 296         {\r
 297             case ID_length:\r
 298             {\r
 299                 double val = (double)libvlc_input_get_length(p_input, &ex);\r
 300                 libvlc_input_free(p_input);\r
 301                 if( libvlc_exception_raised(&ex) )\r
 302                 {\r
 303                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 304                     libvlc_exception_clear(&ex);\r
 305                     return INVOKERESULT_GENERIC_ERROR;\r
 306                 }\r
 307                 DOUBLE_TO_NPVARIANT(val, *result);\r
 308                 return INVOKERESULT_NO_ERROR;\r
 309             }\r
 310             case ID_position:\r
 311             {\r
 312                 double val = libvlc_input_get_position(p_input, &ex);\r
 313                 libvlc_input_free(p_input);\r
 314                 if( libvlc_exception_raised(&ex) )\r
 315                 {\r
 316                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 317                     libvlc_exception_clear(&ex);\r
 318                     return INVOKERESULT_GENERIC_ERROR;\r
 319                 }\r
 320                 DOUBLE_TO_NPVARIANT(val, *result);\r
 321                 return INVOKERESULT_NO_ERROR;\r
 322             }\r
 323             case ID_time:\r
 324             {\r
 325                 double val = (double)libvlc_input_get_time(p_input, &ex);\r
 326                 libvlc_input_free(p_input);\r
 327                 if( libvlc_exception_raised(&ex) )\r
 328                 {\r
 329                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 330                     libvlc_exception_clear(&ex);\r
 331                     return INVOKERESULT_GENERIC_ERROR;\r
 332                 }\r
 333                 DOUBLE_TO_NPVARIANT(val, *result);\r
 334                 return INVOKERESULT_NO_ERROR;\r
 335             }\r
 336             case ID_fps:\r
 337             {\r
 338                 double val = libvlc_input_get_fps(p_input, &ex);\r
 339                 libvlc_input_free(p_input);\r
 340                 if( libvlc_exception_raised(&ex) )\r
 341                 {\r
 342                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 343                     libvlc_exception_clear(&ex);\r
 344                     return INVOKERESULT_GENERIC_ERROR;\r
 345                 }\r
 346                 DOUBLE_TO_NPVARIANT(val, *result);\r
 347                 return INVOKERESULT_NO_ERROR;\r
 348             }\r
 349             case ID_hasvout:\r
 350             {\r
 351                 vlc_bool_t val = libvlc_input_has_vout(p_input, &ex);\r
 352                 libvlc_input_free(p_input);\r
 353                 if( libvlc_exception_raised(&ex) )\r
 354                 {\r
 355                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 356                     libvlc_exception_clear(&ex);\r
 357                     return INVOKERESULT_GENERIC_ERROR;\r
 358                 }\r
 359                 BOOLEAN_TO_NPVARIANT(val, *result);\r
 360                 return INVOKERESULT_NO_ERROR;\r
 361             }\r
 362         }\r
 363         libvlc_input_free(p_input);\r
 364     }\r
 365     return INVOKERESULT_GENERIC_ERROR;\r
 366 }\r
 367 \r
 368 RuntimeNPObject::InvokeResult LibvlcInputNPObject::setProperty(int index, const NPVariant *value)\r
 369 {\r
 370     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 371     if( p_plugin )\r
 372     {\r
 373         libvlc_exception_t ex;\r
 374         libvlc_exception_init(&ex);\r
 375 \r
 376         libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);\r
 377         if( libvlc_exception_raised(&ex) )\r
 378         {\r
 379             NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 380             libvlc_exception_clear(&ex);\r
 381             return INVOKERESULT_GENERIC_ERROR;\r
 382         }\r
 383 \r
 384         switch( index )\r
 385         {\r
 386             case ID_position:\r
 387             {\r
 388                 if( ! NPVARIANT_IS_DOUBLE(*value) )\r
 389                 {\r
 390                     libvlc_input_free(p_input);\r
 391                     return INVOKERESULT_INVALID_VALUE;\r
 392                 }\r
 393 \r
 394                 float val = (float)NPVARIANT_TO_DOUBLE(*value);\r
 395                 libvlc_input_set_position(p_input, val, &ex);\r
 396                 libvlc_input_free(p_input);\r
 397                 if( libvlc_exception_raised(&ex) )\r
 398                 {\r
 399                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 400                     libvlc_exception_clear(&ex);\r
 401                     return INVOKERESULT_GENERIC_ERROR;\r
 402                 }\r
 403                 return INVOKERESULT_NO_ERROR;\r
 404             }\r
 405             case ID_time:\r
 406             {\r
 407                 vlc_int64_t val;\r
 408                 if( NPVARIANT_IS_INT32(*value) )\r
 409                     val = (vlc_int64_t)NPVARIANT_TO_INT32(*value);\r
 410                 else if( NPVARIANT_IS_DOUBLE(*value) )\r
 411                     val = (vlc_int64_t)NPVARIANT_TO_DOUBLE(*value);\r
 412                 else\r
 413                 {\r
 414                     libvlc_input_free(p_input);\r
 415                     return INVOKERESULT_INVALID_VALUE;\r
 416                 }\r
 417 \r
 418                 libvlc_input_set_time(p_input, val, &ex);\r
 419                 libvlc_input_free(p_input);\r
 420                 if( libvlc_exception_raised(&ex) )\r
 421                 {\r
 422                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 423                     libvlc_exception_clear(&ex);\r
 424                     return INVOKERESULT_GENERIC_ERROR;\r
 425                 }\r
 426                 return INVOKERESULT_NO_ERROR;\r
 427             }\r
 428         }\r
 429         libvlc_input_free(p_input);\r
 430     }\r
 431     return INVOKERESULT_GENERIC_ERROR;\r
 432 }\r
 433 \r
 434 const NPUTF8 * const LibvlcInputNPObject::methodNames[] =\r
 435 {\r
 436     /* no methods */\r
 437 };\r
 438 \r
 439 const int LibvlcInputNPObject::methodCount = sizeof(LibvlcInputNPObject::methodNames)/sizeof(NPUTF8 *);\r
 440 \r
 441 /*\r
 442 ** implementation of libvlc playlist object\r
 443 */\r
 444 \r
 445 \r
 446 const NPUTF8 * const LibvlcPlaylistNPObject::propertyNames[] = \r
 447 {\r
 448     "itemscount",\r
 449     "isplaying",\r
 450 };\r
 451 \r
 452 enum LibvlcPlaylistNPObjectPropertyIds\r
 453 {\r
 454     ID_itemscount,\r
 455     ID_isplaying,\r
 456 };\r
 457 \r
 458 const int LibvlcPlaylistNPObject::propertyCount = sizeof(LibvlcPlaylistNPObject::propertyNames)/sizeof(NPUTF8 *);\r
 459 \r
 460 RuntimeNPObject::InvokeResult LibvlcPlaylistNPObject::getProperty(int index, NPVariant *result)\r
 461 {\r
 462     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 463     if( p_plugin )\r
 464     {\r
 465         libvlc_exception_t ex;\r
 466         libvlc_exception_init(&ex);\r
 467 \r
 468         switch( index )\r
 469         {\r
 470             case ID_itemscount:\r
 471             {\r
 472                 int val = libvlc_playlist_items_count(p_plugin->getVLC(), &ex);\r
 473                 if( libvlc_exception_raised(&ex) )\r
 474                 {\r
 475                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 476                     libvlc_exception_clear(&ex);\r
 477                     return INVOKERESULT_GENERIC_ERROR;\r
 478                 }\r
 479                 INT32_TO_NPVARIANT(val, *result);\r
 480                 return INVOKERESULT_NO_ERROR;\r
 481             }\r
 482             case ID_isplaying:\r
 483             {\r
 484                 int val = libvlc_playlist_isplaying(p_plugin->getVLC(), &ex);\r
 485                 if( libvlc_exception_raised(&ex) )\r
 486                 {\r
 487                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 488                     libvlc_exception_clear(&ex);\r
 489                     return INVOKERESULT_GENERIC_ERROR;\r
 490                 }\r
 491                 BOOLEAN_TO_NPVARIANT(val, *result);\r
 492                 return INVOKERESULT_NO_ERROR;\r
 493             }\r
 494         }\r
 495     }\r
 496     return INVOKERESULT_GENERIC_ERROR;\r
 497 }\r
 498 \r
 499 const NPUTF8 * const LibvlcPlaylistNPObject::methodNames[] =\r
 500 {\r
 501     "add",\r
 502     "play",\r
 503     "togglepause"\r
 504     "stop",\r
 505     "next",\r
 506     "prev",\r
 507     "clear",\r
 508     "deleteitem"\r
 509 };\r
 510 \r
 511 enum LibvlcPlaylistNPObjectMethodIds\r
 512 {\r
 513     ID_add,\r
 514     ID_play,\r
 515     ID_togglepause,\r
 516     ID_stop,\r
 517     ID_next,\r
 518     ID_prev,\r
 519     ID_clear,\r
 520     ID_deleteitem,\r
 521 };\r
 522 \r
 523 const int LibvlcPlaylistNPObject::methodCount = sizeof(LibvlcPlaylistNPObject::methodNames)/sizeof(NPUTF8 *);\r
 524 \r
 525 RuntimeNPObject::InvokeResult LibvlcPlaylistNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result)\r
 526 {\r
 527     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 528     if( p_plugin )\r
 529     {\r
 530         libvlc_exception_t ex;\r
 531         libvlc_exception_init(&ex);\r
 532 \r
 533         switch( index )\r
 534         {\r
 535             case ID_add:\r
 536                 if( (argCount == 1) && NPVARIANT_IS_STRING(args[0]) )\r
 537                 {\r
 538                     const NPString &name = NPVARIANT_TO_STRING(args[0]);\r
 539                     NPUTF8 *s = new NPUTF8[name.utf8length+1];\r
 540                     if( s )\r
 541                     {\r
 542                         strncpy(s, name.utf8characters, name.utf8length);\r
 543                         s[name.utf8length] = '\0';\r
 544 \r
 545                         char *url = p_plugin->getAbsoluteURL(s);\r
 546                         delete s;\r
 547                         if( ! url )\r
 548                             // what happened ?\r
 549                             return INVOKERESULT_GENERIC_ERROR;\r
 550                              \r
 551                         int item = libvlc_playlist_add(p_plugin->getVLC(), url, NULL, &ex);\r
 552                         free(url);\r
 553                         if( libvlc_exception_raised(&ex) )\r
 554                         {\r
 555                             NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 556                             libvlc_exception_clear(&ex);\r
 557                             return INVOKERESULT_GENERIC_ERROR;\r
 558                         }\r
 559                         else\r
 560                         {\r
 561                             INT32_TO_NPVARIANT(item, *result);\r
 562                             return INVOKERESULT_NO_ERROR;\r
 563                         }\r
 564                     }\r
 565                     else\r
 566                         return INVOKERESULT_OUT_OF_MEMORY;\r
 567                 }\r
 568                 return INVOKERESULT_NO_SUCH_METHOD;\r
 569             case ID_play:\r
 570                 if( argCount == 0 )\r
 571                 {\r
 572                     libvlc_playlist_play(p_plugin->getVLC(), -1, 0, NULL, &ex);\r
 573                     if( libvlc_exception_raised(&ex) )\r
 574                     {\r
 575                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 576                         libvlc_exception_clear(&ex);\r
 577                         return INVOKERESULT_GENERIC_ERROR;\r
 578                     }\r
 579                     else\r
 580                     {\r
 581                         VOID_TO_NPVARIANT(*result);\r
 582                         return INVOKERESULT_NO_ERROR;\r
 583                     }\r
 584                 }\r
 585                 return INVOKERESULT_NO_SUCH_METHOD;\r
 586             case ID_togglepause:\r
 587                 if( argCount == 0 )\r
 588                 {\r
 589                     libvlc_playlist_pause(p_plugin->getVLC(), &ex);\r
 590                     if( libvlc_exception_raised(&ex) )\r
 591                     {\r
 592                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 593                         libvlc_exception_clear(&ex);\r
 594                         return INVOKERESULT_GENERIC_ERROR;\r
 595                     }\r
 596                     else\r
 597                     {\r
 598                         VOID_TO_NPVARIANT(*result);\r
 599                         return INVOKERESULT_NO_ERROR;\r
 600                     }\r
 601                 }\r
 602                 return INVOKERESULT_NO_SUCH_METHOD;\r
 603             case ID_stop:\r
 604                 if( argCount == 0 )\r
 605                 {\r
 606                     libvlc_playlist_stop(p_plugin->getVLC(), &ex);\r
 607                     if( libvlc_exception_raised(&ex) )\r
 608                     {\r
 609                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 610                         libvlc_exception_clear(&ex);\r
 611                         return INVOKERESULT_GENERIC_ERROR;\r
 612                     }\r
 613                     else\r
 614                     {\r
 615                         VOID_TO_NPVARIANT(*result);\r
 616                         return INVOKERESULT_NO_ERROR;\r
 617                     }\r
 618                 }\r
 619                 return INVOKERESULT_NO_SUCH_METHOD;\r
 620             case ID_next:\r
 621                 if( argCount == 0 )\r
 622                 {\r
 623                     libvlc_playlist_next(p_plugin->getVLC(), &ex);\r
 624                     if( libvlc_exception_raised(&ex) )\r
 625                     {\r
 626                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 627                         libvlc_exception_clear(&ex);\r
 628                         return INVOKERESULT_GENERIC_ERROR;\r
 629                     }\r
 630                     else\r
 631                     {\r
 632                         VOID_TO_NPVARIANT(*result);\r
 633                         return INVOKERESULT_NO_ERROR;\r
 634                     }\r
 635                 }\r
 636                 return INVOKERESULT_NO_SUCH_METHOD;\r
 637             case ID_prev:\r
 638                 if( argCount == 0 )\r
 639                 {\r
 640                     libvlc_playlist_prev(p_plugin->getVLC(), &ex);\r
 641                     if( libvlc_exception_raised(&ex) )\r
 642                     {\r
 643                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 644                         libvlc_exception_clear(&ex);\r
 645                         return INVOKERESULT_GENERIC_ERROR;\r
 646                     }\r
 647                     else\r
 648                     {\r
 649                         VOID_TO_NPVARIANT(*result);\r
 650                         return INVOKERESULT_NO_ERROR;\r
 651                     }\r
 652                 }\r
 653                 return INVOKERESULT_NO_SUCH_METHOD;\r
 654             case ID_clear:\r
 655                 if( argCount == 0 )\r
 656                 {\r
 657                     libvlc_playlist_clear(p_plugin->getVLC(), &ex);\r
 658                     if( libvlc_exception_raised(&ex) )\r
 659                     {\r
 660                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 661                         libvlc_exception_clear(&ex);\r
 662                         return INVOKERESULT_GENERIC_ERROR;\r
 663                     }\r
 664                     else\r
 665                     {\r
 666                         VOID_TO_NPVARIANT(*result);\r
 667                         return INVOKERESULT_NO_ERROR;\r
 668                     }\r
 669                 }\r
 670                 return INVOKERESULT_NO_SUCH_METHOD;\r
 671             case ID_deleteitem:\r
 672                 if( (argCount == 1) && isNumberValue(args[0]) )\r
 673                 {\r
 674                     libvlc_playlist_delete_item(p_plugin->getVLC(), numberValue(args[0]), &ex);\r
 675                     if( libvlc_exception_raised(&ex) )\r
 676                     {\r
 677                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 678                         libvlc_exception_clear(&ex);\r
 679                         return INVOKERESULT_GENERIC_ERROR;\r
 680                     }\r
 681                     else\r
 682                     {\r
 683                         VOID_TO_NPVARIANT(*result);\r
 684                         return INVOKERESULT_NO_ERROR;\r
 685                     }\r
 686                 }\r
 687                 return INVOKERESULT_NO_SUCH_METHOD;\r
 688             default:\r
 689                 return INVOKERESULT_NO_SUCH_METHOD;\r
 690         }\r
 691     }\r
 692     return INVOKERESULT_GENERIC_ERROR;\r
 693 }\r
 694 \r
 695 /*\r
 696 ** implementation of libvlc video object\r
 697 */\r
 698 \r
 699 const NPUTF8 * const LibvlcVideoNPObject::propertyNames[] = \r
 700 {\r
 701     "fullscreen",\r
 702     "height",\r
 703     "width",\r
 704 };\r
 705 \r
 706 enum LibvlcVideoNPObjectPropertyIds\r
 707 {\r
 708     ID_fullscreen,\r
 709     ID_height,\r
 710     ID_width,\r
 711 };\r
 712 \r
 713 const int LibvlcVideoNPObject::propertyCount = sizeof(LibvlcVideoNPObject::propertyNames)/sizeof(NPUTF8 *);\r
 714 \r
 715 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::getProperty(int index, NPVariant *result)\r
 716 {\r
 717     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 718     if( p_plugin )\r
 719     {\r
 720         libvlc_exception_t ex;\r
 721         libvlc_exception_init(&ex);\r
 722 \r
 723         libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);\r
 724         if( libvlc_exception_raised(&ex) )\r
 725         {\r
 726             NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 727             libvlc_exception_clear(&ex);\r
 728             return INVOKERESULT_GENERIC_ERROR;\r
 729         }\r
 730 \r
 731         switch( index )\r
 732         {\r
 733             case ID_fullscreen:\r
 734             {\r
 735                 int val = libvlc_get_fullscreen(p_input, &ex);\r
 736                 libvlc_input_free(p_input);\r
 737                 if( libvlc_exception_raised(&ex) )\r
 738                 {\r
 739                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 740                     libvlc_exception_clear(&ex);\r
 741                     return INVOKERESULT_GENERIC_ERROR;\r
 742                 }\r
 743                 BOOLEAN_TO_NPVARIANT(val, *result);\r
 744                 return INVOKERESULT_NO_ERROR;\r
 745             }\r
 746             case ID_height:\r
 747             {\r
 748                 int val = libvlc_video_get_height(p_input, &ex);\r
 749                 libvlc_input_free(p_input);\r
 750                 if( libvlc_exception_raised(&ex) )\r
 751                 {\r
 752                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 753                     libvlc_exception_clear(&ex);\r
 754                     return INVOKERESULT_GENERIC_ERROR;\r
 755                 }\r
 756                 INT32_TO_NPVARIANT(val, *result);\r
 757                 return INVOKERESULT_NO_ERROR;\r
 758             }\r
 759             case ID_width:\r
 760             {\r
 761                 int val = libvlc_video_get_width(p_input, &ex);\r
 762                 libvlc_input_free(p_input);\r
 763                 if( libvlc_exception_raised(&ex) )\r
 764                 {\r
 765                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 766                     libvlc_exception_clear(&ex);\r
 767                     return INVOKERESULT_GENERIC_ERROR;\r
 768                 }\r
 769                 INT32_TO_NPVARIANT(val, *result);\r
 770                 return INVOKERESULT_NO_ERROR;\r
 771             }\r
 772         }\r
 773         libvlc_input_free(p_input);\r
 774     }\r
 775     return INVOKERESULT_GENERIC_ERROR;\r
 776 }\r
 777 \r
 778 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::setProperty(int index, const NPVariant *value)\r
 779 {\r
 780     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 781     if( p_plugin )\r
 782     {\r
 783         libvlc_exception_t ex;\r
 784         libvlc_exception_init(&ex);\r
 785 \r
 786         libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);\r
 787         if( libvlc_exception_raised(&ex) )\r
 788         {\r
 789             NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 790             libvlc_exception_clear(&ex);\r
 791             return INVOKERESULT_GENERIC_ERROR;\r
 792         }\r
 793 \r
 794         switch( index )\r
 795         {\r
 796             case ID_fullscreen:\r
 797             {\r
 798                 if( ! NPVARIANT_IS_BOOLEAN(*value) )\r
 799                 {\r
 800                     libvlc_input_free(p_input);\r
 801                     return INVOKERESULT_INVALID_VALUE;\r
 802                 }\r
 803 \r
 804                 int val = NPVARIANT_TO_BOOLEAN(*value);\r
 805                 libvlc_set_fullscreen(p_input, val, &ex);\r
 806                 libvlc_input_free(p_input);\r
 807                 if( libvlc_exception_raised(&ex) )\r
 808                 {\r
 809                     NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 810                     libvlc_exception_clear(&ex);\r
 811                     return INVOKERESULT_GENERIC_ERROR;\r
 812                 }\r
 813                 return INVOKERESULT_NO_ERROR;\r
 814             }\r
 815         }\r
 816         libvlc_input_free(p_input);\r
 817     }\r
 818     return INVOKERESULT_GENERIC_ERROR;\r
 819 }\r
 820 \r
 821 const NPUTF8 * const LibvlcVideoNPObject::methodNames[] =\r
 822 {\r
 823     "togglefullscreen",\r
 824 };\r
 825 \r
 826 enum LibvlcVideoNPObjectMethodIds\r
 827 {\r
 828     ID_togglefullscreen,\r
 829 };\r
 830 \r
 831 const int LibvlcVideoNPObject::methodCount = sizeof(LibvlcVideoNPObject::methodNames)/sizeof(NPUTF8 *);\r
 832 \r
 833 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result)\r
 834 {\r
 835     VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);\r
 836     if( p_plugin )\r
 837     {\r
 838         libvlc_exception_t ex;\r
 839         libvlc_exception_init(&ex);\r
 840 \r
 841         libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);\r
 842         if( libvlc_exception_raised(&ex) )\r
 843         {\r
 844             NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 845             libvlc_exception_clear(&ex);\r
 846             return INVOKERESULT_GENERIC_ERROR;\r
 847         }\r
 848 \r
 849         switch( index )\r
 850         {\r
 851             case ID_togglefullscreen:\r
 852                 if( argCount == 0 )\r
 853                 {\r
 854                     libvlc_toggle_fullscreen(p_input, &ex);\r
 855                     libvlc_input_free(p_input);\r
 856                     if( libvlc_exception_raised(&ex) )\r
 857                     {\r
 858                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 859                         libvlc_exception_clear(&ex);\r
 860                         return INVOKERESULT_GENERIC_ERROR;\r
 861                     }\r
 862                     else\r
 863                     {\r
 864                         VOID_TO_NPVARIANT(*result);\r
 865                         return INVOKERESULT_NO_ERROR;\r
 866                     }\r
 867                 }\r
 868                 else\r
 869                 {\r
 870                     /* cannot get input, probably not playing */\r
 871                     if( libvlc_exception_raised(&ex) )\r
 872                     {\r
 873                         NPN_SetException(this, libvlc_exception_get_message(&ex));\r
 874                         libvlc_exception_clear(&ex);\r
 875                     }\r
 876                     return INVOKERESULT_GENERIC_ERROR;\r
 877                 }\r
 878                 return INVOKERESULT_NO_SUCH_METHOD;\r
 879             default:\r
 880                 return INVOKERESULT_NO_SUCH_METHOD;\r
 881         }\r
 882     }\r
 883     return INVOKERESULT_GENERIC_ERROR;\r
 884 }\r
 885 \r