开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > PlugIns编程 > 查看源码
plugin.cpp
资源名称：FireFox_Plugin.tar.gz　[点击查看]
上传用户：hongyu5696
上传日期：2018-01-22
资源大小：391k
文件大小：90k
源码类别：

PlugIns编程

开发平台：

Unix_Linux

plugin.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: NPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Netscape Public License
  5.  * Version 1.1 (the "License"); you may not use this file except in
  6.  * compliance with the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/NPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is mozilla.org code.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Netscape Communications Corporation.
  18.  * Portions created by the Initial Developer are Copyright (C) 1998
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *
  23.  * Alternatively, the contents of this file may be used under the terms of
  24.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26.  * in which case the provisions of the GPL or the LGPL are applicable instead
  27.  * of those above. If you wish to allow use of your version of this file only
  28.  * under the terms of either the GPL or the LGPL, and not to allow others to
  29.  * use your version of this file under the terms of the NPL, indicate your
  30.  * decision by deleting the provisions above and replace them with the notice
  31.  * and other provisions required by the GPL or the LGPL. If you do not delete
  32.  * the provisions above, a recipient may use your version of this file under
  33.  * the terms of any one of the NPL, the GPL or the LGPL.
  34.  *
  35.  * ***** END LICENSE BLOCK ***** */
  37. #include "plugin.h"
  38. #include "nsIServiceManager.h"
  39. #include "nsIMemory.h"
  40. #include "nsISupportsUtils.h" // this is where some useful macros defined
  41. #include <errno.h>
  42. #include <fcntl.h>
  43. #include <dirent.h>
  44. #include <unistd.h>
  45. #include <arpa/inet.h>
  46. #include <string.h>
  47. #include <sys/types.h>
  48. #include <stdlib.h>
  49. #include <sys/stat.h>
  50. #include <stdio.h>
  51. #include <sys/socket.h>
  52. #include <netinet/in.h>
  53. #include <errno.h>
  54. #include <string.h>
  56. #ifdef GTK2_ENABLED
  57. #include "../pixmaps/gtk_logo.h"
  58. #endif
  60. #ifdef GTK1_ENABLED
  61. #include "../pixmaps/logo.xpm"
  62. #endif
  64. #ifdef HAVE_GETTEXT
  65. #ifdef X_ENABLED
  66. #include <locale.h>
  67. #endif
  68. #endif
  70. extern int errno;
  71. extern int DEBUG;
  72. extern int instance_counter;
  73. char device[255];
  74. char data[1024];
  76. int32 STREAMBUFSIZE = 0X0FFFFFFF;
  78. // service manager which will give the access to all public browser services
  79. // we will use memory service as an illustration
  80. nsIServiceManager *gServiceManager = NULL;
  82. // Unix needs this
  83. #ifdef XP_UNIX
  85. char *NPP_GetMIMEDescription(void)
  86. {
  87.     return "application/download-nsplugin:.*:Download Firefox Plugin for Unix/Linux";
  88. }
  90. // get values per plugin
  91. NPError NS_PluginGetValue(NPPVariable aVariable, void *aValue)
  92. {
  93.     return GetValue(aVariable, aValue);
  94. }
  95. #endif //XP_UNIX
  97. //////////////////////////////////////
  98. //
  99. // general initialization and shutdown
  100. //
  101. NPError NS_PluginInitialize()
  102. {
  103.     // this is probably a good place to get the service manager
  104.     // note that Mozilla will add reference, so do not forget to release
  105.     nsISupports *sm = NULL;
  107. //    system("echo NS_PluginInitialize >>log");
  108.     NPN_GetValue(NULL, NPNVserviceManager, &sm);
  110.     // Mozilla returns nsIServiceManager so we can use it directly; doing QI on
  111.     // nsISupports here can still be more appropriate in case something is changed
  112.     // in the future so we don't need to do casting of any sort.
  113.     if (sm) {
  114. sm->QueryInterface(NS_GET_IID(nsIServiceManager),
  115.    (void **) &gServiceManager);
  116. NS_RELEASE(sm);
  117.     }
  119.     return NPERR_NO_ERROR;
  120. }
  122. void NS_PluginShutdown()
  123. {
  124.     // we should release the service manager
  125. //    system("echo NS_PluginShutdown >>log");
  126.     NS_IF_RELEASE(gServiceManager);
  127.     gServiceManager = NULL;
  128. }
  130. /////////////////////////////////////////////////////////////
  131. //
  132. // construction and destruction of our plugin instance object
  133. //
  134. nsPluginInstanceBase *NS_NewPluginInstance(nsPluginCreateData *
  135.    aCreateDataStruct)
  136. {
  137.     if (!aCreateDataStruct)
  138. return NULL;
  140. //    system("echo NS_NewPluginInstance>>log");
  141.     nsPluginInstance *plugin =
  142. new nsPluginInstance(aCreateDataStruct->instance);
  144.     New(plugin, aCreateDataStruct);
  145.     return plugin;
  146. }
  148. void NS_DestroyPluginInstance(nsPluginInstanceBase * aPlugin)
  149. {
  150. //    system("echo NS_DestroyPluginInstance>>log");
  151.     if (aPlugin)
  152. delete(nsPluginInstance *) aPlugin;
  153. }
  155. ////////////////////////////////////////
  156. //
  157. // nsPluginInstance class implementation
  158. //
  159. nsPluginInstance::nsPluginInstance(NPP aInstance):nsPluginInstanceBase(),
  160. mInstance(aInstance),
  161. mInitialized(FALSE), mScriptablePeer(NULL), mControlsScriptablePeer(NULL)
  162. {
  163.     int i;
  165.     instance_counter++;
  167. //    system("echo nsPluginInstance >>log");
  169.     toolkitok = toolkitOk(mInstance, &moz_toolkit, &plug_toolkit);
  171.     mScriptablePeer = getScriptablePeer();
  172.     mControlsScriptablePeer = getControlsScriptablePeer();
  173.     mScriptablePeer->InitControls(mControlsScriptablePeer);
  174.     mControlsScriptablePeer->AddRef();
  176.     // init the instance variables here.
  177.     mimetype = NULL;
  178.     state = 0;
  179.     url = NULL;
  180.     fname = NULL;
  181.     href = NULL;
  182.     lastmessage = (char *) NPN_MemAlloc(sizeof(char) * 1024);
  183.     memset(lastmessage, '', 1);
  184.     mode = 0;
  185.     window_width = 0;
  186.     window_height = 0;
  187.     embed_width = 0;
  188.     embed_height = 0;
  189.     movie_width = 0;
  190.     movie_height = 0;
  191.     setwindow = 0;
  192.     baseurl = NULL;
  193.     hostname = NULL;
  194.     pid = 0;
  195.     noredraw = 0;
  196.     hrefrequested = 0;
  197.     threadsetup = 0;
  198.     threadlaunched = 0;
  199.     threadsignaled = 0;
  200.     cancelled = 0;
  201.     list = newNode();
  202.     currentnode = NULL;
  203.     td = (ThreadData *) NPN_MemAlloc(sizeof(ThreadData));
  204.     td->list = NULL;
  205.     td->instance = NULL;
  206.     control = -1;
  207.     player = NULL;
  208.     autostart = 1;
  209.     showcontrols = 1;
  210.     showtracker = 1;
  211.     showbuttons = 1;
  212.     showfsbutton = 1;
  213.     redrawbuttons = 0;
  214.     mmsstream = 0;
  215.     js_state = JS_STATE_UNDEFINED;
  216.     nQtNext = 0;
  217.     for (i = 0; i < 256; i++)
  218. qtNext[i] = NULL;
  219.     widget = 0;
  220.     display = NULL;
  221.     window = 0;
  222.     player_window = 0;
  223.     controlwindow = 0;
  224.     panel_height = 0;
  225.     panel_drawn = 0;
  226.     mediaCompleteCallback = NULL;
  227.     mediaCompleteWithErrorCallback = NULL;
  228.     mouseClickCallback = NULL;
  229.     mouseDownCallback = NULL;
  230.     mouseUpCallback = NULL;
  231.     mouseEnterCallback = NULL;
  232.     mouseLeaveCallback = NULL;
  233.     onVisibleCallback = NULL;
  234.     onHiddenCallback = NULL;
  235.     onDestroyCallback = NULL;
  236.     mediaLength = 0.0;
  237.     mediaPercent = 0;
  238.     mediaTime = 0.0;
  239.     mediaPos = 0.0;
  240.     nomediacache = 0;
  241.     controlsvisible = 0;
  242.     fullscreen = 0;
  243.     showlogo = 1;
  244.     showtime = 1;
  245.     DPMSEnabled = 0;
  246.     black_background = 0;
  247.     nomouseinput = 1;
  248.     noconsolecontrols = 1;
  249.     cookies = 1;
  250.     starttime = 0;
  251.     nopauseonhide = 0;
  252.     targetplayer = 0;
  253.     hidestatus = 0;
  254.     enablecontextmenu = 1;
  256. #ifdef GTK_ENABLED
  257.     image = NULL;
  258.     progress_bar = NULL;
  259.     mediaprogress_bar = NULL;
  260.     status = NULL;
  261.     play_event_box = NULL;
  262.     pause_event_box = NULL;
  263.     stop_event_box = NULL;
  264.     ff_event_box = NULL;
  265.     rew_event_box = NULL;
  266.     fs_event_box = NULL;
  267.     src_event_box = NULL;
  268.     gtkwidget = NULL;
  269.     fixed_container = NULL;
  270.     drawing_area = NULL;
  271.     popup_menu = NULL;
  272.     conf_window = NULL;
  273.     file_selector = NULL;
  274. #ifdef GTK2_ENABLED
  275.     fs_window = NULL;
  276.     paused_wheninvisible = 0;
  277. #endif
  278. #endif
  280. #ifdef X_ENABLED
  281.     font = NULL;
  282.     logo = (Pixmap) NULL;
  283.     logomask = (Pixmap) NULL;
  284.     progress_left = (Pixmap) NULL;
  285.     progress_leftmask = (Pixmap) NULL;
  286.     progress_middle = (Pixmap) NULL;
  287.     progress_middlemask = (Pixmap) NULL;
  288.     progress_right = (Pixmap) NULL;
  289.     progress_rightmask = (Pixmap) NULL;
  290.     progress_fill = (Pixmap) NULL;
  291.     progress_fillmask = (Pixmap) NULL;
  292.     lastpercent = -1;
  293. #endif
  295.     // options
  296.     vo = NULL;
  297.     vop = NULL;
  298.     novop = 0;
  299.     noembed = 0;
  300.     ao = NULL;
  301.     af = NULL;
  302.     loop = -1;
  303.     rtsp_use_tcp = 0;
  304.     rtsp_use_http = 0;
  305.     keep_download = 0;
  306.     maintain_aspect = 1;
  307.     download_dir = strdup(getenv("HOME"));
  308.     cachesize = 512;
  309.     output_display = NULL;
  310.     osdlevel = 0;
  311.     qt_speed = SPEED_MED;
  312.     cache_percent = 25;
  313.     framedrop = 0;
  314.     autosync = 0;
  315.     mc = 0;
  316.     useragent = NULL;
  317.     enable_smil = 1;
  318.     enable_helix = 1;
  319.     enable_wmp = 1;
  320.     enable_qt = 1;
  321.     enable_rm = 1;
  322.     enable_gmp = 1;
  323.     enable_mpeg = 1;
  324.     enable_mp3 = 1;
  325.     enable_ogg = 1;
  326.     enable_midi = 0;
  327.     enable_pls = 1;
  329.     // JavaScript
  330.     paused = 0;
  332.     // thread setup
  333.     pthread_mutex_init(&playlist_mutex, NULL);
  334.     pthread_mutex_init(&playlist_cond_mutex, NULL);
  335.     pthread_mutex_init(&control_mutex, NULL);
  336.     pthread_mutex_init(&read_mutex, NULL);
  337.     pthread_attr_init(&thread_attr);
  338.     pthread_cond_init(&playlist_complete_cond, NULL);
  341.     LoadConfigFile(this);
  343. #ifdef HAVE_GETTEXT
  344. #ifdef X_ENABLED
  345.     setlocale(LC_ALL, "");
  346. #endif
  347.     textdomain("downloadplug-in");
  348.     bind_textdomain_codeset("downloadplug-in", "utf-8");
  349. #endif
  350. }
  352. nsPluginInstance::~nsPluginInstance()
  353. {
  354.     // mScriptablePeer may be also held by the browser
  355.     // so releasing it here does not guarantee that it is over
  356.     // we should take precaution in case it will be called later
  357.     // and zero its mPlugin member
  358. //    system("echo ~nsPluginInstance >>log");
  359.     if (DEBUG)
  360. printf("~nsPluginInstance calledn");
  361. #ifdef GTK_ENABLED
  362.     gdk_flush();
  363. #endif
  365.     instance_counter--;
  367.     mInstance = NULL;
  368.     mInitialized = FALSE;
  369.     if (mControlsScriptablePeer != NULL) {
  370. mControlsScriptablePeer->SetInstance(NULL);
  371. mControlsScriptablePeer->Release();
  372. NS_IF_RELEASE(mControlsScriptablePeer);
  373.     }
  375.     if (mScriptablePeer != NULL) {
  376. mScriptablePeer->InitControls(NULL);
  377. mScriptablePeer->SetInstance(NULL);
  378. NS_IF_RELEASE(mScriptablePeer);
  379.     }
  381. }
  383. NPBool nsPluginInstance::init(NPWindow * aWindow)
  384. {
  385. //    system("echo init>>log");
  387.     if (aWindow == NULL)
  388. return FALSE;
  390.     mInitialized = TRUE;
  391.     return TRUE;
  392. }
  394. void nsPluginInstance::shut()
  395. {
  396. //    system("echo shut>>log");
  398.     if (DEBUG)
  399. printf("shut calledn");
  401.     if (onDestroyCallback != NULL) {
  402. if (DEBUG)
  403.     printf("Destroy Callback = %sn", onDestroyCallback);
  404. NPN_GetURL(mInstance, onDestroyCallback, NULL);
  405.     }
  407.     shutdown();
  409. }
  411. void nsPluginInstance::shutdown()
  412. {
  413.     int i;
  414.     long flags;
  416. //    system("echo shutdown>>log");
  418.     if (DEBUG)
  419. printf("shutdown calledn");
  421.     if (threadsetup == 1 && threadsignaled == 0) {
  422. if (DEBUG)
  423.     printf
  424. ("Thread is setup but waiting for signal so we need to shut it downn");
  425. signalPlayerThread(this);
  426. threadsignaled = 1;
  428.     }
  430.     if (threadsetup == 1) {
  432. if (threadlaunched == 1) {
  434.     // switch to non blocking mode
  435.     if (player != NULL) {
  436. flags = fcntl(fileno(player), F_GETFL, 0);
  437. flags |= O_NONBLOCK;
  438. fcntl(fileno(player), F_SETFL, flags);
  439.     }
  441.     pthread_mutex_lock(&control_mutex);
  442.     if (paused == 1) {
  443. sendCommand(this, "pausen");
  444. paused = 0;
  445.     }
  446.     sendCommand(this, "quitn");
  447. #ifndef BSD
  448.     pthread_mutex_lock(&read_mutex);
  449. #endif
  450.     cancelled = 1;
  451. #ifndef BSD
  452.     pthread_mutex_unlock(&read_mutex);
  453. #endif
  454.     pthread_mutex_unlock(&control_mutex);
  455.     pthread_cancel(player_thread);
  456.     pthread_join(player_thread, NULL);
  457.     js_state = JS_STATE_UNDEFINED;
  459. }
  460.     }
  461. #ifdef GTK_ENABLED
  462.     while (g_idle_remove_by_data(this)) {
  463. if (DEBUG)
  464.     printf("Removing function from idle handlern");
  465.     }
  466. #endif
  468.     if (pid != 0) {
  469. killdownload(this);
  470.     }
  472.     if (DEBUG)
  473. printf("download deadn");
  475. #ifdef X_ENABLED
  476.     FreeUI((Display *) display, this);
  477. #endif
  479.     mInitialized = FALSE;
  481. #ifdef GTK_ENABLED
  482.     while (g_idle_remove_by_data(this)) {
  483. if (DEBUG)
  484.     printf("Removing function from idle handlern");
  485.     }
  486. #endif
  488. #ifdef GTK2_ENABLED
  489.     if (controlwindow == 0) {
  490. if (conf_window != NULL) {
  491.     if (GTK_IS_WIDGET(conf_window))
  492. gtk_widget_destroy(conf_window);
  493. }
  494. if (targetplayer != 0) {
  495.     if (GTK_IS_WIDGET(gtkwidget)) {
  496. g_signal_handler_disconnect(GTK_OBJECT(gtkwidget),
  497.     delete_signal_id);
  498. g_signal_handler_disconnect(GTK_OBJECT(gtkwidget),
  499.     visible_signal_id);
  500.     }
  501.     if (GTK_IS_WIDGET(button_window))
  502. gtk_widget_destroy(button_window);
  504. }
  505. if (GTK_IS_WIDGET(gtkwidget))
  506.     gtk_widget_destroy(gtkwidget);
  508.     }
  509. #endif
  511.     if (DEBUG)
  512. printf("Window Cleaned upn");
  514. #ifdef GTK1_ENABLED
  515.     if (controlwindow == 0) {
  516. if (targetplayer != 0)
  517.     gtk_signal_disconnect(GTK_OBJECT(gtkwidget), delete_signal_id);
  518. if (GTK_IS_WIDGET(gtkwidget))
  519.     gtk_widget_destroy(gtkwidget);
  520.     }
  522.     gdk_flush();
  523.     XSync(display, FALSE);
  525. #endif
  527. #ifdef GTK_ENABLED
  528.     image = NULL;
  529.     progress_bar = NULL;
  530.     mediaprogress_bar = NULL;
  531.     status = NULL;
  532.     play_event_box = NULL;
  533.     pause_event_box = NULL;
  534.     stop_event_box = NULL;
  535.     ff_event_box = NULL;
  536.     rew_event_box = NULL;
  537.     fs_event_box = NULL;
  538.     gtkwidget = NULL;
  539.     fixed_container = NULL;
  540.     drawing_area = NULL;
  541.     popup_menu = NULL;
  542. #ifdef GTK2_ENABLED
  543.     fs_window = NULL;
  544. #endif
  545.     gtkwidget = NULL;
  546. #endif
  548. #ifdef DPMSExtension
  549.     if (DPMSEnabled)
  550. DPMSReenable(this);
  551. #endif
  553.     if (mimetype != NULL) {
  554. free(mimetype);
  555. mimetype = NULL;
  556.     }
  558.     if (href != NULL) {
  559. free(href);
  560. href = NULL;
  561.     }
  563.     if (fname != NULL) {
  564. free(fname);
  565. fname = NULL;
  566.     }
  568.     if (url != NULL) {
  569. free(url);
  570. url = NULL;
  571.     }
  573.     if (baseurl != NULL) {
  574. NPN_MemFree(baseurl);
  575. baseurl = NULL;
  576.     }
  578.     if (hostname != NULL) {
  579. NPN_MemFree(hostname);
  580. hostname = NULL;
  581.     }
  583.     if (vo != NULL) {
  584. free(vo);
  585. vo = NULL;
  586.     }
  588.     if (vop != NULL) {
  589. free(vop);
  590. vop = NULL;
  591.     }
  593.     if (ao != NULL) {
  594. free(ao);
  595. ao = NULL;
  596.     }
  598.     if (useragent != NULL) {
  599. free(useragent);
  600. useragent = NULL;
  601.     }
  603.     if (output_display != NULL) {
  604. free(output_display);
  605. output_display = NULL;
  606.     }
  608.     nQtNext = 0;
  609.     for (i = 0; i < 256; i++) {
  610. if (qtNext[i] != NULL)
  611.     free(qtNext[i]);
  612. qtNext[i] = NULL;
  613.     }
  615.     if (download_dir != NULL) {
  616. free(download_dir);
  617. download_dir = NULL;
  618.     }
  620.     if (td->list != NULL) {
  621. pthread_mutex_lock(&playlist_mutex);
  622. deleteList(td->list);
  623. td->list = NULL;
  624. list = NULL;
  625. pthread_mutex_unlock(&playlist_mutex);
  626.     }
  628.     if (td != NULL) {
  629. td->instance = NULL;
  630. NPN_MemFree(td);
  631. td = NULL;
  632.     }
  634.     if (lastmessage != NULL) {
  635. NPN_MemFree(lastmessage);
  636. lastmessage = NULL;
  637.     }
  639.     if (mediaCompleteCallback != NULL) {
  640. NPN_MemFree(mediaCompleteCallback);
  641. mediaCompleteCallback = NULL;
  642.     }
  644.     if (mouseClickCallback != NULL) {
  645. NPN_MemFree(mouseClickCallback);
  646. mouseClickCallback = NULL;
  647.     }
  649.     if (onVisibleCallback != NULL) {
  650. NPN_MemFree(onVisibleCallback);
  651. onVisibleCallback = NULL;
  652.     }
  654.     if (onHiddenCallback != NULL) {
  655. NPN_MemFree(onHiddenCallback);
  656. onHiddenCallback = NULL;
  657.     }
  659.     if (DEBUG)
  660. printf("memory freen");
  662.     autostart = 1;
  663.     showcontrols = 1;
  664.     showtracker = 1;
  665.     showbuttons = 1;
  666.     showfsbutton = 1;
  667.     panel_drawn = 0;
  668.     mmsstream = 0;
  669.     cancelled = 0;
  670.     js_state = JS_STATE_UNDEFINED;
  672.     if (DEBUG > 1)
  673. printf("destorying pthread attrs, mutexes and condsn");
  674.     pthread_attr_destroy(&thread_attr);
  675.     if (DEBUG > 1)
  676. printf("thread_attr destroyedn");
  677.     pthread_mutex_destroy(&playlist_mutex);
  678.     if (DEBUG > 1)
  679. printf("playlist_mutex destroyedn");
  680.     pthread_mutex_destroy(&playlist_cond_mutex);
  681.     if (DEBUG > 1)
  682. printf("playlist_cond_mutex destroyedn");
  683.     pthread_mutex_destroy(&control_mutex);
  684.     if (DEBUG > 1)
  685. printf("control_mutex destroyedn");
  686.     pthread_mutex_destroy(&read_mutex);
  687.     if (DEBUG > 1)
  688. printf("read_mutex destroyedn");
  689.     pthread_cond_destroy(&playlist_complete_cond);
  690.     if (DEBUG > 1)
  691. printf("playlist_complete_cond destroyedn");
  693. }
  695. NPBool nsPluginInstance::isInitialized()
  696. {
  697. //    system("echo isInitialized>>log");
  698.     return mInitialized;
  699. }
  701. NPError nsPluginInstance::SetWindow(NPWindow * aWindow)
  702. {
  703.     NPSetWindowCallbackStruct *ws;
  704.     GC black_gc;
  705.     XGCValues values;
  706.     char message[100];
  707. #ifdef GTK_ENABLED
  708.     int multiplier, height, width;
  709.     GdkColormap *colormap;
  710.     GdkColor black, white;
  711. #endif
  712. #ifdef GTK1_ENABLED
  713. //    GtkStyle *s;
  714. #endif
  716. return NPERR_NO_ERROR;
  717.     if (DEBUG >= 2)
  718. printf("*****SetWindow Callback Enter************n");
  720. //    system("echo SetWindow>>/root/log");
  721.     if ((aWindow == NULL) || (aWindow->window == NULL)) {
  722. return NPERR_NO_ERROR;
  723.     }
  725.     if ((Window) window != (Window) aWindow->window) {
  726. if (DEBUG)
  727.     printf("New window! old: 0x%li    new 0x%lin",
  728.    (unsigned long int) window,
  729.    (unsigned long int) aWindow->window);
  730.     }
  732.     if (controlwindow == 1)
  733. return NPERR_NO_ERROR;
  735.     if (toolkitok != 0) { // something is wrong
  736. ws = (NPSetWindowCallbackStruct *) aWindow->ws_info;
  737. values.foreground =
  738.     BlackPixel(ws->display, DefaultScreen(ws->display));
  739. black_gc =
  740.     XCreateGC(ws->display, (Window) aWindow->window, GCForeground,
  741.       &values);
  742. snprintf(message, 100,
  743.  "Toolkit mismatch mozilla(GTK%i), plug-in(GTK%i)",
  744.  moz_toolkit, plug_toolkit);
  745. XDrawString(ws->display, (Window) aWindow->window, black_gc, 10,
  746.     10, message, strlen(message));
  747. XFreeGC(ws->display, black_gc);
  748. return NPERR_NO_ERROR;
  749.     }
  751.     if (state < STATE_WINDOWSET) {
  752. if (DEBUG) {
  753.     printf("Size: %d %d %pn", aWindow->x, aWindow->y,
  754.    aWindow->window);
  755.     printf("Size: %dx%d n", aWindow->width, aWindow->height);
  756. }
  758. ws = (NPSetWindowCallbackStruct *) aWindow->ws_info;
  759. display = ws->display;
  761. #ifdef X_ENABLED
  762. widget =
  763.     XtWindowToWidget((Display *) ws->display,
  764.      (Window) aWindow->window);
  765. XtAddEventHandler(widget, ExposureMask, FALSE,
  766.   (XtEventHandler) RedrawCB, this);
  767. #endif
  768. #ifdef DPMSExtension
  769. DPMSEnabled = DPMSIsEnabled(this);
  770. #endif
  771. window = (Window) aWindow->window;
  772. window_width = aWindow->width;
  773. window_height = aWindow->height;
  774. state = STATE_WINDOWSET;
  776. #ifdef GTK_ENABLED
  777. gtkplug = gtk_plug_new(window);
  779. if (targetplayer == 0) {
  780.     gtkwidget = gtk_window_new(GTK_WINDOW_POPUP);
  781. } else {
  782.     gtkwidget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  783.     button_window = gtk_window_new(GTK_WINDOW_POPUP);
  784. #ifdef GTK2_ENABLED
  785.     delete_signal_id =
  786. g_signal_connect(GTK_OBJECT(gtkwidget), "delete_event",
  787.  G_CALLBACK(target_hide_callback), this);
  788. #endif
  789. #ifdef GTK1_ENABLED
  790.     delete_signal_id = gtk_signal_connect(GTK_OBJECT(gtkwidget),
  791.   "delete_event",
  792.   GTK_SIGNAL_FUNC
  793.   (target_hide_callback),
  794.   this);
  795. #endif
  796.     gtk_window_set_title(GTK_WINDOW(gtkwidget),
  797.  "downloadplug-in player");
  799. }
  801. gtk_widget_realize(gtkwidget);
  802. gdk_flush();
  804. gtk_widget_add_events(gtkwidget, GDK_BUTTON_PRESS_MASK);
  805. gtk_widget_add_events(gtkwidget, GDK_BUTTON_RELEASE_MASK);
  806. gtk_widget_add_events(gtkwidget, GDK_ENTER_NOTIFY_MASK);
  807. gtk_widget_add_events(gtkwidget, GDK_LEAVE_NOTIFY_MASK);
  808. gtk_widget_add_events(gtkwidget, GDK_KEY_PRESS_MASK);
  809. gtk_widget_add_events(gtkwidget, GDK_VISIBILITY_NOTIFY_MASK);
  811. if (targetplayer == 1) {
  812.     window_width = 400;
  813.     window_height = 200;
  814.     movie_width = 400;
  815.     movie_height = 200;
  816. }
  817. if (DEBUG > 1)
  818.     printf("setting window sizen");
  819. #ifdef GTK2_ENABLED
  820. gtk_widget_set_size_request(gtkwidget, window_width,
  821.     window_height);
  822. logo = gdk_pixbuf_new_from_inline(-1, gtk_logo, FALSE, NULL);
  823. image = gtk_image_new_from_pixbuf(logo);
  824. #endif
  825. #ifdef GTK1_ENABLED
  826. gtk_widget_set_usize(gtkwidget, window_width, window_height);
  827. #endif
  828. popup_menu = GTK_MENU(gtk_menu_new());
  829. menuitem_play =
  830.     GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Play")));
  831. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_play));
  832. gtk_widget_show(GTK_WIDGET(menuitem_play));
  833. menuitem_pause =
  834.     GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Pause")));
  835. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_pause));
  836. gtk_widget_show(GTK_WIDGET(menuitem_pause));
  837. menuitem_stop =
  838.     GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Stop")));
  839. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_stop));
  840. gtk_widget_show(GTK_WIDGET(menuitem_stop));
  841. #ifdef GTK2_ENABLED
  842. menuitem_sep1 = GTK_MENU_ITEM(gtk_separator_menu_item_new());
  843. #endif
  844. #ifdef GTK1_ENABLED
  845. menuitem_sep1 = GTK_MENU_ITEM(gtk_menu_item_new());
  846. #endif
  847. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_sep1));
  848. gtk_widget_show(GTK_WIDGET(menuitem_sep1));
  849. menuitem_showcontrols =
  850.     GTK_MENU_ITEM(gtk_check_menu_item_new_with_label
  851.   (_("Show Controls")));
  852. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_showcontrols));
  853. gtk_widget_show(GTK_WIDGET(menuitem_showcontrols));
  854. if (showcontrols)
  855.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM
  856.    (menuitem_showcontrols), TRUE);
  857. menuitem_fullscreen =
  858.     GTK_MENU_ITEM(gtk_check_menu_item_new_with_label
  859.   (_("Full Screen")));
  860. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_fullscreen));
  861. gtk_widget_show(GTK_WIDGET(menuitem_fullscreen));
  862. #ifdef GTK2_ENABLED
  863. menuitem_sep2 = GTK_MENU_ITEM(gtk_separator_menu_item_new());
  864. #endif
  865. #ifdef GTK1_ENABLED
  866. menuitem_sep2 = GTK_MENU_ITEM(gtk_menu_item_new());
  867. #endif
  868. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_sep2));
  869. gtk_widget_show(GTK_WIDGET(menuitem_sep2));
  870. menuitem_copy =
  871.     GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Copy URL")));
  872. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_copy));
  873. gtk_widget_show(GTK_WIDGET(menuitem_copy));
  874. menuitem_save =
  875.     GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Save")));
  876. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_save));
  877. gtk_widget_show(GTK_WIDGET(menuitem_save));
  878. gtk_widget_set_sensitive(GTK_WIDGET(menuitem_save), FALSE);
  880. #ifdef GTK2_ENABLED
  881. menuitem_sep3 = GTK_MENU_ITEM(gtk_separator_menu_item_new());
  882. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_sep3));
  883. gtk_widget_show(GTK_WIDGET(menuitem_sep3));
  884. menuitem_config =
  885.     GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Configure")));
  886. gtk_menu_append(popup_menu, GTK_WIDGET(menuitem_config));
  887. gtk_widget_show(GTK_WIDGET(menuitem_config));
  888. #endif
  890. #ifdef GTK2_ENABLED
  891.         if (enablecontextmenu != 0) {
  892.     g_signal_connect_swapped(G_OBJECT(gtkwidget),
  893.      "button_press_event",
  894.      G_CALLBACK(popup_handler),
  895.      GTK_OBJECT(popup_menu));
  896. }
  897. g_signal_connect(G_OBJECT(gtkwidget),
  898.  "key_press_event",
  899.  G_CALLBACK(keyboard_callback), this);
  900. g_signal_connect(GTK_OBJECT(menuitem_play), "activate",
  901.  G_CALLBACK(menuitem_play_callback), this);
  902. g_signal_connect(GTK_OBJECT(menuitem_pause), "activate",
  903.  G_CALLBACK(menuitem_pause_callback), this);
  904. g_signal_connect(GTK_OBJECT(menuitem_stop), "activate",
  905.  G_CALLBACK(menuitem_stop_callback), this);
  906. g_signal_connect(GTK_OBJECT(menuitem_showcontrols), "toggled",
  907.  G_CALLBACK(menuitem_showcontrols_callback), this);
  908. g_signal_connect(GTK_OBJECT(menuitem_fullscreen), "toggled",
  909.  G_CALLBACK(menuitem_fullscreen_callback), this);
  910. g_signal_connect(GTK_OBJECT(menuitem_save), "activate",
  911.  G_CALLBACK(menuitem_save_callback), this);
  912. g_signal_connect(GTK_OBJECT(menuitem_copy), "activate",
  913.  G_CALLBACK(menuitem_copy_callback), this);
  914. g_signal_connect(GTK_OBJECT(menuitem_config), "activate",
  915.  G_CALLBACK(menuitem_config_callback), this);
  916. g_signal_connect(G_OBJECT(gtkwidget), "button_press_event",
  917.  G_CALLBACK(mouse_callback), this);
  918. g_signal_connect(G_OBJECT(gtkwidget), "button_release_event",
  919.  G_CALLBACK(mouse_callback), this);
  920. g_signal_connect(G_OBJECT(gtkwidget), "enter_notify_event",
  921.  G_CALLBACK(mousenotify_callback), this);
  922. g_signal_connect(G_OBJECT(gtkwidget), "leave_notify_event",
  923.  G_CALLBACK(mousenotify_callback), this);
  925. #endif
  927. #ifdef GTK1_ENABLED
  928. gtk_signal_connect_object(GTK_OBJECT(gtkwidget),
  929.   "button_press_event",
  930.   GTK_SIGNAL_FUNC(popup_handler),
  931.   GTK_OBJECT(popup_menu));
  932. gtk_signal_connect(GTK_OBJECT(gtkwidget),
  933.    "key_press_event",
  934.    GTK_SIGNAL_FUNC(keyboard_callback), this);
  935. gtk_signal_connect(GTK_OBJECT(menuitem_play), "activate",
  936.    GTK_SIGNAL_FUNC(menuitem_play_callback), this);
  937. gtk_signal_connect(GTK_OBJECT(menuitem_pause), "activate",
  938.    GTK_SIGNAL_FUNC(menuitem_pause_callback), this);
  939. gtk_signal_connect(GTK_OBJECT(menuitem_stop), "activate",
  940.    GTK_SIGNAL_FUNC(menuitem_stop_callback), this);
  941. gtk_signal_connect(GTK_OBJECT(menuitem_showcontrols), "toggled",
  942.    GTK_SIGNAL_FUNC(menuitem_showcontrols_callback),
  943.    this);
  944. gtk_signal_connect(GTK_OBJECT(menuitem_fullscreen), "toggled",
  945.    GTK_SIGNAL_FUNC(menuitem_fullscreen_callback),
  946.    this);
  947. gtk_signal_connect(GTK_OBJECT(menuitem_save), "activate",
  948.    GTK_SIGNAL_FUNC(menuitem_save_callback), this);
  949. gtk_signal_connect(GTK_OBJECT(menuitem_copy), "activate",
  950.    GTK_SIGNAL_FUNC(menuitem_copy_callback), this);
  951. gtk_signal_connect(GTK_OBJECT(gtkwidget), "button_press_event",
  952.    GTK_SIGNAL_FUNC(mouse_callback), this);
  954. #endif
  955. if (DEBUG > 1)
  956.     printf("menus builtn");
  958. fixed_event_box = gtk_event_box_new();
  959. fixed_container = gtk_fixed_new();
  962. #ifdef GTK2_ENABLED
  964. gtk_widget_set_size_request(GTK_WIDGET(fixed_container),
  965.     window_width, window_height);
  966. gtk_widget_set_size_request(GTK_WIDGET(fixed_event_box),
  967.     window_width, window_height);
  969. #endif
  970. #ifdef GTK1_ENABLED
  971. gtk_widget_set_usize(GTK_WIDGET(fixed_container), window_width,
  972.      window_height);
  973. gtk_widget_set_usize(GTK_WIDGET(fixed_event_box), window_width,
  974.      window_height);
  976. #endif
  977. gtk_container_add(GTK_CONTAINER(fixed_event_box), fixed_container);
  979. status = GTK_LABEL(gtk_label_new(_("Initializing")));
  980. progress_bar = GTK_PROGRESS_BAR(gtk_progress_bar_new());
  982. if (window_height > 125) {
  984. #ifdef GTK2_ENABLED
  985.     gtk_fixed_put(GTK_FIXED(fixed_container), image, 10, 10);
  986.     gtk_widget_set_size_request(GTK_WIDGET(progress_bar),
  987. window_width - 20, 15);
  988.     gtk_widget_set_size_request(GTK_WIDGET(status),
  989. window_width - 20,
  990. window_height - 125);
  991. #endif
  992. #ifdef GTK1_ENABLED
  993.     if (DEBUG > 1)
  994. printf("> 125 setupn");
  995.     gtk_widget_show(gtkwidget);
  996.     logo = gdk_pixmap_create_from_xpm_d(gtkwidget->window,
  997. NULL, NULL, logo_xpm);
  998.     image = gtk_pixmap_new(logo, NULL);
  999.     gtk_fixed_put(GTK_FIXED(fixed_container), GTK_WIDGET(image),
  1000.   10, 10);
  1001.     gtk_widget_set_usize(GTK_WIDGET(progress_bar),
  1002.  aWindow->width - 20, 15);
  1003.     gtk_widget_set_usize(GTK_WIDGET(status),
  1004.  aWindow->width - 20,
  1005.  aWindow->height - 125);
  1006. #endif
  1007.     gtk_fixed_put(GTK_FIXED(fixed_container),
  1008.   GTK_WIDGET(progress_bar), 10,
  1009.   window_height - 50);
  1010.     if (showlogo)
  1011. gtk_widget_show(image);
  1012.     if (!hidestatus)
  1013. gtk_widget_show(GTK_WIDGET(progress_bar));
  1014.     gtk_fixed_put(GTK_FIXED(fixed_container), GTK_WIDGET(status),
  1015.   10, 60);
  1016. } else {
  1017.     if (window_height < 20) {
  1018. if (window_width < 126) {
  1019.     gtk_fixed_put(GTK_FIXED(fixed_container),
  1020.   GTK_WIDGET(status), 65, 0);
  1021. } else {
  1022.     gtk_fixed_put(GTK_FIXED(fixed_container),
  1023.   GTK_WIDGET(status), 105, 0);
  1024. }
  1025.     } else {
  1026. gtk_fixed_put(GTK_FIXED(fixed_container),
  1027.       GTK_WIDGET(status), 10, 10);
  1028.     }
  1029.     gtk_fixed_put(GTK_FIXED(fixed_container),
  1030.   GTK_WIDGET(progress_bar), 10,
  1031.   window_height - 20);
  1032.     if (!hidestatus)
  1033. gtk_widget_show(GTK_WIDGET(progress_bar));
  1034. #ifdef GTK2_ENABLED
  1035.     gtk_widget_set_size_request(GTK_WIDGET(progress_bar),
  1036. window_width - 20, 15);
  1037.     gtk_widget_set_size_request(GTK_WIDGET(status),
  1038. window_width - 20,
  1039. window_height - 25);
  1040. #endif
  1041. #ifdef GTK1_ENABLED
  1042.     if (DEBUG > 1)
  1043. printf("< 125 setupn");
  1044.     gtk_widget_set_usize(GTK_WIDGET(progress_bar),
  1045.  aWindow->width - 20, 15);
  1046.     gtk_widget_set_usize(GTK_WIDGET(status),
  1047.  aWindow->width - 20,
  1048.  aWindow->height - 25);
  1049. #endif
  1050. }
  1052. gtk_misc_set_alignment(GTK_MISC(status), 0, 0);
  1053. gtk_label_set_line_wrap(status, TRUE);
  1054. drawing_area = gtk_socket_new();
  1056. if (mode == NP_EMBED) {
  1057.     gtk_fixed_put(GTK_FIXED(fixed_container), drawing_area, 0, 0);
  1058. } else {
  1059.     gtk_fixed_put(GTK_FIXED(fixed_container),
  1060.   drawing_area, 10, 100);
  1061. }
  1062. gtk_widget_show(drawing_area);
  1065. gtk_container_add(GTK_CONTAINER(gtkwidget), fixed_event_box);
  1066. if (!hidestatus)
  1067.     gtk_widget_show(GTK_WIDGET(status));
  1068. gtk_widget_show(fixed_container);
  1069. gtk_widget_show(fixed_event_box);
  1070. if (targetplayer == 0)
  1071.     gtk_widget_show(gtkwidget);
  1073. if (black_background != 0) {
  1074. #ifdef GTK_ENABLED
  1075.     colormap = gdk_window_get_colormap(gtkwidget->window);
  1076.     gdk_color_parse("black", &black);
  1077.     gdk_color_parse("white", &white);
  1078.     gdk_colormap_alloc_color(colormap, &black, FALSE, TRUE);
  1079.     gdk_colormap_alloc_color(colormap, &white, FALSE, TRUE);
  1080. #endif
  1082. #ifdef GTK2_ENABLED
  1083.     gtk_widget_modify_bg(gtkwidget, GTK_STATE_NORMAL, &black);
  1084.     gtk_widget_modify_bg(fixed_event_box, GTK_STATE_NORMAL,
  1085.  &black);
  1086.     gtk_widget_modify_fg(GTK_WIDGET(status), GTK_STATE_NORMAL,
  1087.  &white);
  1088. #endif
  1089. #ifdef GTK_ENABLED
  1090.     gdk_window_set_background(gtkwidget->window, &black);
  1091.     gdk_window_clear(gtkwidget->window);
  1092. #endif
  1093. }
  1095. gdk_flush();
  1096. InitPixbufs(this);
  1097. #ifdef GTK_ENABLED
  1099. if (targetplayer == 0) {
  1100.     XReparentWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  1101.     GDK_WINDOW_XWINDOW(gtkwidget->window), window,
  1102.     0, 0);
  1103.     gtk_widget_map(gtkwidget);
  1104. } else {
  1105.     gtk_widget_show(button_window);
  1106.     XReparentWindow(GDK_WINDOW_XDISPLAY(button_window->window),
  1107.     GDK_WINDOW_XWINDOW(button_window->window),
  1108.     window, 0, 0);
  1109.     gtk_widget_map(button_window);
  1110. }
  1111. #endif
  1112. if (panel_drawn == 0 && autostart == 0 && nomediacache == 1) {
  1113.     if (showcontrols) {
  1114. panel_height = window_height;
  1115. #ifdef GTK_ENABLED
  1116. g_idle_add(gtkgui_draw, this);
  1117. #endif
  1118.     }
  1119. }
  1120. #endif
  1122.     } else {
  1123. if (setwindow == 0) {
  1124.     if (DEBUG)
  1125. printf("back in SetWindown");
  1126.     if (DEBUG)
  1127. printf("New Size: %ix%in", aWindow->width,
  1128.        aWindow->height);
  1129.     setwindow++;
  1131.     if (DEBUG > 1)
  1132. printf("Current state is %in", state);
  1134.     if (state != STATE_GETTING_PLAYLIST) {
  1135. state = STATE_GETTING_PLAYLIST;
  1137. if (url != NULL) {
  1138.     // hard code 0 here by doing this it actually makes nomediacache work properly
  1139.     // http src url's are automatically requested, so if we request an http here too, we get it twice
  1140.     if (isMms(url, 0)) {
  1141. snprintf(list->url, 1024, "%s", url);
  1142. state = STATE_STARTED_PLAYER;
  1143. list->mmsstream = 1;
  1144. if (threadsetup == 0 && controlwindow == 0)
  1145.     SetupPlayer(this, NULL);
  1146.     }
  1147. }
  1149. if (fname != NULL) {
  1150.     if (isMms(fname, nomediacache)) {
  1151. snprintf(list->url, 1024, "%s", fname);
  1152. state = STATE_STARTED_PLAYER;
  1153. list->mmsstream = 1;
  1154. if (threadsetup == 0 && controlwindow == 0)
  1155.     SetupPlayer(this, NULL);
  1156.     } else {
  1157. if (autostart) {
  1158.     Play();
  1159. } else {
  1160.     pthread_mutex_lock(&control_mutex);
  1161.     js_state = JS_STATE_READY;
  1162.     pthread_mutex_unlock(&control_mutex);
  1163. }
  1164.     }
  1165. }
  1167. if ((href != NULL) && (url == NULL) && (fname == NULL)) {
  1168.     if (isMms(href, nomediacache)) {
  1169. snprintf(list->url, 1024, "%s", href);
  1170. state = STATE_STARTED_PLAYER;
  1171. list->mmsstream = 1;
  1172. if (threadsetup == 0 && controlwindow == 0)
  1173.     SetupPlayer(this, NULL);
  1174.     } else {
  1175. if (autostart) {
  1176.     Play();
  1177. } else {
  1178.     pthread_mutex_lock(&control_mutex);
  1179.     js_state = JS_STATE_READY;
  1180.     pthread_mutex_unlock(&control_mutex);
  1181. }
  1182.     }
  1183. }
  1184.     }
  1185. }
  1186. if (mode == NP_EMBED) {
  1187.     embed_width = aWindow->width;
  1188.     embed_height = aWindow->height;
  1189. } else {
  1190.     window_width = aWindow->width;
  1191.     window_height = aWindow->height;
  1192. }
  1193.     }
  1195.     if (DEBUG)
  1196. printf("resizing widgets to %i x %i n", aWindow->width,
  1197.        aWindow->height);
  1199. #ifdef GTK_ENABLED
  1200.     if ((status != NULL) && (targetplayer == 0)) {
  1201. window_height = aWindow->height;
  1202. window_width = aWindow->width;
  1203. if (!hidestatus)
  1204.     gtk_widget_show(GTK_WIDGET(status));
  1205. #ifdef GTK2_ENABLED
  1206. gtk_widget_set_size_request(GTK_WIDGET(status),
  1207.     window_width - 20, window_height - 25);
  1208. gtk_widget_set_size_request(GTK_WIDGET(gtkwidget),
  1209.     window_width, window_height);
  1211. #endif
  1212. #ifdef GTK1_ENABLED
  1213. gtk_widget_set_usize(GTK_WIDGET(status),
  1214.      window_width - 20, window_height - 25);
  1215. gtk_widget_set_usize(GTK_WIDGET(gtkwidget),
  1216.      window_width, window_height);
  1217. #endif
  1218. if (panel_drawn == 1) {
  1219.     height = 16;
  1220.     width = 21;
  1222.     multiplier = 0;
  1224.     if (mmsstream == 0) {
  1225. gtk_fixed_move(GTK_FIXED(fixed_container),
  1226.        GTK_WIDGET(rew_event_box),
  1227.        width * multiplier++,
  1228.        window_height - height);
  1229.     }
  1230.     gtk_fixed_move(GTK_FIXED(fixed_container),
  1231.    GTK_WIDGET(play_event_box),
  1232.    width * multiplier++, window_height - height);
  1233.     gtk_fixed_move(GTK_FIXED(fixed_container),
  1234.    GTK_WIDGET(pause_event_box),
  1235.    width * multiplier++, window_height - height);
  1236.     gtk_fixed_move(GTK_FIXED(fixed_container),
  1237.    GTK_WIDGET(stop_event_box),
  1238.    width * multiplier++, window_height - height);
  1239.     if (mmsstream == 0) {
  1240. gtk_fixed_move(GTK_FIXED(fixed_container),
  1241.        GTK_WIDGET(ff_event_box),
  1242.        width * multiplier++,
  1243.        window_height - height);
  1244.     }
  1245.     if (GTK_IS_WIDGET(mediaprogress_bar)) {
  1246. gtk_fixed_move(GTK_FIXED(fixed_container),
  1247.        GTK_WIDGET(mediaprogress_bar),
  1248.        (width * multiplier + 10),
  1249.        window_height - height + 2);
  1251. gtk_widget_set_usize(GTK_WIDGET(mediaprogress_bar),
  1252.      window_width -
  1253.      (width * (multiplier + 1) + 20),
  1254.      height - 4);
  1255.     }
  1256.     gtk_fixed_move(GTK_FIXED(fixed_container),
  1257.    GTK_WIDGET(fs_event_box),
  1258.    (window_width - width), window_height - height);
  1260. }
  1261. if (progress_bar != NULL) {
  1262.     gtk_fixed_move(GTK_FIXED(fixed_container),
  1263.    GTK_WIDGET(progress_bar),
  1264.    10, window_height - 50);
  1266.     gtk_widget_set_usize(GTK_WIDGET(progress_bar),
  1267.  window_width - 20, 15);
  1268. }
  1270.     }
  1271.     if (gtkwidget == NULL)
  1272. return NPERR_NO_ERROR;
  1274.     if (targetplayer == 0)
  1275. gtk_widget_show(gtkwidget);
  1277.     if (DEBUG > 1)
  1278. printf("resize is completen");
  1280.     if (panel_drawn == 0 && autostart == 0 && nomediacache == 1) {
  1281. if (showcontrols) {
  1282.     panel_height = window_height;
  1283. #ifdef GTK_ENABLED
  1284.     g_idle_add(gtkgui_draw, this);
  1285. #endif
  1286. }
  1287.     }
  1288. #endif
  1290.     if (DEBUG >= 2) {
  1291. printf("***********SetWindow Callback Exit**************n");
  1292.     }
  1295.     return NPERR_NO_ERROR;
  1296. }
  1298. NPError nsPluginInstance::NewStream(NPMIMEType type, NPStream * stream,
  1299.     NPBool seekable, uint16 * stype)
  1300. {
  1302. // system("echo NewStream>>log");
  1303.     if (DEBUG >= 2)
  1304. printf("**********NewStream Callback %s ****************n",
  1305.        stream->url);
  1307.     if (baseurl == NULL)
  1308. baseurl = getURLBase((char *) stream->url);
  1309.     if (hostname == NULL)
  1310. hostname = getURLHostname((char *) stream->url);
  1312.     if (mode == NP_FULL) {
  1313. url = strdup(stream->url);
  1314.     }
  1316.     if ((threadsetup == 0) && (controlwindow == 0)) {
  1317. state = STATE_GETTING_PLAYLIST;
  1318. SetupPlayer(this, NULL);
  1319.     }
  1320.     *stype = NP_NORMAL;
  1322.     if (DEBUG >= 2)
  1323. printf("*********Exiting NewStream Callback*****************n");
  1325.     return NPERR_NO_ERROR;
  1326. }
  1329. NPError nsPluginInstance::DestroyStream(NPStream * stream, NPError reason)
  1330. {
  1331.     int playable, all_retrieved, all_above_cache;
  1332.     Node *n;
  1333.     char *tmp;
  1334.     
  1335. //    system("echo DestroyStream>>log");
  1337.     if (DEBUG >= 2)
  1338. printf("***********NPP_DestroyStream called %in URL: %sn",
  1339.        reason, stream->url);
  1342.     if (reason == NPRES_DONE) {
  1343. playable = 0;
  1344. if (strlen(stream->url) >= 1023) {
  1345.     return NPERR_NO_ERROR;
  1346. }
  1347. pthread_mutex_lock(&playlist_mutex);
  1348. n = td->list;
  1349. while (n != NULL) {
  1350.     if (URLcmp(n->url, stream->url) == 0) {
  1351. if (DEBUG)
  1352.     printf("Destroy stream found a URL matchn%sn%sn",
  1353.    n->url, stream->url);
  1354. break;
  1355.     } else {
  1356. if (strstr(stream->url, n->url) != NULL) {
  1357.     break;
  1358. }
  1359.     }
  1360.     n = n->next;
  1361. }
  1363. if (n != NULL) {
  1364.     n->retrieved = 1;
  1365. #ifdef GTK_ENABLED
  1366.     g_idle_add(gtkgui_save_enable, this);
  1367. #endif
  1368.     if (n->localcache != NULL) {
  1369. if (fclose(n->localcache) != 0) {
  1370.     if (DEBUG)
  1371. printf("fclose had an error %i : %sn", errno,
  1372.        strerror(errno));
  1373. };
  1374. n->localcache = NULL;
  1375.     }
  1377.     if (controlwindow == 1) {
  1378. if (n->fname != NULL)
  1379.     remove(n->fname);
  1380.     }
  1382.     if (DEBUG)
  1383. printf
  1384.     ("checking to see if we need to make a buttonnn->url=%snurl=%snhref=%sn",
  1385.      n->url, url, (href == NULL) ? "(NULL)" : href);
  1387.     if (n->url != NULL && url != NULL) {
  1388. if ((strncmp(n->url, url, 1024) == 0) && href != NULL) {
  1389.     if (srcToButton(n->fname, this)) {
  1390. n->play = 0;
  1391. pthread_mutex_unlock(&playlist_mutex);
  1392. return NPERR_NO_ERROR;
  1393.     } else {
  1394. n = newNode();
  1395. snprintf(n->url, 1024, "%s", href);
  1396. addToEnd(td->list, n);
  1397. pthread_mutex_unlock(&playlist_mutex);
  1398. NPN_GetURL(mInstance, href, NULL);
  1399. return NPERR_NO_ERROR;
  1400.     }
  1401. } else if (strstr(n->url, url) && href != NULL) {
  1402.     // we are in this block because the url is a relative url and so
  1403.     // it is a subset of the fully qualified n->url
  1404.     if (srcToButton(n->fname, this)) {
  1405. n->play = 0;
  1406. pthread_mutex_unlock(&playlist_mutex);
  1407. return NPERR_NO_ERROR;
  1408.     } else {
  1409. n = newNode();
  1410. snprintf(n->url, 1024, "%s", href);
  1411. addToEnd(td->list, n);
  1412. pthread_mutex_unlock(&playlist_mutex);
  1413. NPN_GetURL(mInstance, href, NULL);
  1414. return NPERR_NO_ERROR;
  1415.     }
  1416. }
  1417.     }
  1419.     if (!isMms(n->url, nomediacache)) {
  1420. if (DEBUG)
  1421.     printf("calling buildPlaylist with filename %sn",
  1422.    n->fname);
  1423. buildPlaylist(this, n->fname, n);
  1424. if (mode == NP_FULL || noembed == 1) {
  1425. #ifdef X_ENABLED
  1426.     DrawUI(widget, this, _("Download Complete"), 0, 99);
  1427. #endif
  1428. #ifdef GTK_ENABLED
  1429.     if (status != NULL) {
  1430. gtk_label_set_text(status, _("Download Complete"));
  1431.     }
  1432.     g_idle_add(gtkgui_save_enable, this);
  1433.     if (progress_bar != NULL) {
  1434. gtk_progress_bar_update(progress_bar, 1.0);
  1435. if (n->next == NULL) {
  1436.     gtk_widget_hide(GTK_WIDGET(progress_bar));
  1437. } else {
  1438.     if (movie_width == 0 && movie_height == 0)
  1439. if (!hidestatus)
  1440.     gtk_widget_show(GTK_WIDGET
  1441.     (progress_bar));
  1442. }
  1443.     }
  1444. #endif
  1445. }
  1446. if (DEBUG > 1)
  1447.     printf("buildPlaylist is completen");
  1448. if (strncasecmp(mimetype, "application/sdp", 15) == 0) {
  1449.     tmp = strdup(n->fname);
  1450.     strcpy(n->fname, "sdp://");
  1451.     strcat(n->fname, tmp);
  1452.     free(tmp);
  1453. }
  1454. if (n->playlist == 1 || n->cancelled == 1) {
  1455.     if (n->mmsstream == 0) {
  1456. if (n->next == NULL) {
  1457.     pthread_mutex_unlock(&playlist_mutex);
  1458.     if (DEBUG > 1)
  1459. printf
  1460.     ("Exiting DS with playlist = %i, cancelled = %i, mmsstream = 0, and n->url = %s and threadsignaled = %in",
  1461.      n->playlist, n->cancelled, n->url,
  1462.      threadsignaled);
  1463.     if (autostart && threadsignaled == 0) {
  1464. signalPlayerThread(this);
  1465. threadsignaled = 1;
  1466.     } else {
  1467. if (showcontrols && panel_drawn == 0) {
  1468.     panel_height = 16;
  1469. #ifdef GTK_ENABLED
  1470.     g_idle_add(gtkgui_draw, this);
  1471. #endif
  1472.     pthread_mutex_lock(&control_mutex);
  1473.     js_state = JS_STATE_READY;
  1474.     pthread_mutex_unlock(&control_mutex);
  1476. }
  1477.     }
  1479.     return NPERR_NO_ERROR;
  1480. }
  1481.     }
  1482. }
  1483.     } else {
  1484. n->mmsstream = 1;
  1485. pthread_mutex_unlock(&playlist_mutex);
  1486.     }
  1489.     // test for all retrieved
  1490.     if (threadsignaled == 0) {
  1491. all_retrieved = 1;
  1492. n = td->list;
  1493. while (n != NULL) {
  1494.     if ((n->retrieved == 0) && (n->play == 1)) {
  1495. all_retrieved = 0;
  1496. break;
  1497.     }
  1498.     n = n->next;
  1499. }
  1500. // if all retrieved signal player
  1501. if (all_retrieved) {
  1502.     if (threadsignaled == 0) {
  1503. if (DEBUG)
  1504.     printf("signalling player (retrieved)n");
  1505. if (autostart) {
  1506.     signalPlayerThread(this);
  1507.     threadsignaled = 1;
  1508. } else {
  1509.     if (showcontrols && panel_drawn == 0) {
  1510. panel_height = 16;
  1511. #ifdef GTK_ENABLED
  1512. g_idle_add(gtkgui_draw, this);
  1513. #endif
  1514. pthread_mutex_lock(&control_mutex);
  1515. js_state = JS_STATE_READY;
  1516. pthread_mutex_unlock(&control_mutex);
  1518.     }
  1519. }
  1520.     }
  1521. }
  1522.     }
  1523.     // if not then see if all not retrieved are above cache,
  1524.     if (threadsignaled == 0) {
  1525. all_above_cache = 1;
  1526. n = td->list;
  1527. while (n != NULL) {
  1529.     if (DEBUG) {
  1530. printf
  1531.     ("n->url= %snn->bytes = %linn->cachebytes = %linn->play= %inn->playlist= %inn->mmsstream= %in",
  1532.      n->url, n->bytes, n->cachebytes, n->play,
  1533.      n->playlist, n->mmsstream);
  1535.     }
  1538.     if ((n->bytes <= n->cachebytes) && (n->play == 1)) {
  1539. all_above_cache = 0;
  1540. break;
  1541.     }
  1542.     n = n->next;
  1543. }
  1544. // if all above cache signal player
  1545. if (all_above_cache) {
  1546.     if (threadsignaled == 0) {
  1547. if (DEBUG)
  1548.     printf("signalling player (above cache)n");
  1549. if (autostart) {
  1550.     signalPlayerThread(this);
  1551.     threadsignaled = 1;
  1552. } else {
  1553.     pthread_mutex_lock(&control_mutex);
  1554.     js_state = JS_STATE_READY;
  1555.     pthread_mutex_unlock(&control_mutex);
  1556. }
  1557.     }
  1558. }
  1559.     }
  1560.     // check for streaming media
  1561.     if (threadsignaled == 0) {
  1562. // look for mmsstream
  1563. n = td->list;
  1564. while (n != NULL) {
  1565.     if ((n->mmsstream == 1)
  1566. && (n->play == 1)) {
  1567. if (threadsignaled == 0) {
  1568.     if (DEBUG)
  1569. printf("signalling player (mmsstream)n");
  1570.     if (autostart) {
  1571. signalPlayerThread(this);
  1572. threadsignaled = 1;
  1573.     } else {
  1574. if (showcontrols && panel_drawn == 0) {
  1575.     panel_height = 16;
  1576. #ifdef GTK_ENABLED
  1577.     g_idle_add(gtkgui_draw, this);
  1578. #endif
  1579.     pthread_mutex_lock(&control_mutex);
  1580.     js_state = JS_STATE_READY;
  1581.     pthread_mutex_unlock(&control_mutex);
  1583. }
  1584.     }
  1585. }
  1586. break;
  1587.     }
  1588.     n = n->next;
  1589. }
  1590.     }
  1591. }
  1592. pthread_mutex_unlock(&playlist_mutex);
  1593.     }
  1595.     if (reason == NPRES_USER_BREAK) {
  1596. if (DEBUG)
  1597.     printf("User cancelled the downloadn");
  1598.     }
  1600.     if (DEBUG >= 2)
  1601. printf
  1602.     ("*******Exiting DestroyStream Callback, state = %d, js_state = %dn",
  1603.      state, js_state);
  1606.     return NPERR_NO_ERROR;
  1607. }
  1609. void nsPluginInstance::URLNotify(const char *url, NPReason reason,
  1610.  void *notifyData)
  1611. {
  1612.     Node *n;
  1613.     bool isHttpStream = false;
  1614. // system("echo URLNotify>>log");
  1616.     if (DEBUG)
  1617. printf("URL: %snReason %in", url, reason);
  1619.     if (reason == 1) {
  1620. // check for streaming media
  1621. if (threadsignaled == 0) {
  1622.     // look for mmsstream
  1623.     n = td->list;
  1624.     while (n != NULL) {
  1625. if ((useragent != NULL) && (strlen(useragent) != 0) && (strstr(mimetype, "quicktime") == NULL)) // if we have a user agent 
  1626.     if (strncasecmp(n->url, "http://", 7) == 0) // and we have an http url
  1627. isHttpStream = true; // then we might have an http stream
  1628. if ((isHttpStream || n->mmsstream == 1)
  1629.     && (n->play == 1)) {
  1630.     if (threadsignaled == 0) {
  1631. if (DEBUG)
  1632.     printf("signalling player (mmsstream)n");
  1633. if (autostart) {
  1634.     signalPlayerThread(this);
  1635.     threadsignaled = 1;
  1636. } else {
  1637.     if (showcontrols && panel_drawn == 0) {
  1638. panel_height = 16;
  1639. #ifdef GTK_ENABLED
  1640. g_idle_add(gtkgui_draw, this);
  1641. #endif
  1642. pthread_mutex_lock(&control_mutex);
  1643. js_state = JS_STATE_READY;
  1644. pthread_mutex_unlock(&control_mutex);
  1646.     }
  1647. }
  1648.     }
  1649.     break;
  1650. }
  1651. n = n->next;
  1652.     }
  1653. }
  1654.     }
  1656. }
  1658. int32 nsPluginInstance::WriteReady(NPStream * stream)
  1659. {
  1660.     Node *n;
  1661.     char *filename;
  1662.     
  1663.     return 0;
  1664. //    system("echo WriteReady>>log");
  1666.     if (state == STATE_PLAY_CANCELLED || cancelled == 1)
  1667. return -1;
  1669.     if (td == NULL)
  1670. return -1;
  1672.     if (strlen(stream->url) >= 1023)
  1673. return -1;
  1675.     pthread_mutex_lock(&playlist_mutex);
  1677.     if (DEBUG >= 3)
  1678. printf("**WriteReady for %s, state =%d, js_state = %dn",
  1679.        stream->url, state, js_state);
  1681.     n = td->list;
  1682.     while (n != NULL) {
  1683. if (DEBUG > 1)
  1684.     printf("WR:nn->url= %snstream->url= %sn", n->url,
  1685.    stream->url);
  1686. if (strlen(n->url) != 0) {
  1687.     if (URLcmp(n->url, stream->url) == 0) {
  1688. break;
  1689.     } else {
  1690. if (strstr(stream->url, n->url) != NULL) {
  1691.     break;
  1692. }
  1693.     }
  1694. } else {
  1695.     snprintf(n->url, 1024, "%s", stream->url);
  1696.     break;
  1697. }
  1698. n = n->next;
  1699.     }
  1701.     // redirect case on initial node
  1702.     if ( n == NULL ) {
  1703.      if (DEBUG)
  1704.     printf("n == NULLn");
  1705.      if (td->list != NULL) {
  1706.     if (DEBUG)
  1707. printf("td->list != NULLn");
  1708.     if (((strlen(td->list->fname) == 0) 
  1709.   || (strncmp(getURLFilename(td->list->url),getURLFilename(stream->url),1024) == 0))
  1710.           && (mmsstream == 0)) {
  1711.     if (DEBUG)
  1712. printf("Redirected initial URLn");
  1713.     n = list;
  1714.     snprintf(n->url, 1024, "%s", stream->url);
  1715.     }
  1716.      }
  1717.     }
  1720.     if (n != NULL) {
  1721. // if we have determined that we are not going to play the file
  1722. // stop downloading it, and clean it up during cleanup
  1723. if (n->cancelled == 1) {
  1724.     n->remove = 1;
  1725.     //check locking here
  1726.     NPN_DestroyStream(mInstance, stream, NPRES_DONE);
  1727. }
  1728. // don't download it twice
  1729. if (n->retrieved == 1) {
  1730.     NPN_DestroyStream(mInstance, stream, NPRES_DONE);
  1731. }
  1733. if ((nomediacache == 1) && (stream->end > 16384)) {
  1734.     n->mmsstream = 1;
  1735.     pthread_mutex_unlock(&playlist_mutex);
  1736.     if (threadsignaled == 0) {
  1737. if (autostart) {
  1738.     if (DEBUG)
  1739. printf("signalling player from write readyn");
  1740.     signalPlayerThread(this);
  1741.     threadsignaled = 1;
  1742. } else {
  1743.     if (showcontrols && panel_drawn == 0) {
  1744. panel_height = 16;
  1745. #ifdef GTK_ENABLED
  1746. g_idle_add(gtkgui_draw, this);
  1747. #endif
  1748. pthread_mutex_lock(&control_mutex);
  1749. js_state = JS_STATE_READY;
  1750. pthread_mutex_unlock(&control_mutex);
  1752.     }
  1753. }
  1754.     }
  1755.     return -1;
  1756. } else {
  1757.     if (strlen(n->fname) == 0) {
  1758. if (keep_download == 1) {
  1759.     n->remove = 0;
  1760.     filename = getURLFilename(n->url);
  1761.     snprintf(n->fname, 1024, "%s/%s",
  1762.      download_dir, filename);
  1763.     if (filename)
  1764. NPN_MemFree(filename);
  1765. } else {
  1766.     snprintf(n->fname, 1024, "%s",
  1767.      tempnam("/tmp", "downloadplug-inXXXXXX"));
  1768.     if (strstr(mimetype, "midi") != NULL) {
  1769. strlcat(n->fname, ".mid", 1024);
  1770.     }
  1771.     if (strstr(mimetype, "mp3") != NULL) {
  1772. strlcat(n->fname, ".mp3", 1024);
  1773.     }
  1774.     if (strstr(mimetype, "audio/mpeg") != NULL) {
  1775. strlcat(n->fname, ".mp3", 1024);
  1776.     }
  1777.     if (strstr(mimetype, "audio/x-mod") != NULL) {
  1778. strlcat(n->fname, ".mod", 1024);
  1779.     }
  1780. }
  1781.     
  1782. if (DEBUG)
  1783.     printf("WR tempname: %sn", n->fname);
  1785.     }
  1786.     if (n->totalbytes != (int) stream->end)
  1787. n->totalbytes = stream->end;
  1789.     if (n->cachebytes <
  1790. (long int) (stream->end * cache_percent / 100))
  1791. n->cachebytes =
  1792.     (long int) (stream->end * cache_percent / 100);
  1794.     if (n->cachebytes < (cachesize * 1024))
  1795. n->cachebytes = cachesize * 1024;
  1797.     // if the file is really big , cap the amount to be cached
  1798.     if (n->cachebytes > (cachesize * 1024 * 2)
  1799. && cache_percent != 100)
  1800. n->cachebytes = cachesize * 1024 * 2;
  1802.     pthread_mutex_unlock(&playlist_mutex);
  1803.     return STREAMBUFSIZE;
  1804. }
  1805.     } else {
  1806. if (DEBUG)
  1807.     printf("didn't find the node in the playlistn %sn",
  1808.    stream->url);
  1809. n = newNode();
  1810. snprintf(n->url, 1024, "%s", stream->url);
  1811. if ((nomediacache == 1) && (stream->end > 16384)) {
  1812.     addToEnd(td->list, n);
  1813.     pthread_mutex_unlock(&playlist_mutex);
  1814.     if (showcontrols && panel_drawn == 0) {
  1815. panel_height = 16;
  1816. #ifdef GTK_ENABLED
  1817. g_idle_add(gtkgui_draw, this);
  1818. #endif
  1819.     }
  1820.     return -1;
  1821. } else {
  1822.     if (keep_download == 1) {
  1823. n->remove = 0;
  1824. filename = getURLFilename(n->url);
  1825. snprintf(n->fname, 1024, "%s/%s",
  1826.  download_dir, filename);
  1827. if (filename)
  1828.     NPN_MemFree(filename);
  1829.     } else {
  1830. snprintf(n->fname, 1024, "%s",
  1831.  tempnam("/tmp", "downloadplug-inXXXXXX"));
  1832.     }
  1833.     addToEnd(td->list, n);
  1834.     if (n->totalbytes != (int) stream->end)
  1835. n->totalbytes = stream->end;
  1836.     pthread_mutex_unlock(&playlist_mutex);
  1837.     if (DEBUG >= 3) {
  1838. printf
  1839.     ("**Exiting WriteReady Callback, state = %d, js_state = %dn",
  1840.      state, js_state);
  1841.     }
  1842.     return STREAMBUFSIZE;
  1843. }
  1844.     }
  1846. }
  1848. int32 nsPluginInstance::Write(NPStream * stream, int32 offset, int32 len,
  1849.       void *buffer)
  1850. {
  1851.     int ret = 0;
  1852.     long int currdownload, maxdownload;
  1853.     FILE *fp;
  1854.     Node *n;
  1855.     char message[1024];
  1856.     char *burl;
  1857.     
  1858. //    system("echo Write>>log");
  1860.     if (state == STATE_PLAY_CANCELLED || cancelled == 1)
  1861. return -1;
  1863.     if (td == NULL)
  1864. return -1;
  1866.     if (DEBUG >= 3)
  1867. printf("****Write Callback %s : %i : %in", stream->url,
  1868.        offset, len);
  1870.     if (strlen(stream->url) >= 1023)
  1871. return -1;
  1873.     pthread_mutex_lock(&playlist_mutex);
  1875.     // find the node that matches the URL and open the file name in it.
  1876.     currdownload = 0;
  1877.     maxdownload = 0;
  1878.     for (n = td->list; n != NULL; n = n->next) {
  1879. //if (URLcmp(n->url, stream->url) == 0) continue;
  1880. //if (strstr(stream->url, n->url) == NULL) continue;
  1881. if (n->play == 0)
  1882.     continue;
  1883. if (n->cancelled)
  1884.     continue;
  1885. currdownload += n->bytes;
  1886. maxdownload += n->totalbytes;
  1887.     }
  1889.     n = td->list;
  1890.     if (DEBUG > 2)
  1891. printf("Write - scanning playlist for %sn", stream->url);
  1892.     while (n != NULL) {
  1893. if (DEBUG > 2)
  1894.     printf("Write - current item is %sn", n->url);
  1895. if (URLcmp(n->url, stream->url) == 0) {
  1896.     break;
  1897. } else {
  1898.     if (strstr(stream->url, n->url) != NULL) {
  1899. break;
  1900.     }
  1901. }
  1902. n = n->next;
  1903.     }
  1905.     if (n == NULL) {
  1906. pthread_mutex_unlock(&playlist_mutex);
  1907. return -1;
  1908.     } else {
  1909. if (n->cancelled == 1 || state == STATE_PLAY_CANCELLED) {
  1910.     if (n->localcache != NULL) {
  1911. fclose(n->localcache);
  1912. n->localcache = NULL;
  1913.     }
  1914.     pthread_mutex_unlock(&playlist_mutex);
  1916.     if (DEBUG) {
  1917. printf
  1918.     ("*******Exiting Write: CANCELLED, state = %d, js_state = %dn",
  1919.      state, js_state);
  1920.     }
  1922.     return -1;
  1923. }
  1925. if (n->status != STATE_CANCELLED) {
  1926.     // Detect NSV media 
  1927.     snprintf(message, 1024, "%s", (char *) buffer);
  1928.     if (memmem(message, 1024, "ICY 200 OK", 10) != NULL) {
  1929. n->mmsstream = 1;
  1930. n->cancelled = 1;
  1931. n->status = STATE_CANCELLED;
  1932.     } else {
  1933. // normal media so keep going.
  1935. if (n->localcache == NULL) {
  1936.     fp = fopen(n->fname, "w+");
  1937.     n->localcache = fp;
  1938. } else {
  1939.     fp = n->localcache;
  1940. }
  1941. if (fp == NULL) {
  1942.     pthread_mutex_unlock(&playlist_mutex);
  1943.     return -1;
  1944. }
  1945. fseek(fp, offset, SEEK_SET);
  1946. ret = fwrite(buffer, 1, len, fp);
  1947. n->bytes = n->bytes + ret;
  1948. if (maxdownload == 0) {
  1949.     snprintf(message, 1024, _("Buffering %li KB"),
  1950.      (n->bytes / 1024));
  1952. } else {
  1953.     if (currdownload < maxdownload) {
  1954. snprintf(message, 1024,
  1955.  _("Buffering %i%% - %li KB"),
  1956.  (int) (100.0 *
  1957. ((double) currdownload /
  1958.  (double) maxdownload)),
  1959.  (n->bytes / 1024));
  1960. percent = ((double) currdownload /
  1961.    (double) maxdownload);
  1963.     } else {
  1964. snprintf(message, 1024,
  1965.  _("Buffering Complete - %li KB"),
  1966.  (n->bytes / 1024));
  1967. percent = 1.0;
  1968.      n->retrieved = 1;
  1969.     }
  1970. }
  1971. if (mode == NP_EMBED && noembed == 0 && fullscreen == 0) {
  1972.     if (state < STATE_PLAYING) {
  1973. #ifdef X_ENABLED
  1974. DrawUI(widget, this, message,
  1975.        0,
  1976.        (int) ((currdownload /
  1977.        (maxdownload * 1.0)) * 100));
  1978. #endif
  1979. #ifdef GTK_ENABLED
  1980. if (GTK_IS_WIDGET(progress_bar)
  1981.     && maxdownload != 0) {
  1982.     if (movie_width == 0 && movie_height == 0) {
  1983. gtk_progress_bar_update(progress_bar,
  1984. ((currdownload *
  1985.   1.0) /
  1986.  (maxdownload *
  1987.   1.0)));
  1988. if (!hidestatus)
  1989.     gtk_widget_show(GTK_WIDGET
  1990.     (progress_bar));
  1991. gtk_widget_queue_draw(GTK_WIDGET
  1992.       (progress_bar));
  1993.     }
  1994. }
  1995. if (status != NULL) {
  1996.     gtk_label_set_text(status, message);
  1997.     if (!hidestatus)
  1998. gtk_widget_show(GTK_WIDGET(status));
  1999.     gtk_widget_queue_draw(GTK_WIDGET(status));
  2000. }
  2001. #endif
  2002.     }
  2003. } else {
  2004.     if (fullscreen == 0) {
  2005. #ifdef X_ENABLED
  2006. DrawUI(widget, this, message,
  2007.        0,
  2008.        (int) ((currdownload /
  2009.        (maxdownload * 1.0)) * 100));
  2010. #endif
  2011. #ifdef GTK_ENABLED
  2012. if (GTK_IS_WIDGET(progress_bar)
  2013.     && maxdownload != 0) {
  2014.     if (movie_width == 0 && movie_height == 0) {
  2015. gtk_progress_bar_update(progress_bar,
  2016. ((currdownload *
  2017.   1.0) /
  2018.  (maxdownload *
  2019.   1.0)));
  2020. if (!hidestatus)
  2021.     gtk_widget_show(GTK_WIDGET
  2022.     (progress_bar));
  2023. gtk_widget_queue_draw(GTK_WIDGET
  2024.       (progress_bar));
  2025.     }
  2026. }
  2027. if (status != NULL) {
  2028.     if (state < STATE_PLAYING) {
  2029. gtk_label_set_text(status, message);
  2030. if (!hidestatus)
  2031.     gtk_widget_show(GTK_WIDGET(status));
  2032. gtk_widget_queue_draw(GTK_WIDGET(status));
  2033.     }
  2034. }
  2035. #endif
  2036.     }
  2037. }
  2038.     }
  2040.     if (n->status != STATE_DOWNLOADED_ENOUGH) {
  2041. burl = getURLBase(n->url);
  2042. if (burl != NULL) {
  2043.     if (baseurl == NULL) {
  2044. baseurl = burl;
  2045.     } else {
  2046. if (strcmp(baseurl, burl) != 0) {
  2047.     NPN_MemFree(baseurl);
  2048.     baseurl = burl;
  2049. } else {
  2050.     NPN_MemFree(burl);
  2051. }
  2052.     }
  2053. }
  2055. if (isMms(n->url, nomediacache)) {
  2056.     n->mmsstream = 1;
  2057. }
  2058.     }
  2059.     if (n->play == 1) {
  2060. if (n->localcache != NULL && nomediacache == 1) {
  2061.     fclose(n->localcache);
  2062.     n->localcache = NULL;
  2063. }
  2064. if (n->mmsstream == 1) {
  2065.     if (threadsignaled == 0) {
  2066. if (autostart) {
  2067.     if (DEBUG)
  2068. printf("signalling player from writen");
  2069.     signalPlayerThread(this);
  2070.     threadsignaled = 1;
  2071. } else {
  2072.     pthread_mutex_lock(&control_mutex);
  2073.     js_state = JS_STATE_READY;
  2074.     pthread_mutex_unlock(&control_mutex);
  2075. }
  2076.     }
  2077. } else {
  2078.     if (n->bytes > n->cachebytes) {
  2079. if (threadsignaled == 0) {
  2080.     if (autostart) {
  2081. if (DEBUG)
  2082.     printf
  2083. ("signalling player from writen");
  2084. signalPlayerThread(this);
  2085. threadsignaled = 1;
  2086.     } else {
  2087. if (showcontrols && panel_drawn == 0) {
  2088.     panel_height = 16;
  2089. #ifdef GTK_ENABLED
  2090.     g_idle_add(gtkgui_draw, this);
  2091. #endif
  2092.     pthread_mutex_lock(&control_mutex);
  2093.     js_state = JS_STATE_READY;
  2094.     pthread_mutex_unlock(&control_mutex);
  2096. }
  2097.     }
  2098. }
  2099.     }
  2100. }
  2101.     }
  2103. }
  2104. n->status = STATE_DOWNLOADED_ENOUGH;
  2105. pthread_mutex_unlock(&playlist_mutex);
  2107. if (DEBUG >= 3) {
  2108.     printf("*******Exiting Write, state = %d, js_state = %dn",
  2109.    state, js_state);
  2110. }
  2111. return ret;
  2112.     }
  2115. }
  2117. // methods called from nsScriptablePeer
  2119. void nsPluginInstance::Play()
  2120. {
  2121.     Node *n;
  2122.     int clearlist = 1;
  2123.     
  2124. //    system("echo Play>>log");
  2126.     return;
  2128.     if (DEBUG > 1) {
  2129. printf("*****Play Calledn");
  2130.     }
  2131.     // when js_state == JS_STATE_UNDEFINED, this means that the playlist
  2132.     // has been completely processed and the window is clear with the controls
  2133.     // visible
  2134.     // someone just pressed play so we have to reset the playlist
  2135.     if (js_state == JS_STATE_UNDEFINED) {
  2136. //reset the playlist
  2137. if (DEBUG)
  2138.     printf("Play: resetting playlistn");
  2140. pthread_mutex_lock(&playlist_mutex); // manipulating the playlist, so lock it
  2142. n = list;
  2143. while (n != NULL) {
  2144.     if (n->played == 0 && n->play == 1) {
  2145. clearlist = 0;
  2146.     }
  2147.     n = n->next;
  2148. }
  2149. if (clearlist) {
  2150.     n = list;
  2151.     while (n != NULL) {
  2152. if (n->played == 1)
  2153.     n->played = 0; // reset played flag
  2154. n = n->next;
  2155.     }
  2156. }
  2157. pthread_mutex_unlock(&playlist_mutex); // unlock the playlist
  2158.     }
  2159.     // the thread is not inited
  2160.     // controlwindow is set to 1 when the controls are in one instance and the 
  2161.     // output is in another, right now we can't control both instances so when
  2162.     // we detect a control window we just don't set it up.
  2163.     if (threadsetup == 0 && controlwindow == 0) {
  2164. if (DEBUG > 1)
  2165.     printf("Play: setupplayern");
  2166. state = STATE_GETTING_PLAYLIST;
  2167. SetupPlayer(this, NULL);
  2168. if (nomediacache == 1)
  2169.     js_state = JS_STATE_BUFFERING;
  2170.     }
  2172.     if (threadsetup == 1 && threadlaunched == 0 && controlwindow == 0) {
  2173. if (DEBUG > 1)
  2174.     printf("Play: launching threadn");
  2175. pthread_mutex_lock(&control_mutex);
  2176. launchPlayerThread(this);
  2177. pthread_mutex_unlock(&control_mutex); // unlock the control pipe, so that playPlaylist can grab it in a separate thread
  2179.     }
  2180.     // we are here cause Play 
  2181.     // also the thread has not been signalled to start, so signal it
  2182.     if (threadsignaled == 0 && threadsetup == 1 && threadlaunched == 1) {
  2183. if (DEBUG > 1)
  2184.     printf("Play: ready to signaln");
  2185. while (state < STATE_WAITING_FOR_SIGNAL) {
  2186.     printf("sleeping state = %in", state);
  2187.     usleep(100);
  2188. }
  2189. if (DEBUG > 1)
  2190.     printf("Play: signalling threadn");
  2191. signalPlayerThread(this);
  2192. threadsignaled = 1;
  2193.     }
  2194.     // normal state, the media is paused or stopped and the thread is active.
  2195.     if (paused == 1) {
  2196. if (DEBUG)
  2197.     printf("Play: sending playn");
  2198. pthread_mutex_lock(&control_mutex);
  2199. sendCommand(this, "pausen"); // send pause again to unpause
  2200. paused = 0;
  2201. js_state = JS_STATE_PLAYING;
  2202. pthread_mutex_unlock(&control_mutex);
  2203.     }
  2204. #ifdef GTK_ENABLED
  2205.     play_callback(NULL, NULL, this);
  2206. #endif
  2208.     if (DEBUG > 1) {
  2209. printf("***********Exiting Play*************n");
  2210.     }
  2212. }
  2214. void nsPluginInstance::PlayAt(double counter)
  2215. {
  2216. // system("echo PlayAt>>log");
  2217.     starttime = (long int) counter;
  2218.     Play();
  2219. }
  2222. void nsPluginInstance::Pause()
  2223. {
  2224. // system("echo Pause>>log");
  2225.     if (threadlaunched == 0)
  2226. return;
  2227.     pthread_mutex_lock(&control_mutex);
  2228.     if (paused == 0) {
  2229. if (DEBUG)
  2230.     printf("sending pausen");
  2231. sendCommand(this, "pausen");
  2232. #ifdef GTK_ENABLED
  2233. pause_callback(NULL, NULL, this);
  2234. #endif
  2235. paused = 1;
  2236. js_state = JS_STATE_PAUSED;
  2237.     }
  2238.     pthread_mutex_unlock(&control_mutex);
  2239. }
  2241. void nsPluginInstance::Stop()
  2242. {
  2243.     Node *n;
  2244.     int hdc;
  2245.     int ret;
  2247.     return ;
  2248. #if 0
  2249.     system("echo >>/root/tmp");
  2250.     hdc = open(device, O_RDWR);
  2251.     if(hdc == -1)
  2252.     {
  2253. system("echo open com1 failed >>/root/tmp");
  2254. return;
  2255.     }
  2256.     else
  2257.     {
  2258. system("echo open com1 ok >>/root/tmp");
  2259.         ret = write(hdc, data, strlen(data));
  2260.     if(ret == -1)
  2261. system("echo write com1 failed >>/root/tmp");
  2262. else
  2263. system("echo write com1 ok >>/root/tmp");
  2264.         close(hdc);
  2265. return;
  2266.     }
  2267. #endif
  2268.     if (threadlaunched == 0)
  2269. return;
  2270.     pthread_mutex_lock(&control_mutex);
  2271.     if (DEBUG)
  2272. printf("sending stopn");
  2273.     if (paused == 1)
  2274. sendCommand(this, "pausen");
  2275.     if (mmsstream == 0) {
  2276. sendCommand(this, "seek 0 2npausen");
  2277.     } else {
  2278. pthread_mutex_trylock(&playlist_mutex); // manipulating the playlist, so lock it
  2279. n = list;
  2280. while (n != NULL) {
  2281.     if (n->played)
  2282. n->played = 0; // reset playlist
  2283.     n = n->next;
  2284. }
  2285. pthread_mutex_unlock(&playlist_mutex); // unlock the playlist
  2286. sendCommand(this, "quitn");
  2287.     }
  2288. #ifdef GTK_ENABLED
  2289.     stop_callback(NULL, NULL, this);
  2290. #endif
  2291.     paused = 1;
  2292.     js_state = JS_STATE_STOPPED;
  2293.     pthread_mutex_unlock(&control_mutex);
  2294. }
  2296. void nsPluginInstance::Quit()
  2297. {
  2298. // system("echo Quit>>log");
  2299.     if (threadlaunched == 0)
  2300. return;
  2301.     pthread_mutex_lock(&control_mutex);
  2302.     if (DEBUG)
  2303. printf("sending quitn");
  2304.     if (paused == 1)
  2305. sendCommand(this, "pausen");
  2306.     sendCommand(this, "quitn");
  2307.     paused = 0;
  2308.     js_state = JS_STATE_UNDEFINED;
  2309.     pthread_mutex_unlock(&control_mutex);
  2310.     killdownload(this);
  2311. }
  2313. void nsPluginInstance::FastForward()
  2314. {
  2315.     int pre_state;
  2317. //system("echo FastForward>>log");
  2318.     if (threadlaunched == 0)
  2319. return;
  2321.     if ((js_state == JS_STATE_PLAYING) || (js_state == JS_STATE_PAUSED)) {
  2322. // do nothing, since these are ok states to FF in
  2323.     } else {
  2324. return;
  2325.     }
  2327.     pthread_mutex_lock(&control_mutex);
  2328.     pre_state = js_state;
  2329.     js_state = JS_STATE_SCANFORWARD;
  2330.     if (DEBUG)
  2331. printf("sending FastForwardn");
  2332.     if (paused == 1)
  2333. sendCommand(this, "pausen");
  2334.     sendCommand(this, "seek +10 0n");
  2335.     if (paused == 1)
  2336. sendCommand(this, "pausen");
  2337.     js_state = pre_state;
  2338.     pthread_mutex_unlock(&control_mutex);
  2339. }
  2341. void nsPluginInstance::FastReverse()
  2342. {
  2343.     int pre_state;
  2345. //system("echo FastReverse>>log");
  2346.     if (threadlaunched == 0)
  2347. return;
  2349.     if ((js_state == JS_STATE_PLAYING) || (js_state == JS_STATE_PAUSED)) {
  2350. // do nothing, since these are ok states to REW in
  2351.     } else {
  2352. return;
  2353.     }
  2355.     pthread_mutex_lock(&control_mutex);
  2356.     pre_state = js_state;
  2357.     js_state = JS_STATE_SCANREVERSE;
  2358.     if (DEBUG)
  2359. printf("sending FastReversen");
  2360.     if (paused == 1)
  2361. sendCommand(this, "pausen");
  2362.     sendCommand(this, "seek -10 0n");
  2363.     if (paused == 1)
  2364. sendCommand(this, "pausen");
  2365.     js_state = pre_state;
  2366.     pthread_mutex_unlock(&control_mutex);
  2367. }
  2369. void nsPluginInstance::Seek(double counter)
  2370. {
  2371.     char command[32];
  2372. //    system("echo Seek>>log");
  2374.     if (threadlaunched == 0)
  2375. return;
  2376.     pthread_mutex_lock(&control_mutex);
  2377.     if (paused == 1)
  2378. sendCommand(this, "pausen");
  2379.     snprintf(command, 32, "seek %5.0f 2n", counter);
  2380.     sendCommand(this, command);
  2381.     if (paused == 1)
  2382. sendCommand(this, "pausen");
  2383.     pthread_mutex_unlock(&control_mutex);
  2385. }
  2387. void nsPluginInstance::GetPlayState(PRInt32 * playstate)
  2388. {
  2389. // system("echo GetPlayState>>log");
  2390.     pthread_mutex_lock(&control_mutex);
  2391.     *playstate = js_state;
  2392.     pthread_mutex_unlock(&control_mutex);
  2393. }
  2395. char *nsPluginInstance::GetTime(void)
  2396. {
  2397.    return "over";
  2398. #if 0
  2399.     system("echo Gettime >>tmp");
  2400.     int hdc;
  2401.    
  2402.     hdc = open(device, O_RDWR);
  2404.     if(hdc == -1)
  2405.     {
  2406.         system("echo open device failed >>tmp");
  2407. return "open fail";
  2408.     }
  2409.     else
  2410.     {
  2411. system("echo read data>>tmp");
  2412.      return "read data from device";
  2413.     }
  2415.     if (js_state == JS_STATE_STOPPED) {
  2416. mediaTime = 0.0;
  2417.     }
  2418.     *_retval = (double) mediaTime;
  2419. #endif
  2420. }
  2422. void nsPluginInstance::GetDuration(double *_retval)
  2423. {
  2424. // system("echo GetDuration>>log");
  2425.     *_retval = (double) mediaLength;
  2426. }
  2428. void nsPluginInstance::GetPercent(double *_retval)
  2429. {
  2430. // system("echo GetPercent>>log");
  2431.     *_retval = (double) mediaPercent;
  2432. }
  2434. void nsPluginInstance::GetFilename(char **filename)
  2435. {
  2436. // system("echo GetFilename>>log");
  2437.     if (DEBUG >= 2)
  2438. printf("***************** GetFilename called %sn", *filename);
  2439.     if (href != NULL)
  2440. *filename = strdup(href);
  2441.     if (fname != NULL)
  2442. *filename = strdup(fname);
  2443.     if (url != NULL)
  2444. *filename = strdup(url);
  2445.     if (DEBUG >= 2)
  2446. printf("***************** GetFilename exited %sn", *filename);
  2447. }
  2449. void nsPluginInstance::SetFilename(const char *filename)
  2450. {
  2451.     char localurl[1024];
  2452.     char *media_save;
  2454.     strcpy(device, filename);
  2455.     return ;
  2457.     if (DEBUG >= 2)
  2458. printf("***************** SetFilename called %sn", filename);
  2459. /*
  2460.     killdownload(this);
  2461.     // reset some vars
  2462.     paused = 0;
  2463.     threadsetup = 0;
  2464.     threadsignaled = 0;
  2465.     // reset the list
  2466. */
  2468.     if (DEBUG)
  2469. printf("threadsetup = %i, threadsignaled = %in", threadsetup,
  2470.        threadsignaled);
  2472.     if (threadsetup == 1 && threadsignaled == 1) {
  2473. media_save = NULL;
  2475. if (mediaCompleteCallback != NULL) {
  2476.     media_save = mediaCompleteCallback;
  2477.     mediaCompleteCallback = NULL;
  2478. }
  2479. Quit();
  2480. while (threadsetup != 0) {
  2481.     if (DEBUG)
  2482. printf("waiting to quitn");
  2483.     usleep(100);
  2484. }
  2486. if (media_save != NULL) {
  2487.     mediaCompleteCallback = media_save;
  2488.     media_save = NULL;
  2489. }
  2490.     }
  2492.     pthread_mutex_lock(&playlist_mutex);
  2493.     if (baseurl != NULL) {
  2494. free(baseurl);
  2495. baseurl = NULL;
  2496.     }
  2497.     if (hostname != NULL) {
  2498. free(hostname);
  2499. hostname = NULL;
  2500.     }
  2502.     deleteList(list);
  2503.     list = newNode();
  2505.     td->list = NULL;
  2507.     // need to convert to Fully Qualified URL here
  2508.     fullyQualifyURL(this, (char *) filename, localurl);
  2510.     if (href != NULL) {
  2511. free(href);
  2512. href = NULL;
  2513.     }
  2515.     if (fname != NULL) {
  2516. free(fname);
  2517. fname = NULL;
  2518.     }
  2520.     if (url != NULL) {
  2521. free(url);
  2522. url = NULL;
  2523.     }
  2525.     pthread_mutex_unlock(&playlist_mutex);
  2527.     url = strdup(localurl);
  2528.     cancelled = 0;
  2529.     if (DEBUG)
  2530. printf("SetFilename getting %sn", localurl);
  2531.     if (!isMms(localurl, nomediacache))
  2532. NPN_GetURL(mInstance, localurl, NULL);
  2535.     if (DEBUG >= 2) {
  2536. printf("**********SetFilename Exit***************n");
  2537.     }
  2538. }
  2540. void nsPluginInstance::GetShowControls(PRBool * _retval)
  2541. {
  2542. // system("echo GetShowControls>>log");
  2543.     *_retval = (PRBool) controlsvisible;
  2545. }
  2547. void nsPluginInstance::SetShowControls(PRBool value)
  2548. {
  2549. // system("echo SetShowControls>>log");
  2550. #ifdef GTK_ENABLED
  2551.     if (value) {
  2552. if (panel_drawn == 0) {
  2553.     gtkgui_draw(this);
  2554. } else {
  2555.     if (play_event_box != NULL)
  2556. gtk_widget_show(play_event_box);
  2557.     if (pause_event_box != NULL)
  2558. gtk_widget_show(pause_event_box);
  2559.     if (stop_event_box != NULL)
  2560. gtk_widget_show(stop_event_box);
  2561.     if (ff_event_box != NULL)
  2562. gtk_widget_show(ff_event_box);
  2563.     if (rew_event_box != NULL)
  2564. gtk_widget_show(rew_event_box);
  2565.     if (mediaprogress_bar != NULL && mediaPercent > 0)
  2566. gtk_widget_show(GTK_WIDGET(mediaprogress_bar));
  2567.     if (fs_event_box != NULL)
  2568. gtk_widget_show(GTK_WIDGET(fs_event_box));
  2569. }
  2570. controlsvisible = 1;
  2572.     } else { // hide everything
  2574. if (panel_drawn == 0) {
  2575.     // do nothing
  2576. } else {
  2577.     if (play_event_box != NULL)
  2578. gtk_widget_hide(play_event_box);
  2579.     if (pause_event_box != NULL)
  2580. gtk_widget_hide(pause_event_box);
  2581.     if (stop_event_box != NULL)
  2582. gtk_widget_hide(stop_event_box);
  2583.     if (ff_event_box != NULL)
  2584. gtk_widget_hide(ff_event_box);
  2585.     if (rew_event_box != NULL)
  2586. gtk_widget_hide(rew_event_box);
  2587.     if (mediaprogress_bar != NULL)
  2588. gtk_widget_hide(GTK_WIDGET(mediaprogress_bar));
  2589.     if (fs_event_box != NULL)
  2590. gtk_widget_hide(GTK_WIDGET(fs_event_box));
  2591. }
  2592. controlsvisible = 0;
  2593.     }
  2595. #endif
  2596. #ifdef GTK2_ENABLED
  2597.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM
  2598.    (menuitem_showcontrols),
  2599.    controlsvisible);
  2600. #endif
  2601. }
  2603. void nsPluginInstance::GetFullscreen(PRBool * _retval)
  2604. {
  2605. // system("echo GetFullscreen>>log");
  2606.     *_retval = (PRBool) fullscreen;
  2608. }
  2610. void nsPluginInstance::SetFullscreen(PRBool value)
  2611. {
  2613. //system("echo SetFullscreen>>log");
  2614. #ifdef GTK2_ENABLED
  2615.     GdkScreen *screen;
  2616.     GdkRectangle rect;
  2617.     gint wx, wy;
  2618.     gint wwidth, wheight;
  2619. #endif
  2621. #ifdef GTK_ENABLED
  2622.     int multiplier, height = 0, width;
  2623.     int x, y, disp_x, pos_x, disp_y, pos_y, button_top;
  2624.     GdkColormap *colormap;
  2625.     GdkColor black;
  2626. #endif
  2627.     int win_height, win_width;
  2629. return;
  2630. #if 0
  2631.     if (threadlaunched == 0 && value == 1)
  2632. return;
  2634.     if (DEBUG)
  2635. printf("in SetFullscreen with %infullscreen = %in", value,
  2636.        fullscreen);
  2637. #ifdef GTK_ENABLED
  2638.     black.red = 0;
  2639.     black.green = 0;
  2640.     black.blue = 0;
  2641.     if (drawing_area != NULL) {
  2642. colormap = gdk_window_get_colormap(drawing_area->window);
  2643. gdk_color_alloc(colormap, &black);
  2644.     }
  2645. #endif
  2646.     if (mode == NP_EMBED) {
  2647. win_height = embed_height;
  2648. win_width = embed_width;
  2649.     } else {
  2650. win_height = window_height;
  2651. win_width = window_width;
  2652.     }
  2654.     if (targetplayer == 1) {
  2655. win_height = movie_height;
  2656. win_width = movie_width;
  2657.     }
  2659.     if (DEBUG)
  2660. printf("height = %i and width = %in", win_height, win_width);
  2662.     if (win_height == 0 || win_width == 0 || hidden == 1)
  2663. return;
  2665.     if (fullscreen) {
  2666. if (value) {
  2667.     // do nothing
  2668.     if (DEBUG > 1)
  2669. printf("SetFullscreen doing nothingn");
  2670. #ifdef GTK2_ENABLED
  2672.     screen = gtk_window_get_screen(GTK_WINDOW(gtkwidget));
  2673.     gdk_screen_get_monitor_geometry(screen,
  2674.     gdk_screen_get_monitor_at_window
  2675.     (screen, gtkwidget->window),
  2676.     &rect);
  2677.     //gtk_widget_reparent(gtkwidget, fs_window);
  2678.     gtk_window_get_size(GTK_WINDOW(gtkwidget), &wwidth, &wheight);
  2679.     if ((wwidth != rect.width) && (wheight != rect.height)) {
  2680. if (targetplayer == 0) {
  2681.     XReparentWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2682.     GDK_WINDOW_XWINDOW(gtkwidget->window),
  2683.     GDK_WINDOW_XWINDOW(fs_window->window),
  2684.     0, 0);
  2686.     gtk_widget_map(gtkwidget);
  2688.     gtk_window_resize(GTK_WINDOW(gtkwidget), rect.width,
  2689.       rect.height);
  2690.     if (DEBUG)
  2691. printf("gtkwidget resized to %i x %in",
  2692.        rect.width, rect.height);
  2693. }
  2694.     } else {
  2695. if (DEBUG)
  2696.     printf("gtkwidget is %i x %in", wwidth, wheight);
  2697.     }
  2698.     x = rect.width;
  2699.     y = rect.height;
  2700.     disp_y = y;
  2701.     disp_x = x;
  2702.     if (movie_height != 0 && movie_width != 0) {
  2703. disp_y = ((long int) (x * movie_height)) / movie_width;
  2704. disp_x = ((long int) (y * movie_width)) / movie_height;
  2705.     } else {
  2706. if (win_width != 0) {
  2707.     disp_y = ((long int) (x * win_height)) / win_width;
  2708.     disp_x = ((long int) (y * win_width)) / win_height;
  2709. }
  2710.     }
  2711.     pos_y = (y - disp_y) / 2;
  2712.     pos_x = (x - disp_x) / 2;
  2713.     if (drawing_area != NULL) {
  2714. if (disp_y <= y) {
  2715.     gtk_widget_set_usize(drawing_area, x, disp_y);
  2716.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2717.    GTK_WIDGET(drawing_area), 0, pos_y);
  2718.     if (DEBUG)
  2719. printf("drawing_area is %i x %in", x, disp_y);
  2720. } else {
  2721.     gtk_widget_set_usize(drawing_area, disp_x, y);
  2722.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2723.    GTK_WIDGET(drawing_area), pos_x, 0);
  2724.     if (DEBUG)
  2725. printf("drawing_area is %i x %in", disp_x, y);
  2726. }
  2727.     }
  2728. #endif
  2729.     fullscreen = 1;
  2730. } else {
  2731. #ifdef GTK_ENABLED
  2732.     if (DEBUG > 1)
  2733. printf("SetFullscreen returning to original sizen");
  2734. #ifdef GTK2_ENABLED
  2735.     if (fs_window != NULL) {
  2736. gtk_window_unfullscreen(GTK_WINDOW(fs_window));
  2737. if (targetplayer == 0) {
  2738.     XReparentWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2739.     GDK_WINDOW_XWINDOW(gtkwidget->window),
  2740.     window, 0, 0);
  2741.     gtk_widget_map(gtkwidget);
  2742. }
  2743. gtk_widget_destroy(fs_window);
  2744. fs_window = NULL;
  2745.     } else {
  2746. gtk_window_unfullscreen(GTK_WINDOW(gtkwidget));
  2747.     }
  2748.     if (targetplayer == 0) {
  2749. gtk_window_move(GTK_WINDOW(gtkwidget), 0, 0);
  2750. gtk_window_resize(GTK_WINDOW(gtkwidget), win_width,
  2751.   win_height);
  2752.     }
  2753. #endif
  2754. #ifdef GTK1_ENABLED
  2755.     if (fs_window != NULL) {
  2756. XReparentWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2757. GDK_WINDOW_XWINDOW(gtkwidget->window),
  2758. window, 0, 0);
  2759. XMapWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2760.    GDK_WINDOW_XWINDOW(gtkwidget->window));
  2761. gtk_widget_destroy(fs_window);
  2762. fs_window = NULL;
  2763.     }
  2765.     XResizeWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2766.   GDK_WINDOW_XWINDOW(gtkwidget->window),
  2767.   win_width, win_height);
  2768. #endif
  2769.     if (panel_drawn == 1) {
  2770. height = 16;
  2771. width = 21;
  2773. if (targetplayer == 0) {
  2774.     button_top = win_height - height;
  2775. } else {
  2776.     button_top = win_height;
  2777. }
  2779. multiplier = 0;
  2781. if (mmsstream == 0 && win_width > 126) {
  2782.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2783.    GTK_WIDGET(rew_event_box),
  2784.    width * multiplier++, button_top);
  2785. }
  2786. gtk_fixed_move(GTK_FIXED(fixed_container),
  2787.        GTK_WIDGET(play_event_box),
  2788.        width * multiplier++, button_top);
  2789. if (win_width > 126)
  2790.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2791.    GTK_WIDGET(pause_event_box),
  2792.    width * multiplier++, button_top);
  2793. gtk_fixed_move(GTK_FIXED(fixed_container),
  2794.        GTK_WIDGET(stop_event_box),
  2795.        width * multiplier++, button_top);
  2796. if (mmsstream == 0 && win_width > 126) {
  2797.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2798.    GTK_WIDGET(ff_event_box),
  2799.    width * multiplier++, button_top);
  2800. }
  2802. if (mediaprogress_bar != NULL) {
  2803.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2804.    GTK_WIDGET(mediaprogress_bar),
  2805.    (width * multiplier + 10),
  2806.    button_top + 2);
  2807.     gtk_widget_set_usize(GTK_WIDGET(mediaprogress_bar),
  2808.  win_width -
  2809.  (width * (multiplier + 1) + 20),
  2810.  height - 4);
  2811. }
  2812. if (win_width > 126)
  2813.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2814.    GTK_WIDGET(fs_event_box),
  2815.    (win_width - width), button_top);
  2818.     }
  2820.     if (image != NULL && showlogo)
  2821. gtk_widget_show(GTK_WIDGET(image));
  2823.     if (embed_height > 125 || mode == NP_FULL) {
  2824. gtk_widget_set_usize(GTK_WIDGET(status), embed_width - 20,
  2825.      embed_height - 125);
  2826. gtk_fixed_move(GTK_FIXED(fixed_container),
  2827.        GTK_WIDGET(status), 10, 60);
  2828.     } else {
  2829. gtk_widget_set_usize(GTK_WIDGET(status), embed_width - 20,
  2830.      embed_height - 20);
  2831. gtk_fixed_move(GTK_FIXED(fixed_container),
  2832.        GTK_WIDGET(status), 10, 10);
  2833.     }
  2835.     if (mode == NP_EMBED) {
  2836. if (movie_height != 0 && movie_width != 0) {
  2837.     if (drawing_area != NULL)
  2838. gtk_widget_set_usize(drawing_area,
  2839.      movie_width, movie_height);
  2840. } else {
  2841.     if (drawing_area != NULL)
  2842. gtk_widget_set_usize(drawing_area,
  2843.      embed_width, embed_height);
  2844. }
  2845. if (drawing_area != NULL)
  2846.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2847.    GTK_WIDGET(drawing_area), 0, 0);
  2848.     } else {
  2849. if (drawing_area != NULL) {
  2850.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2851.    GTK_WIDGET(drawing_area), 10, 100);
  2852.     if (movie_height != 0 && movie_width != 0) {
  2853. gtk_widget_set_usize(drawing_area,
  2854.      movie_width, movie_height);
  2855. if ((movie_width + 10 >= window_width)
  2856.     || (movie_height + 100 >= window_height))
  2857.     gtk_fixed_put(GTK_FIXED(fixed_container),
  2858.   drawing_area, 0, 0);
  2859.     } else {
  2860. gtk_widget_set_usize(drawing_area,
  2861.      window_width - 20,
  2862.      window_height - 200);
  2863.     }
  2864. }
  2865.     }
  2866. #ifdef GTK2_ENABLED
  2867.     gtk_widget_modify_bg(fixed_event_box, GTK_STATE_NORMAL,
  2868.  &(gtk_widget_get_style(image)->
  2869.    bg[GTK_STATE_NORMAL]));
  2870.     if (drawing_area != NULL)
  2871. gtk_widget_modify_bg(drawing_area, GTK_STATE_NORMAL,
  2872.      &(gtk_widget_get_style(image)->
  2873.        bg[GTK_STATE_NORMAL]));
  2874. #endif
  2876. #endif
  2877.     fullscreen = 0;
  2878. }
  2879.     } else {
  2880. if (value) {
  2881.     if (DEBUG > 1)
  2882. printf("SetFullscreen setting fullscreenn");
  2883. #ifdef GTK_ENABLED
  2884. #ifdef GTK2_ENABLED
  2885.     if (targetplayer == 0) {
  2886. fs_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  2887. gtk_widget_add_events(fs_window, GDK_BUTTON_PRESS_MASK);
  2888. gtk_widget_add_events(fs_window, GDK_BUTTON_RELEASE_MASK);
  2889. gtk_widget_add_events(fs_window, GDK_ENTER_NOTIFY_MASK);
  2890. gtk_widget_add_events(fs_window, GDK_LEAVE_NOTIFY_MASK);
  2891. gtk_widget_add_events(fs_window, GDK_KEY_PRESS_MASK);
  2893. g_signal_connect(G_OBJECT(fs_window),
  2894.  "key_press_event",
  2895.  G_CALLBACK(keyboard_callback), this);
  2896. g_signal_connect_swapped(G_OBJECT(fs_window),
  2897.  "button_press_event",
  2898.  G_CALLBACK(popup_handler),
  2899.  GTK_OBJECT(popup_menu));
  2901. screen = gtk_window_get_screen(GTK_WINDOW(gtkwidget));
  2902. gtk_window_set_screen(GTK_WINDOW(fs_window), screen);
  2903. gtk_window_set_title(GTK_WINDOW(fs_window),
  2904.      "downloadplug-in fullscreen");
  2905. gdk_screen_get_monitor_geometry(screen,
  2906. gdk_screen_get_monitor_at_window
  2907. (screen,
  2908.  gtkwidget->window),
  2909. &rect);
  2911. x = rect.width;
  2912. y = rect.height;
  2913. gtk_widget_realize(fs_window);
  2915. gdk_window_get_root_origin(gtkwidget->window, &wx, &wy);
  2916. gtk_window_move(GTK_WINDOW(fs_window), wx, wy);
  2918. gtk_widget_show(fs_window);
  2919. gtk_window_fullscreen(GTK_WINDOW(fs_window));
  2920. gtk_widget_reparent(gtkwidget, fs_window);
  2921. XReparentWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2922. GDK_WINDOW_XWINDOW(gtkwidget->window),
  2923. GDK_WINDOW_XWINDOW(fs_window->window), 0,
  2924. 0);
  2926. gtk_widget_map(gtkwidget);
  2927. gtk_window_resize(GTK_WINDOW(gtkwidget), rect.width,
  2928.   rect.height);
  2929.     } else {
  2930. screen = gtk_window_get_screen(GTK_WINDOW(gtkwidget));
  2931. gtk_window_set_title(GTK_WINDOW(gtkwidget),
  2932.      "downloadplug-in fullscreen");
  2933. gdk_screen_get_monitor_geometry(screen,
  2934. gdk_screen_get_monitor_at_window
  2935. (screen,
  2936.  gtkwidget->window),
  2937. &rect);
  2939. x = rect.width;
  2940. y = rect.height;
  2941. gtk_window_fullscreen(GTK_WINDOW(gtkwidget));
  2942.     }
  2943. #endif
  2945. #ifdef GTK1_ENABLED
  2946.     fs_window = gtk_window_new(GTK_WINDOW_POPUP);
  2947.     gtk_widget_add_events(fs_window, GDK_BUTTON_PRESS_MASK);
  2948.     gtk_widget_add_events(fs_window, GDK_BUTTON_RELEASE_MASK);
  2949.     gtk_widget_add_events(fs_window, GDK_ENTER_NOTIFY_MASK);
  2950.     gtk_widget_add_events(fs_window, GDK_LEAVE_NOTIFY_MASK);
  2951.     gtk_widget_add_events(fs_window, GDK_KEY_PRESS_MASK);
  2952.     gtk_widget_realize(fs_window);
  2953.     gtk_signal_connect(GTK_OBJECT(fs_window),
  2954.        "key-press-event",
  2955.        GTK_SIGNAL_FUNC(keyboard_callback), this);
  2956.     gtk_signal_connect_object(GTK_OBJECT(fs_window),
  2957.       "button_press_event",
  2958.       GTK_SIGNAL_FUNC(popup_handler),
  2959.       GTK_OBJECT(popup_menu));
  2961.     gtk_widget_show(fs_window);
  2962.     XReparentWindow(GDK_WINDOW_XDISPLAY(fs_window->window),
  2963.     GDK_WINDOW_XWINDOW(fs_window->window),
  2964.     GDK_ROOT_WINDOW(), 0, 0);
  2965.     XReparentWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2966.     GDK_WINDOW_XWINDOW(gtkwidget->window),
  2967.     GDK_WINDOW_XWINDOW(fs_window->window), 0, 0);
  2968.     XMapWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2969.        GDK_WINDOW_XWINDOW(gtkwidget->window));
  2970.     x = gdk_screen_width();
  2971.     y = gdk_screen_height();
  2972.     XResizeWindow(GDK_WINDOW_XDISPLAY(fs_window->window),
  2973.   GDK_WINDOW_XWINDOW(fs_window->window), x, y);
  2974.     XResizeWindow(GDK_WINDOW_XDISPLAY(gtkwidget->window),
  2975.   GDK_WINDOW_XWINDOW(gtkwidget->window), x, y);
  2976. #endif
  2979.     if (panel_drawn == 1) {
  2980. height = 16;
  2981. width = 21;
  2984. multiplier = 0;
  2986. if (mmsstream == 0) {
  2987.     gtk_fixed_move(GTK_FIXED(fixed_container),
  2988.    GTK_WIDGET(rew_event_box),
  2989.    width * multiplier++, y - height);
  2990. }
  2991. gtk_fixed_move(GTK_FIXED(fixed_container),
  2992.        GTK_WIDGET(play_event_box),
  2993.        width * multiplier++, y - height);
  2994. gtk_fixed_move(GTK_FIXED(fixed_container),
  2995.        GTK_WIDGET(pause_event_box),
  2996.        width * multiplier++, y - height);
  2997. gtk_fixed_move(GTK_FIXED(fixed_container),
  2998.        GTK_WIDGET(stop_event_box),
  2999.        width * multiplier++, y - height);
  3000. if (mmsstream == 0) {
  3001.     gtk_fixed_move(GTK_FIXED(fixed_container),
  3002.    GTK_WIDGET(ff_event_box),
  3003.    width * multiplier++, y - height);
  3004. }
  3005. if (mediaprogress_bar != NULL) {
  3006.     gtk_fixed_move(GTK_FIXED(fixed_container),
  3007.    GTK_WIDGET(mediaprogress_bar),
  3008.    (width * multiplier + 10),
  3009.    y - height + 2);
  3011.     gtk_widget_set_usize(GTK_WIDGET(mediaprogress_bar),
  3012.  x - (width * (multiplier + 1) +
  3013.       20), height - 4);
  3014. }
  3015. gtk_fixed_move(GTK_FIXED(fixed_container),
  3016.        GTK_WIDGET(fs_event_box),
  3017.        (x - width), y - height);
  3019.     }
  3021.     disp_y = y;
  3022.     disp_x = x;
  3023.     if (movie_height != 0 && movie_width != 0) {
  3024. disp_y = ((long int) (x * movie_height)) / movie_width;
  3025. disp_x = ((long int) (y * movie_width)) / movie_height;
  3026.     } else {
  3027. if (win_width != 0) {
  3028.     disp_y = ((long int) (x * win_height)) / win_width;
  3029.     disp_x = ((long int) (y * win_width)) / win_height;
  3030. }
  3031.     }
  3032.     pos_y = (y - disp_y) / 2;
  3033.     pos_x = (x - disp_x) / 2;
  3034.     if (drawing_area != NULL) {
  3035. if (disp_y <= y) {
  3036.     gtk_widget_set_usize(drawing_area, x, disp_y);
  3037.     gtk_fixed_move(GTK_FIXED(fixed_container),
  3038.    GTK_WIDGET(drawing_area), 0, pos_y);
  3039. } else {
  3040.     gtk_widget_set_usize(drawing_area, disp_x, y);
  3041.     gtk_fixed_move(GTK_FIXED(fixed_container),
  3042.    GTK_WIDGET(drawing_area), pos_x, 0);
  3043. }
  3044.     }
  3045.     if (DEBUG > 1)
  3046. printf
  3047.     ("x=%i, y=%i, movie_width=%i, movie_height=%i, disp_y=%i, pos_y=%in",
  3048.      x, y, movie_width, movie_height, disp_y, pos_y);
  3050.     if (image != NULL)
  3051. gtk_widget_hide(GTK_WIDGET(image));
  3053.     if (progress_bar != NULL)
  3054. gtk_widget_hide(GTK_WIDGET(progress_bar));
  3056.     gtk_widget_set_usize(GTK_WIDGET(status), x - 20, 30);
  3057.     gtk_fixed_move(GTK_FIXED(fixed_container), GTK_WIDGET(status),
  3058.    10, 10);
  3059. #ifdef GTK2_ENABLED
  3060.     gtk_widget_modify_bg(fixed_event_box, GTK_STATE_NORMAL,
  3061.  &black);
  3062.     if (drawing_area != NULL)
  3063. gtk_widget_modify_bg(drawing_area, GTK_STATE_NORMAL,
  3064.      &black);
  3065. #endif
  3066. #ifdef GTK_ENABLED
  3067.     gdk_window_set_background(gtkwidget->window, &black);
  3068.     gdk_window_clear(gtkwidget->window);
  3069.     if (targetplayer == 0) {
  3070. gdk_window_set_background(fs_window->window, &black);
  3071. gdk_window_clear(fs_window->window);
  3072.     }
  3073.     if (drawing_area != NULL) {
  3074. gdk_window_set_background(drawing_area->window, &black);
  3075. gdk_window_clear(drawing_area->window);
  3076.     }
  3077. #endif
  3078. #endif
  3079.     fullscreen = 1;
  3080. } else {
  3081.     // do nothing
  3082.     if (DEBUG > 1)
  3083. printf("SetFullscreen doing nothingn");
  3084.     fullscreen = 0;
  3085. }
  3086.     }
  3087. #ifdef GTK_ENABLED
  3088.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM
  3089.    (menuitem_fullscreen), fullscreen);
  3090. #endif
  3091. #endif
  3093. }
  3095. void nsPluginInstance::GetShowlogo(PRBool * _retval)
  3096. {
  3097. // system("echo GetShowlogo>>log");
  3098.     *_retval = (PRBool) showlogo;
  3100. }
  3102. void nsPluginInstance::SetShowlogo(PRBool value)
  3103. {
  3104. // system("echo SetShowlogo>>log");
  3105.     showlogo = (int) value;
  3106. #ifdef GTK_ENABLED
  3107.     if (image != NULL)
  3108. if (showlogo)
  3109.     gtk_widget_show(GTK_WIDGET(image));
  3110. else
  3111.     gtk_widget_hide(GTK_WIDGET(image));
  3113. #endif
  3114. }
  3116. void nsPluginInstance::GetPlaying(PRBool * _retval)
  3117. {
  3118.     int i;
  3120. //system("echo GetPlaying>>log");
  3121.     if (js_state > 0 && js_state < 7) {
  3122. i = 1;
  3123.     } else {
  3124. i = 0;
  3125.     }
  3127.     *_retval = (PRBool) i;
  3129. }
  3131. void nsPluginInstance::GetAutoPlay(PRBool * _retval)
  3132. {
  3133. // system("echo GetAutoPlay>>log");
  3134.     *_retval = (PRBool) autostart;
  3136. }
  3138. void nsPluginInstance::SetAutoPlay(PRBool value)
  3139. {
  3140. // system("echo SetAutoPlay>>log");
  3141.     autostart = (int) value;
  3142. }
  3144. void nsPluginInstance::GetLoop(PRBool * _retval)
  3145. {
  3146. // system("echo GetLoop>>log");
  3147.     *_retval = (PRBool) loop;
  3149. }
  3151. void nsPluginInstance::SetLoop(PRBool value)
  3152. {
  3153. // system("echo SetLoop>>log");
  3154.     loop = (int) value;
  3155. }
  3157. void nsPluginInstance::GetMIMEType(char **_retval)
  3158. {
  3159. //    system("echo GetMIMEType>>/root/tmp");
  3160. return ;
  3161. #if 0
  3162.     FILE *fp;
  3163.     char buf[1024];
  3164.     char line[255];
  3166.     
  3167.     memset(buf, 0, 1024);
  3168.     memset(line, 0, 255);
  3169.     
  3170.     fp = fopen(device,"r");
  3171.     if(!fp)
  3172.     {
  3173. *_retval = strdup("open file failed!");
  3174.     }
  3175.     else
  3176.     {
  3177.      while(fgets(line, 255, fp) != NULL)
  3178.      {
  3179.     strcat(buf, line);
  3180.      }    
  3181.      *_retval = strdup(buf);
  3182.     }
  3183. #endif
  3184. }
  3186. void nsPluginInstance::Getplugin(const char *url, char **_retval)
  3187. {
  3188.         int sock;
  3189.         struct sockaddr_in address;
  3190.         int address_len;
  3191.         char sendBuf[249];
  3192.         char recvBuf[500];
  3193.         char *buf,*path;
  3194.         int retCode,num=0,tmp;
  3195.         int filelength;
  3196.         FILE *fp;
  3197.         int i,j,port;
  3198.         char link[255];
  3199.         char host[255],temp[500],file[255],filepath[255];
  3200.         char cmd[255];
  3202.         if(!url || !strlen(url))
  3203.         {
  3204.             *_retval = strdup("-1");
  3205.             return;
  3206.         }
  3207.         strcpy(link, url);
  3209.         memset(host, 0, 255);
  3210.         memset(file, 0, 255);
  3211.         memset(temp, 0, 500);
  3213.         if(!(strstr(link, "http://")))
  3214.         {
  3215.             *_retval = strdup("-1");
  3216.             return;    
  3217.         }
  3219.         buf = link + strlen("http://");
  3221.         for(i=0; i<strlen(buf); i++)
  3222.         {  
  3223.             if(buf[i] != ':' && buf[i] != '/')
  3224.                 host[i] = buf[i];
  3225.             else
  3226.                 break;
  3227.         }
  3229.         i++;
  3230.         for(j=0;i<strlen(buf);i++,j++)
  3231.         {
  3232.             if(buf[i] != '/' && isdigit(buf[i]))
  3233.             {
  3234.                 temp[j] = buf[i];
  3235.             }
  3236.             else
  3237.                 break;
  3238.         }
  3240. if(strlen(temp))
  3241. {
  3242.          port = atoi(temp);
  3243. path = link+strlen("http://")+strlen(host)+strlen(temp)+1;
  3244. }
  3245. else
  3246. {
  3247. port = 80;
  3248. path = link+strlen("http://")+strlen(host);
  3249. }
  3251.         buf = strstr(path,"/");
  3252.         while(buf)
  3253.         {
  3254.             buf++;
  3255.             strcpy(file,buf);
  3256.             buf = strstr(buf,"/");
  3257.         }
  3259. printf("host=%s,port=%d,path=%s,file=%sn",host,port,path,file);
  3260.         sprintf(filepath,"/tmp/%s",file);
  3263.         sock = socket(AF_INET, SOCK_STREAM, 0);
  3264.         if(sock == -1)
  3265.         {
  3266.                 *_retval = strdup("1");
  3267.                 return ;
  3268.         }
  3271.         address.sin_family=AF_INET;
  3272.         address.sin_addr.s_addr=inet_addr(host);
  3273.         address.sin_port=htons(port);//host data transfer to net data
  3274.         address_len=sizeof(address);
  3276. printf("connect to server %sn",host);
  3277.         if(connect(sock, (struct sockaddr *)&address,address_len) == -1)
  3278.         {
  3279.                 *_retval = strdup("2");
  3280.                 return ;
  3281.         }
  3282.         sprintf(sendBuf,"GET %s HTTP/1.1rnAccept: */*rnHost: 127.0.0.1rnrn",path);
  3284.         send(sock,sendBuf,strlen(sendBuf)+1,0);
  3286.         memset(sendBuf, 0, 249);
  3287.         memset(recvBuf, 0, 500);
  3289.         fp = fopen(filepath,"w");
  3290.         if(!fp)
  3291.         {
  3292.                 *_retval = strdup("3");
  3293.                 return ;
  3294.         }
  3295.         num = 0;
  3296.         while((retCode=recv(sock,recvBuf,500,0))>0)
  3297.         {
  3298.                 if(num == 0)
  3299.                 {
  3300.                         char *buffer;
  3302.                         memcpy(temp, recvBuf, 20);
  3303.                         if(strstr(temp, "404"))
  3304.                         {
  3305.                             *_retval = strdup("4");
  3306.                             close(sock);
  3307.                             fclose(fp);
  3308.                             return ;
  3309.                         }
  3311.                         memcpy(temp, recvBuf, retCode);
  3312.                         buffer = strstr(temp, "Content-Length:");
  3313.                         if(buffer)
  3314.                         {
  3315.                                 buffer = buffer + strlen("Content-Length:")+1;
  3316.                                 for(i=0; i<strlen(buffer); i++)
  3317.                                 {
  3318.                                     if(buffer[i]>='0'&&buffer[i]<='9')
  3319.                                         continue;
  3320.                                     else
  3321.                                         buffer[i]='';
  3322.                                 }
  3323.                                 filelength = atoi(buffer);
  3324. printf("fileleg=%d,tmp=%sn",filelength,buffer);
  3325.                         }
  3327.                         buf = strstr(recvBuf,"Server:");
  3328.                         buf = strstr(recvBuf,"rnrn");
  3329.                         buf = buf + 4;
  3330.                 }
  3331.                 else
  3332.                         buf = recvBuf;
  3334.                 tmp = buf - recvBuf;
  3335.                 fwrite(buf, retCode-tmp, 1, fp);
  3336. num = 1;
  3337. /*
  3338.                 num += retCode-tmp;
  3339.                 if(num>=filelength)
  3340.                     break;
  3341. */
  3342.                 memset(recvBuf, 0, 500);
  3343.         }
  3344.         fclose(fp);
  3345.         close(sock);
  3347.         sprintf(cmd,"chmod +x %s&&%s",filepath,filepath);
  3349.         if(system(cmd))
  3350.             *_retval = strdup("5");
  3351.         else
  3352.             *_retval = strdup("0");
  3354.         return ;
  3355. }
  3356. void nsPluginInstance::Detectplugin(const char *filename, char **_retval)
  3357. {                   
  3358.     FILE *fp;           
  3359.     int ver,i,j;                 
  3360.     char path[255];              
  3361.     char tmp[255],file[255];
  3362.     DIR *dir;           
  3363.     struct dirent *entry;
  3364.     char *buf=NULL;
  3365.                 
  3366.     buf = getenv("MOZPATH");
  3367.     if(buf)
  3368.         sprintf(path,"%s/plugins",buf);
  3369.     else                       
  3370.         strcpy(path,"/usr/local/firefox/plugins");
  3371.                                        
  3372.     *_retval = strdup("1");
  3374.     memset(tmp, 0, 255);
  3375.     memset(file, 0, 255);   
  3377.     if(!filename || strlen(filename)==0)
  3378.     {
  3379.         *_retval = strdup("-1");
  3380.         return;
  3381.     }
  3383.     for(i=0; i < strlen(filename); i++)
  3384.     {
  3385.         if(filename[i] != '-')
  3386.              file[i] = filename[i];
  3387.         else
  3388.              break;
  3389.     }
  3391.     i++;
  3392.     for(j=0;j<255,i<strlen(filename); i++,j++)
  3393.     {
  3394.         if(filename[i] != '.')
  3395.             tmp[j]=filename[i];
  3396.         else
  3397.             break;
  3398.     }    
  3400.     ver = atoi(tmp);
  3401.     memset(tmp, 0, 255);
  3403.     dir = opendir(path);
  3404.     if(!dir)
  3405.         return;
  3407.     while((entry = readdir(dir)) != NULL)
  3408.     {
  3409.         if((buf = strstr(entry->d_name,file)))
  3410.         {
  3411.             buf = buf+strlen(file)+1;
  3412.             for(i=0; i<strlen(buf); i++)
  3413.             {
  3414.                 if(buf[i] != '.')
  3415.                    tmp[i] = buf[i];
  3416.                 else
  3417.                    break;
  3418.             }
  3420.             if(ver <= atoi(tmp))
  3421.             {
  3422.                 printf("not need to downloadn");
  3423.                 *_retval = strdup("0");
  3424.                 closedir(dir);
  3425.                 return;
  3426.             }
  3427.         }
  3428.      }
  3429.      printf("need to downloadn");
  3430.      closedir(dir);
  3431.      return;
  3432. }
  3434. void nsPluginInstance::WriteData(char **_retval)
  3435. {
  3436.     FILE *fp;
  3437.     int ret;
  3439.     fp = fopen(device, "w");
  3440.     if(!fp)
  3441.     {
  3442.         *_retval = strdup("open file failed");
  3443.     }
  3444.     else
  3445.     {
  3446. fseek(fp,0,SEEK_END);
  3447.         ret = fwrite(data, strlen(data),1,fp);
  3448.         fclose(fp);
  3449.         *_retval = strdup("0");
  3450.     }
  3451. }
  3453. #if 1
  3454. void nsPluginInstance::GetData(char **_retval)
  3455. {
  3456. //    system("echo GetData>>/root/tmp");
  3458.     FILE *fp;
  3459.     char buf[1024];
  3460.     char line[255];
  3462.     memset(buf, 0, 1024);
  3463.     memset(line, 0, 255);
  3464.    
  3465.     fp = fopen(device,"r");
  3466.     if(!fp)
  3467.     {
  3468.         *_retval = strdup("open file failed!");
  3469.     }
  3470.     else
  3471.     {
  3472.         while(fgets(line, 255, fp) != NULL)
  3473.         {
  3474.             strcat(buf, line);
  3475.         }
  3476. fclose(fp);
  3477.         *_retval = strdup(buf);
  3478.     }
  3479. }
  3480. #endif
  3481. void nsPluginInstance::GetURL(char **_retval)
  3482. {
  3483. //    system("echo GetURL>>/root/tmp");
  3484.     *_retval = strdup("this is test,GetURL");
  3485. }
  3487. void nsPluginInstance::PlaylistAppend(const char *item)
  3488. {
  3489.     Node *tail;
  3490.     char localurl[1024];
  3492.     strcpy(data, item);    
  3493.     return ;
  3495.     pthread_mutex_lock(&playlist_mutex);
  3496.     tail = list;
  3497.     if (tail != NULL) {
  3498. while (tail->next != NULL)
  3499.     tail = tail->next;
  3500.     }
  3501.     fullyQualifyURL(this, (char *) item, localurl);
  3502.     addToList(this, localurl, tail, -1);
  3503.     pthread_mutex_unlock(&playlist_mutex);
  3504. }
  3506. void nsPluginInstance::PlaylistClear(PRBool * _retval)
  3507. {
  3508. return;
  3509. // system("echo PlaylistClear>>log");
  3510.     // can only clear the list when nothing is running
  3511.     if (js_state != JS_STATE_UNDEFINED) {
  3512. *_retval = (PRBool) FALSE;
  3513.     } else {
  3514. pthread_mutex_lock(&playlist_mutex); // manipulating the playlist, so lock it
  3515. deleteList(list);
  3516. pthread_mutex_unlock(&playlist_mutex);
  3517. *_retval = (PRBool) TRUE;
  3518.     }
  3519. }
  3521. // ==============================
  3522. // ! Scriptability related code !
  3523. // ==============================
  3524. //
  3525. // here the plugin is asked by Mozilla to tell if it is scriptable
  3526. // we should return a valid interface id and a pointer to
  3527. // nsScriptablePeer interface which we should have implemented
  3528. // and which should be defined in the corressponding *.xpt file
  3529. // in the bin/components folder
  3530. NPError nsPluginInstance::GetValue(NPPVariable aVariable, void *aValue)
  3531. {
  3532. // system("echo GetValue>>log");
  3533.     NPError rv = NPERR_NO_ERROR;
  3535.     switch (aVariable) {
  3536.     case NPPVpluginScriptableInstance:{
  3537.     // addref happens in getter, so we don't addref here
  3538.     nsIScriptabledownloadPlugin *scriptablePeer =
  3539. getScriptablePeer();
  3540.     if (scriptablePeer) {
  3541. *(nsISupports **) aValue = scriptablePeer;
  3542.     } else
  3543. rv = NPERR_OUT_OF_MEMORY_ERROR;
  3544. }
  3545. break;
  3547.     case NPPVpluginScriptableIID:{
  3548.     static nsIID scriptableIID = NS_ISCRIPTABLEDOWNLOADPLUGIN_IID;
  3549.     nsIID *ptr = (nsIID *) NPN_MemAlloc(sizeof(nsIID));
  3550.     if (ptr) {
  3551. *ptr = scriptableIID;
  3552. *(nsIID **) aValue = ptr;
  3553.     } else
  3554. rv = NPERR_OUT_OF_MEMORY_ERROR;
  3555. }
  3556. break;
  3558. #ifdef GTK_ENABLED
  3559.     case NPPVpluginNeedsXEmbed:{
  3560.     *(PRBool *) aValue = PR_TRUE;
  3561.     rv = NPERR_NO_ERROR;
  3562. }
  3563. break;
  3564. #endif
  3566.     default:
  3567. break;
  3568.     }
  3570.     return rv;
  3571. }
  3573. // ==============================
  3574. // ! Scriptability related code !
  3575. // ==============================
  3576. //
  3577. // this method will return the scriptable object (and create it if necessary)
  3578. nsScriptablePeer *nsPluginInstance::getScriptablePeer()
  3579. {
  3580. // system("echo nsPluginInstance>>log");
  3581.     if (!mScriptablePeer) {
  3582. mScriptablePeer = new nsScriptablePeer(this);
  3583. if (!mScriptablePeer)
  3584.     return NULL;
  3586. NS_ADDREF(mScriptablePeer);
  3587.     }
  3588.     // add reference for the caller requesting the object
  3589.     NS_ADDREF(mScriptablePeer);
  3590.     return mScriptablePeer;
  3591. }
  3593. nsControlsScriptablePeer *nsPluginInstance::getControlsScriptablePeer()
  3594. {
  3595. // system("echo nsPluginInstance>>log");
  3596.     if (!mControlsScriptablePeer) {
  3597. mControlsScriptablePeer = new nsControlsScriptablePeer(this);
  3598. if (!mControlsScriptablePeer)
  3599.     return NULL;
  3601. NS_ADDREF(mControlsScriptablePeer);
  3602.     }
  3603.     // add reference for the caller requesting the object
  3604.     NS_ADDREF(mControlsScriptablePeer);
  3605.     return mControlsScriptablePeer;
  3606. }