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

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

PlugIns编程

开发平台：

Unix_Linux

plugin-ui.cpp：源码内容
  1. #include "plugin.h"
  2. #include <errno.h>
  4. extern int errno;
  5. extern int DEBUG;
  6. #include <X11/xpm.h>
  7. #include <X11/cursorfont.h>
  9. #ifdef X_ENABLED
  10. #include "../pixmaps/logo.xpm"
  11. #include "../pixmaps/progress_left.xpm"
  12. #include "../pixmaps/progress_middle.xpm"
  13. #include "../pixmaps/progress_right.xpm"
  14. #include "../pixmaps/progress_fill.xpm"
  15. #endif
  17. #ifdef GTK_ENABLED
  18. #include <gdk/gdkkeysyms.h>
  20. // 16 x 12 button pixmaps
  21. #include "../pixmaps/play_down_small.xpm"
  22. #include "../pixmaps/play_up_small.xpm"
  23. #include "../pixmaps/pause_down_small.xpm"
  24. #include "../pixmaps/pause_up_small.xpm"
  25. #include "../pixmaps/stop_down_small.xpm"
  26. #include "../pixmaps/stop_up_small.xpm"
  27. #include "../pixmaps/ff_down_small.xpm"
  28. #include "../pixmaps/ff_up_small.xpm"
  29. #include "../pixmaps/rew_down_small.xpm"
  30. #include "../pixmaps/rew_up_small.xpm"
  31. #include "../pixmaps/fs_down_small.xpm"
  32. #include "../pixmaps/fs_up_small.xpm"
  34. // default src button
  35. #include "../pixmaps/start.xpm"
  36. #endif
  38. #define BUTTON_WIDTH 43
  39. #define BUTTON_HEIGHT 32
  40. #define SMALL_BUTTON_WIDTH 21
  41. #define SMALL_BUTTON_HEIGHT 16
  43. #define BORDER               10
  44. #define LOGO_WIDTH          257
  45. #define LOGO_HEIGHT          48
  47. #ifndef HAVE_X11_XPM
  48. #error libXpm has not been found. Compilation cannot continue
  49. #endif
  51. #ifdef X_ENABLED
  52. unsigned long GetFontAtom(Display * dpy, XFontStruct * fs, char *atomname)
  53. {
  54.     unsigned long val;
  55.     Atom atom = XInternAtom(dpy, atomname, True);
  56.     XGetFontProperty(fs, atom, &val);
  57.     return val;
  58. }
  59. #endif
  61. void Initialize(Display * dpy, Drawable d, nsPluginInstance * instance,
  62. GC gc)
  63. {
  64. #ifdef X_ENABLED
  65.     Cursor guicursor;
  66.     XSetWindowAttributes attrs;
  67.     char **missing_charset_list_return;
  68.     int missing_charset_count_return;
  69.     char *def_string_return;
  71.     XpmCreatePixmapFromData(dpy, d, logo_xpm, &instance->logo,
  72.     &instance->logomask, NULL);
  73.     XpmCreatePixmapFromData(dpy, d, progress_left_xpm,
  74.     &instance->progress_left,
  75.     &instance->progress_leftmask, NULL);
  76.     XpmCreatePixmapFromData(dpy, d, progress_middle_xpm,
  77.     &instance->progress_middle,
  78.     &instance->progress_middlemask, NULL);
  79.     XpmCreatePixmapFromData(dpy, d, progress_right_xpm,
  80.     &instance->progress_right,
  81.     &instance->progress_rightmask, NULL);
  82.     XpmCreatePixmapFromData(dpy, d, progress_fill_xpm,
  83.     &instance->progress_fill,
  84.     &instance->progress_fillmask, NULL);
  86.     if (!instance->font) {
  87. XFontStruct *fstr;
  88. char *family;
  89. unsigned long size = 14;
  90. char *italic;
  91. char *bold;
  92. char fontname[256];
  94. fstr = XQueryFont(dpy, XGContextFromGC(gc));
  95. family = XGetAtomName(dpy, GetFontAtom(dpy, fstr, "FAMILY_NAME"));
  96. bold = XGetAtomName(dpy, GetFontAtom(dpy, fstr, "WEIGHT_NAME"));
  97. italic = XGetAtomName(dpy, GetFontAtom(dpy, fstr, "SLANT"));
  98. size = GetFontAtom(dpy, fstr, "PIXEL_SIZE");
  99. XFreeFontInfo(NULL, fstr, 0);
  100.     
  101. sprintf(fontname, "-*-%s-%s-%s-*--%d-*",
  102. family, bold, italic, (int) size);
  103. instance->font = XCreateFontSet(dpy,
  104. fontname,
  105. &missing_charset_list_return,
  106. &missing_charset_count_return,
  107. &def_string_return);
  108.     }
  110.     guicursor = XCreateFontCursor(dpy, XC_watch);
  111.     attrs.cursor = guicursor;
  112.     XChangeWindowAttributes(dpy, d, CWCursor, &attrs);
  113. #endif
  114. }
  116. void InitPixbufs(nsPluginInstance * instance)
  117. {
  118. #ifdef GTK2_ENABLED
  120.     instance->pb_sm_play_up =
  121. gdk_pixbuf_new_from_xpm_data((const char **) play_up_small);
  122.     instance->pb_sm_play_down =
  123. gdk_pixbuf_new_from_xpm_data((const char **) play_down_small);
  124.     instance->pb_sm_pause_up =
  125. gdk_pixbuf_new_from_xpm_data((const char **) pause_up_small);
  126.     instance->pb_sm_pause_down =
  127. gdk_pixbuf_new_from_xpm_data((const char **) pause_down_small);
  128.     instance->pb_sm_stop_up =
  129. gdk_pixbuf_new_from_xpm_data((const char **) stop_up_small);
  130.     instance->pb_sm_stop_down =
  131. gdk_pixbuf_new_from_xpm_data((const char **) stop_down_small);
  132.     instance->pb_sm_ff_up =
  133. gdk_pixbuf_new_from_xpm_data((const char **) ff_up_small);
  134.     instance->pb_sm_ff_down =
  135. gdk_pixbuf_new_from_xpm_data((const char **) ff_down_small);
  136.     instance->pb_sm_rew_up =
  137. gdk_pixbuf_new_from_xpm_data((const char **) rew_up_small);
  138.     instance->pb_sm_rew_down =
  139. gdk_pixbuf_new_from_xpm_data((const char **) rew_down_small);
  140.     instance->pb_sm_fs_up =
  141. gdk_pixbuf_new_from_xpm_data((const char **) fs_up_small);
  142.     instance->pb_sm_fs_down =
  143. gdk_pixbuf_new_from_xpm_data((const char **) fs_down_small);
  144. #endif
  146. #ifdef GTK1_ENABLED
  148.     instance->pb_sm_play_up =
  149. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  150.      NULL, NULL, play_up_small);
  151.     instance->pb_sm_play_down =
  152. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  153.      NULL, NULL, play_down_small);
  154.     instance->pb_sm_pause_up =
  155. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  156.      NULL, NULL, pause_up_small);
  157.     instance->pb_sm_pause_down =
  158. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  159.      NULL, NULL, pause_down_small);
  160.     instance->pb_sm_stop_up =
  161. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  162.      NULL, NULL, stop_up_small);
  163.     instance->pb_sm_stop_down =
  164. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  165.      NULL, NULL, stop_down_small);
  166.     instance->pb_sm_ff_up =
  167. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  168.      NULL, NULL, ff_up_small);
  169.     instance->pb_sm_ff_down =
  170. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  171.      NULL, NULL, ff_down_small);
  172.     instance->pb_sm_rew_up =
  173. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  174.      NULL, NULL, rew_up_small);
  175.     instance->pb_sm_rew_down =
  176. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  177.      NULL, NULL, rew_down_small);
  178.     instance->pb_sm_fs_up =
  179. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  180.      NULL, NULL, fs_up_small);
  181.     instance->pb_sm_fs_down =
  182. gdk_pixmap_create_from_xpm_d(instance->gtkwidget->window,
  183.      NULL, NULL, fs_down_small);
  185. #endif
  186. }
  188. void DrawLogo(Display * dpy, Drawable d, nsPluginInstance * instance,
  189.       GC gc)
  190. {
  191. #ifdef X_ENABLED
  192.     XGCValues values;
  194.     values.clip_mask = instance->logomask;
  195.     values.clip_x_origin = 0;
  196.     values.clip_y_origin = 0;
  197.     XChangeGC(dpy, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin,
  198.       &values);
  199.     XCopyArea(dpy, instance->logo, d, gc, 0, 0, LOGO_WIDTH, LOGO_HEIGHT, 0,
  200.       0);
  201.     values.clip_mask = (Pixmap) NULL;
  202.     XChangeGC(dpy, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin,
  203.       &values);
  204. #endif
  205. }
  208. void DrawProgressBG(Display * dpy, Window w, nsPluginInstance * instance,
  209.     int x, int y, int width, int height)
  210. {
  211. #ifdef X_ENABLED
  212.     XGCValues values;
  213.     GC border_gc;
  215.     border_gc = XCreateGC(dpy, w, GCForeground, &values);
  217.     values.clip_mask = instance->progress_leftmask;
  218.     values.clip_x_origin = x - 10;
  219.     values.clip_y_origin = y - 10;
  220.     XChangeGC(dpy, border_gc, GCClipMask | GCClipXOrigin | GCClipYOrigin,
  221.       &values);
  222.     XCopyArea(dpy, instance->progress_left, (Drawable) w, border_gc, 0, 0,
  223.       10, 31, x - 10, y - 10);
  224.     values.clip_mask = (Pixmap) NULL;
  225.     XChangeGC(dpy, border_gc, GCClipMask | GCClipXOrigin | GCClipYOrigin,
  226.       &values);
  228.     XSetTile(dpy, border_gc, instance->progress_middle);
  229.     XSetFillStyle(dpy, border_gc, FillTiled);
  230.     XSetTSOrigin(dpy, border_gc, x, y - 10);
  231.     XFillRectangle(dpy, w, border_gc, x, y - 10, width, 31);
  232.     XSetFillStyle(dpy, border_gc, FillSolid);
  234.     values.clip_mask = instance->progress_rightmask;
  235.     values.clip_x_origin = x + width;
  236.     values.clip_y_origin = y - 10;
  237.     XChangeGC(dpy, border_gc, GCClipMask | GCClipXOrigin | GCClipYOrigin,
  238.       &values);
  239.     XCopyArea(dpy, instance->progress_right, (Drawable) w, border_gc, 0, 0,
  240.       10, 31, x + width, y - 10);
  241.     values.clip_mask = (Pixmap) NULL;
  242.     XChangeGC(dpy, border_gc, GCClipMask | GCClipXOrigin | GCClipYOrigin,
  243.       &values);
  245.     XFreeGC(dpy, border_gc);
  246. #endif
  247. }
  249. void DrawProgress(Display * dpy, Window w, nsPluginInstance * instance,
  250.   int x, int y, int width, int height, int percent)
  251. {
  252. #ifdef X_ENABLED
  253.     GC progress_gc;
  254.     int pixelpercent;
  255.     XGCValues values;
  257.     if (percent > 100)
  258. percent = 100;
  259.     progress_gc = XCreateGC(dpy, w, GCForeground, &values);
  260.     XSetTile(dpy, progress_gc, instance->progress_fill);
  261.     XSetFillStyle(dpy, progress_gc, FillTiled);
  262.     XSetTSOrigin(dpy, progress_gc, x, y);
  263.     pixelpercent = (int) ((width - x) * (percent / 100.));
  264.     XFillRectangle(dpy, w, progress_gc, x, y, pixelpercent, height);
  265.     XSetFillStyle(dpy, progress_gc, FillSolid);
  266.     XFreeGC(dpy, progress_gc);
  267. #endif
  268. }
  272. void DrawUI(Widget w, nsPluginInstance * instance, char *message,
  273.     int FullRedraw, int percent)
  274. {
  275. #ifdef X_ENABLED
  276.     GC black_gc, white_gc;
  277.     XGCValues values;
  278.     const char *id = "downloadplug-in v" PACKAGE_VERSION;
  279.     unsigned int id_width;
  280.     int top, font_height, loops;
  281.     int term, chop;
  282.     int PercentRedraw;
  284.     if (0) {
  285. printf("Widget: %in", (int) w);
  286. printf("Message: %sn", message);
  287.     }
  289.     if (DEBUG > 1)
  290. printf("state = %i, height = %i width = %in", instance->state,
  291.        instance->movie_height, instance->movie_width);
  293.     if (w == NULL)
  294. return;
  295.     if (instance->state < STATE_READY)
  296. return;
  297.     if (message == NULL)
  298. return;
  299.     if (instance->display == NULL)
  300. return;
  301.     if (instance->state == STATE_PLAYING && instance->movie_height > 0
  302. && instance->movie_width > 0)
  303. return;
  305.     sprintf(instance->lastmessage, "%s", message);
  307.     values.foreground =
  308. BlackPixel((Display *) instance->display,
  309.    DefaultScreen((Display *) instance->display));
  310.     black_gc =
  311. XCreateGC((Display *) instance->display,
  312.   (Drawable) instance->window, GCForeground, &values);
  313.     values.foreground =
  314. WhitePixel((Display *) instance->display,
  315.    DefaultScreen((Display *) instance->display));
  316.     white_gc =
  317. XCreateGC((Display *) instance->display,
  318.   (Drawable) instance->window, GCForeground, &values);
  320.     PercentRedraw = FALSE;
  321.     if (percent != -1 && instance->lastpercent != -1
  322. && instance->lastpercent > percent)
  323. PercentRedraw = TRUE;
  324.     if (instance->font == NULL) {
  325. FullRedraw = TRUE;
  326. Initialize((Display *) instance->display,
  327.    (Drawable) instance->window, instance, black_gc);
  328.     }
  330.     XFontSetExtents *extent;
  331.     extent = XExtentsOfFontSet(instance->font);
  332.     font_height = extent->max_logical_extent.height;
  333.     id_width = XmbTextEscapement(instance->font, id, strlen(id));
  335.     if (FullRedraw || instance->window_height <= 80) {
  336. XFillRectangle((Display *) instance->display,
  337.        (Drawable) instance->window, white_gc, 0, 0,
  338.        instance->window_width, instance->window_height);
  339.     } else {
  340. XFillRectangle((Display *) instance->display,
  341.        (Drawable) instance->window, white_gc, BORDER,
  342.        LOGO_HEIGHT, instance->window_width - BORDER * 2,
  343.        instance->window_height - font_height -
  344.        LOGO_HEIGHT - BORDER - 10);
  345.     }
  347.     if (instance->window_height > 80
  348. && instance->window_width > id_width + BORDER * 2) {
  349. top = BORDER * 2 + LOGO_HEIGHT;
  350. loops = 0;
  351. if (FullRedraw) {
  352.     DrawLogo((Display *) instance->display,
  353.      (Drawable) instance->window, instance, black_gc);
  354.     XmbDrawString((Display *) instance->display,
  355.   (Drawable) instance->window, instance->font,
  356.   black_gc,
  357.   instance->window_width - id_width - BORDER,
  358.   instance->window_height - font_height, id,
  359.   strlen(id));
  360. }
  361. if ((FullRedraw || PercentRedraw)
  362.     && instance->window_width > id_width + BORDER * 3 + 100)
  363.     // The height is set to 11 (my value for font_height)
  364.     // since the progress image only has 11 pixels of space
  365.     DrawProgressBG((Display *) instance->display,
  366.    (Drawable) instance->window,
  367.    instance,
  368.    BORDER,
  369.    instance->window_height - font_height - BORDER,
  370.    instance->window_width - id_width - BORDER * 3,
  371.    11);
  374. // Loop a max of 10 times in case of problems (like too small of a width)
  375. while (strlen(message) != 0 && loops < 10) {
  376.     chop = 0;
  377.     term = 0;
  378.     while (XmbTextEscapement
  379.    (instance->font, message,
  380.     strlen(message) - chop) + BORDER * 2 >
  381.    (int) instance->window_width)
  382. chop++;
  383.     if (strchr(message, 'n') != NULL &&
  384. (int) (strchr(message, 'n') - message) <
  385. (int) (strlen(message) - chop)) {
  386. chop = strlen(message) - (strchr(message, 'n') - message);
  387. term = 1;
  388.     }
  389.     XmbDrawString((Display *) instance->display,
  390.   (Drawable) instance->window, instance->font,
  391.   black_gc, BORDER, top, message,
  392.   strlen(message) - chop);
  393.     message += strlen(message) - chop + term;
  394.     top += font_height;
  395.     loops++;
  396.     if (top > (int) instance->window_height - font_height - BORDER)
  397. break;
  398. }
  400. // Make sure we have at least 100 px in addition to the id tag and borders
  401. if (percent != -1
  402.     && instance->window_width > id_width + BORDER * 3 + 100)
  403.     DrawProgress((Display *) instance->display,
  404.  (Drawable) instance->window,
  405.  instance,
  406.  BORDER,
  407.  instance->window_height - font_height - BORDER,
  408.  instance->window_width - id_width - BORDER * 3,
  409.  11, percent);
  410. else if (FullRedraw && instance->lastpercent != -1
  411.  && instance->window_width > id_width + BORDER * 3 + 100)
  412.     DrawProgress((Display *) instance->display,
  413.  (Drawable) instance->window,
  414.  instance,
  415.  BORDER,
  416.  instance->window_height - font_height - BORDER,
  417.  instance->window_width - id_width - BORDER * 3,
  418.  11, instance->lastpercent);
  420.     } else {
  421. XmbDrawString((Display *) instance->display,
  422.       (Drawable) instance->window, instance->font,
  423.       black_gc, BORDER, 15, message, strlen(message));
  424.     }
  425.     if (percent != -1)
  426. instance->lastpercent = percent;
  428.     XFreeGC((Display *) instance->display, black_gc);
  429.     XFreeGC((Display *) instance->display, white_gc);
  431.     XFlush((Display *) instance->display);
  432.     usleep(100);
  433. #endif
  434. }
  436. void FreeUI(Display * dpy, nsPluginInstance * instance)
  437. {
  438. #ifdef X_ENABLED
  439.     if (instance->font)
  440. XFreeFontSet(dpy, instance->font);
  441.     // Free all the pixmaps used by the GUI
  442.     if (instance->progress_left)
  443. XFreePixmap(dpy, instance->progress_left);
  444.     if (instance->progress_leftmask)
  445. XFreePixmap(dpy, instance->progress_leftmask);
  446.     if (instance->progress_middle)
  447. XFreePixmap(dpy, instance->progress_middle);
  448.     if (instance->progress_middlemask)
  449. XFreePixmap(dpy, instance->progress_middlemask);
  450.     if (instance->progress_right)
  451. XFreePixmap(dpy, instance->progress_right);
  452.     if (instance->progress_rightmask)
  453. XFreePixmap(dpy, instance->progress_rightmask);
  454.     if (instance->progress_fill)
  455. XFreePixmap(dpy, instance->progress_fill);
  456.     if (instance->progress_fillmask)
  457. XFreePixmap(dpy, instance->progress_fillmask);
  458.     if (instance->logo)
  459. XFreePixmap(dpy, instance->logo);
  460.     if (instance->logomask)
  461. XFreePixmap(dpy, instance->logomask);
  462.     // Don't free the font since we didn't create it
  463.     instance->logo = (Pixmap) NULL;
  464.     instance->logomask = (Pixmap) NULL;
  465.     instance->progress_left = (Pixmap) NULL;
  466.     instance->progress_leftmask = (Pixmap) NULL;
  467.     instance->progress_middle = (Pixmap) NULL;
  468.     instance->progress_middlemask = (Pixmap) NULL;
  469.     instance->progress_right = (Pixmap) NULL;
  470.     instance->progress_rightmask = (Pixmap) NULL;
  471.     instance->progress_fill = (Pixmap) NULL;
  472.     instance->progress_fillmask = (Pixmap) NULL;
  473.     instance->font = (XFontSet) NULL;
  474. #endif
  475. }
  477. void RedrawCB(Widget widget, XtPointer client_data, XtPointer call_data)
  478. {
  479.     char message[1024];
  481.     nsPluginInstance *instance = (nsPluginInstance *) client_data;
  482.     if (DEBUG)
  483. printf("redrawing windown");
  485.     if (instance->noredraw)
  486. return;
  488.     if (instance != NULL) {
  489. if (instance->lastmessage != NULL) {
  490.     if (strlen(instance->lastmessage) != 0) {
  491. if (instance->state >= STATE_GETTING_PLAYLIST) {
  492.     strcpy(message, instance->lastmessage);
  493. #ifdef X_ENABLED
  494.     DrawUI(instance->widget, instance, message, 1, -1);
  495. #endif
  496. }
  497.     }
  498. }
  499.     }
  500. }
  502. #ifdef GTK_ENABLED
  503. void play_callback(GtkWidget * widget, GdkEventExpose * event,
  504.    nsPluginInstance * instance)
  505. {
  506.     if (DEBUG)
  507. printf("play clickdn");
  509.     if (instance == NULL)
  510. return;
  511.     if (instance->panel_drawn == 0 && instance->controlsvisible == 1)
  512. return;
  513.     if (instance->controlsvisible == 1) {
  514. if (instance->panel_height > 16)
  515.     instance->panel_height = 16;
  517. instance->redrawbuttons = 1;
  518. gtk_container_remove(GTK_CONTAINER(instance->play_event_box),
  519.      instance->image_play);
  520. gtk_container_remove(GTK_CONTAINER(instance->pause_event_box),
  521.      instance->image_pause);
  522. gtk_container_remove(GTK_CONTAINER(instance->stop_event_box),
  523.      instance->image_stop);
  524. #ifdef GTK2_ENABLED
  525. instance->image_play =
  526.     gtk_image_new_from_pixbuf(instance->pb_sm_play_down);
  527. instance->image_pause =
  528.     gtk_image_new_from_pixbuf(instance->pb_sm_pause_up);
  529. instance->image_stop =
  530.     gtk_image_new_from_pixbuf(instance->pb_sm_stop_up);
  531. #endif
  532. #ifdef GTK1_ENABLED
  533. instance->image_play =
  534.     gtk_pixmap_new(instance->pb_sm_play_down, NULL);
  535. instance->image_pause =
  536.     gtk_pixmap_new(instance->pb_sm_pause_up, NULL);
  537. instance->image_stop =
  538.     gtk_pixmap_new(instance->pb_sm_stop_up, NULL);
  539. #endif
  541. gtk_container_add(GTK_CONTAINER(instance->play_event_box),
  542.   instance->image_play);
  543. gtk_container_add(GTK_CONTAINER(instance->pause_event_box),
  544.   instance->image_pause);
  545. gtk_container_add(GTK_CONTAINER(instance->stop_event_box),
  546.   instance->image_stop);
  547. if (instance->showbuttons) {
  548.     gtk_widget_show(instance->image_play);
  549.     gtk_widget_show(instance->image_pause);
  550.     gtk_widget_show(instance->image_stop);
  552.     gtk_widget_show(instance->play_event_box);
  553.     gtk_widget_show(instance->pause_event_box);
  554.     gtk_widget_show(instance->stop_event_box);
  555. }
  556. gtk_widget_show(instance->fixed_container);
  557. if (instance->drawing_area != NULL) {
  558.     gtk_widget_hide(GTK_WIDGET(instance->drawing_area));
  559.     gtk_widget_show(GTK_WIDGET(instance->drawing_area));
  560. }
  561. if (GTK_IS_WIDGET(instance->src_event_box)
  562.     && instance->targetplayer == 0) {
  563.     gtk_widget_hide(instance->src_event_box);
  564. }
  565. gdk_flush();
  566.     }
  567.     if (widget != NULL)
  568. instance->Play();
  569. }
  571. void pause_callback(GtkWidget * widget, GdkEventExpose * event,
  572.     nsPluginInstance * instance)
  573. {
  574.     if (DEBUG)
  575. printf("pause clickdn");
  577.     if (instance == NULL)
  578. return;
  579.     if (instance->panel_drawn == 0 && instance->controlsvisible == 1)
  580. return;
  581.     if (instance->controlsvisible == 1) {
  582. if (instance->panel_height > 16)
  583.     instance->panel_height = 16;
  585. gtk_container_remove(GTK_CONTAINER(instance->play_event_box),
  586.      instance->image_play);
  587. gtk_container_remove(GTK_CONTAINER(instance->pause_event_box),
  588.      instance->image_pause);
  589. gtk_container_remove(GTK_CONTAINER(instance->stop_event_box),
  590.      instance->image_stop);
  592. #ifdef GTK2_ENABLED
  593. instance->image_play =
  594.     gtk_image_new_from_pixbuf(instance->pb_sm_play_up);
  595. instance->image_pause =
  596.     gtk_image_new_from_pixbuf(instance->pb_sm_pause_down);
  597. instance->image_stop =
  598.     gtk_image_new_from_pixbuf(instance->pb_sm_stop_up);
  599. #endif
  600. #ifdef GTK1_ENABLED
  601. instance->image_play =
  602.     gtk_pixmap_new(instance->pb_sm_play_up, NULL);
  603. instance->image_pause =
  604.     gtk_pixmap_new(instance->pb_sm_pause_down, NULL);
  605. instance->image_stop =
  606.     gtk_pixmap_new(instance->pb_sm_stop_up, NULL);
  607. #endif
  609. gtk_container_add(GTK_CONTAINER(instance->play_event_box),
  610.   instance->image_play);
  611. gtk_container_add(GTK_CONTAINER(instance->pause_event_box),
  612.   instance->image_pause);
  613. gtk_container_add(GTK_CONTAINER(instance->stop_event_box),
  614.   instance->image_stop);
  616. if (instance->showbuttons) {
  617.     gtk_widget_show(instance->image_play);
  618.     gtk_widget_show(instance->image_pause);
  619.     gtk_widget_show(instance->image_stop);
  621.     gtk_widget_show(instance->play_event_box);
  622.     gtk_widget_show(instance->pause_event_box);
  623.     gtk_widget_show(instance->stop_event_box);
  624. }
  625. gtk_widget_show(instance->fixed_container);
  626. if (instance->drawing_area != NULL)
  627.     gtk_widget_show(GTK_WIDGET(instance->drawing_area));
  628. gdk_flush();
  629.     }
  630.     if (widget != NULL)
  631. instance->Pause();
  632. }
  634. void stop_callback(GtkWidget * widget, GdkEventExpose * event,
  635.    nsPluginInstance * instance)
  636. {
  637.     if (DEBUG)
  638. printf("stop clickdn");
  640.     if (instance == NULL)
  641. return;
  642.     if (instance->mInitialized == FALSE)
  643. return;
  644.     if (instance->panel_drawn == 0 && instance->controlsvisible == 1)
  645. return;
  646.     if (instance->controlsvisible == 1) {
  647. if (instance->panel_height > 16)
  648.     instance->panel_height = 16;
  650. gtk_container_remove(GTK_CONTAINER(instance->play_event_box),
  651.      instance->image_play);
  652. gtk_container_remove(GTK_CONTAINER(instance->pause_event_box),
  653.      instance->image_pause);
  654. gtk_container_remove(GTK_CONTAINER(instance->stop_event_box),
  655.      instance->image_stop);
  657. #ifdef GTK2_ENABLED
  658. instance->image_play =
  659.     gtk_image_new_from_pixbuf(instance->pb_sm_play_up);
  660. instance->image_pause =
  661.     gtk_image_new_from_pixbuf(instance->pb_sm_pause_up);
  662. instance->image_stop =
  663.     gtk_image_new_from_pixbuf(instance->pb_sm_stop_down);
  664. #endif
  665. #ifdef GTK1_ENABLED
  666. instance->image_play =
  667.     gtk_pixmap_new(instance->pb_sm_play_up, NULL);
  668. instance->image_pause =
  669.     gtk_pixmap_new(instance->pb_sm_pause_up, NULL);
  670. instance->image_stop =
  671.     gtk_pixmap_new(instance->pb_sm_stop_down, NULL);
  672. #endif
  673. gtk_container_add(GTK_CONTAINER(instance->play_event_box),
  674.   instance->image_play);
  675. gtk_container_add(GTK_CONTAINER(instance->pause_event_box),
  676.   instance->image_pause);
  677. gtk_container_add(GTK_CONTAINER(instance->stop_event_box),
  678.   instance->image_stop);
  679. if (instance->showbuttons) {
  680.     gtk_widget_show(instance->image_play);
  681.     gtk_widget_show(instance->image_pause);
  682.     gtk_widget_show(instance->image_stop);
  684.     gtk_widget_show(instance->play_event_box);
  685.     gtk_widget_show(instance->pause_event_box);
  686.     gtk_widget_show(instance->stop_event_box);
  687. }
  688. gtk_widget_show(instance->fixed_container);
  689. gtk_widget_hide(GTK_WIDGET(instance->progress_bar));
  690. if (instance->drawing_area != NULL) {
  691.     gtk_widget_hide(GTK_WIDGET(instance->drawing_area));
  692.     snprintf(instance->lastmessage, 1024, _("Stopped"));
  693.     g_idle_add(gtkgui_message, instance);
  694.     gtk_widget_hide(GTK_WIDGET(instance->mediaprogress_bar));
  695. }
  696. if (instance->showlogo)
  697.     if (GTK_IS_WIDGET(instance->image))
  698. gtk_widget_show(GTK_WIDGET(instance->image));
  700. if (!instance->hidestatus)
  701.     if (GTK_IS_WIDGET(instance->status))
  702. gtk_widget_show(GTK_WIDGET(instance->status));
  704. gdk_flush();
  705.     }
  706.     if (widget != NULL)
  707. instance->Stop();
  709. }
  711. void ff_callback(GtkWidget * widget, GdkEventExpose * event,
  712.  nsPluginInstance * instance)
  713. {
  714.     if (instance == NULL)
  715. return;
  716.     if (instance->panel_drawn == 0 && instance->controlsvisible == 1)
  717. return;
  718.     if (instance->controlsvisible == 1 && instance->mmsstream == 0) {
  719. if (instance->panel_height > 16)
  720.     instance->panel_height = 16;
  722. gtk_container_remove(GTK_CONTAINER(instance->ff_event_box),
  723.      instance->image_ff);
  724. #ifdef GTK2_ENABLED
  725. instance->image_ff =
  726.     gtk_image_new_from_pixbuf(instance->pb_sm_ff_down);
  727. #endif
  728. #ifdef GTK1_ENABLED
  729. instance->image_ff = gtk_pixmap_new(instance->pb_sm_ff_down, NULL);
  730. #endif
  732. gtk_container_add(GTK_CONTAINER(instance->ff_event_box),
  733.   instance->image_ff);
  734. if (instance->showbuttons) {
  735.     gtk_widget_show(instance->image_ff);
  736.     gtk_widget_show(instance->ff_event_box);
  737. }
  738. gdk_flush();
  739. instance->FastForward();
  740. usleep(500);
  742. gtk_container_remove(GTK_CONTAINER(instance->ff_event_box),
  743.      instance->image_ff);
  744. #ifdef GTK2_ENABLED
  745. instance->image_ff =
  746.     gtk_image_new_from_pixbuf(instance->pb_sm_ff_up);
  747. #endif
  748. #ifdef GTK1_ENABLED
  749. instance->image_ff = gtk_pixmap_new(instance->pb_sm_ff_up, NULL);
  750. #endif
  752. gtk_container_add(GTK_CONTAINER(instance->ff_event_box),
  753.   instance->image_ff);
  754. if (instance->showbuttons) {
  755.     gtk_widget_show(instance->image_ff);
  756.     gtk_widget_show(instance->ff_event_box);
  757. }
  758.     }
  760. }
  762. void rew_callback(GtkWidget * widget, GdkEventExpose * event,
  763.   nsPluginInstance * instance)
  764. {
  765.     if (instance == NULL)
  766. return;
  767.     if (instance->panel_drawn == 0 && instance->controlsvisible == 1)
  768. return;
  769.     if (instance->controlsvisible == 1 && instance->mmsstream == 0) {
  771. if (instance->panel_height > 16)
  772.     instance->panel_height = 16;
  774. gtk_container_remove(GTK_CONTAINER(instance->rew_event_box),
  775.      instance->image_rew);
  776. #ifdef GTK2_ENABLED
  777. instance->image_rew =
  778.     gtk_image_new_from_pixbuf(instance->pb_sm_rew_down);
  779. #endif
  780. #ifdef GTK1_ENABLED
  781. instance->image_rew =
  782.     gtk_pixmap_new(instance->pb_sm_rew_down, NULL);
  783. #endif
  785. gtk_container_add(GTK_CONTAINER(instance->rew_event_box),
  786.   instance->image_rew);
  787. if (instance->showbuttons) {
  788.     gtk_widget_show(instance->image_rew);
  789.     gtk_widget_show(instance->rew_event_box);
  790. }
  791. gdk_flush();
  792. instance->FastReverse();
  793. usleep(500);
  795. gtk_container_remove(GTK_CONTAINER(instance->rew_event_box),
  796.      instance->image_rew);
  797. #ifdef GTK2_ENABLED
  798. instance->image_rew =
  799.     gtk_image_new_from_pixbuf(instance->pb_sm_rew_up);
  800. #endif
  801. #ifdef GTK1_ENABLED
  802. instance->image_rew = gtk_pixmap_new(instance->pb_sm_rew_up, NULL);
  803. #endif
  805. gtk_container_add(GTK_CONTAINER(instance->rew_event_box),
  806.   instance->image_rew);
  807. if (instance->showbuttons) {
  808.     gtk_widget_show(instance->image_rew);
  809.     gtk_widget_show(instance->rew_event_box);
  810. }
  811.     }
  813. }
  815. void fs_callback(GtkWidget * widget, GdkEventExpose * event,
  816.  nsPluginInstance * instance)
  817. {
  818.     if (DEBUG)
  819. printf("fs_callback clickedn");
  820.     if (instance == NULL)
  821. return;
  823.     if (instance->panel_drawn == 0 && instance->controlsvisible == 1)
  824. return;
  826.     if (instance->controlsvisible == 1) {
  827. if (instance->panel_height > 16)
  828.     instance->panel_height = 16;
  830. gtk_container_remove(GTK_CONTAINER(instance->fs_event_box),
  831.      instance->image_fs);
  832. if (widget != NULL)
  833.     instance->SetFullscreen(!instance->fullscreen);
  835. if (instance->fullscreen == 0) {
  836. #ifdef GTK2_ENABLED
  837.     instance->image_fs =
  838. gtk_image_new_from_pixbuf(instance->pb_sm_fs_up);
  839. #endif
  840. #ifdef GTK1_ENABLED
  841.     instance->image_fs =
  842. gtk_pixmap_new(instance->pb_sm_fs_up, NULL);
  843. #endif
  844. } else {
  845. #ifdef GTK2_ENABLED
  846.     instance->image_fs =
  847. gtk_image_new_from_pixbuf(instance->pb_sm_fs_down);
  848. #endif
  849. #ifdef GTK1_ENABLED
  850.     instance->image_fs =
  851. gtk_pixmap_new(instance->pb_sm_fs_down, NULL);
  852. #endif
  855. }
  856. gtk_container_add(GTK_CONTAINER(instance->fs_event_box),
  857.   instance->image_fs);
  859. if (instance->showfsbutton && instance->showbuttons) {
  860.     gtk_widget_show(instance->image_fs);
  861.     gtk_widget_show(instance->fs_event_box);
  862. }
  863. gtk_widget_show(instance->fixed_container);
  864. gdk_flush();
  865.     }
  866. }
  868. gboolean keyboard_callback(GtkWidget * widget, GdkEventKey * event,
  869.    nsPluginInstance * instance)
  870. {
  871.     if (DEBUG)
  872. printf("In keyboard_callback with %in", event->keyval);
  874.     if ((event->keyval == GDK_P) || (event->keyval == GDK_p)
  875. || (event->keyval == GDK_space)) {
  876. if (instance->paused) {
  877.     play_callback(widget, (GdkEventExpose *) NULL, instance);
  878. } else {
  879.     pause_callback(widget, (GdkEventExpose *) NULL, instance);
  880. }
  881. return TRUE;
  882.     }
  884.     if ((event->keyval == GDK_S) || (event->keyval == GDK_s)) {
  885. stop_callback(widget, (GdkEventExpose *) NULL, instance);
  886. return TRUE;
  887.     }
  889.     if ((event->keyval == GDK_less) || (event->keyval == GDK_comma)) {
  890. rew_callback(widget, (GdkEventExpose *) NULL, instance);
  891. return TRUE;
  892.     }
  894.     if ((event->keyval == GDK_greater) || (event->keyval == GDK_period)) {
  895. ff_callback(widget, (GdkEventExpose *) NULL, instance);
  896. return TRUE;
  897.     }
  899.     if ((event->keyval == GDK_F) || (event->keyval == GDK_f)) {
  900. fs_callback(widget, (GdkEventExpose *) NULL, instance);
  901. return TRUE;
  902.     }
  905.     return FALSE;
  906. }
  908. gboolean mouse_callback(GtkWidget * widget, GdkEventButton * event,
  909. nsPluginInstance * instance)
  910. {
  911.     char buffer1[1024];
  912.     char buffer2[1024];
  913.     char *p;
  915.     if (DEBUG)
  916. printf("In mouse_callbackn");
  917.     if (event->type == GDK_BUTTON_PRESS) {
  918. if (DEBUG)
  919.     printf("button press # %in", event->button);
  920. if (event->button == 1) {
  921.     if (instance->mouseClickCallback != NULL)
  922. NPN_GetURL(instance->mInstance,
  923.    instance->mouseClickCallback, "_self");
  924. }
  925. if (instance->mouseDownCallback != NULL) {
  926.     strlcpy(buffer1, instance->mouseDownCallback, 1024);
  927.     p = index(buffer1, '(');
  928.     if (p == NULL) {
  929. p = buffer1 + strlen(buffer1);
  930.     }
  931.     *p = '';
  932.     snprintf(buffer2, 1024, "%s(%i);", buffer1, event->button);
  933.     NPN_MemFree(instance->mouseDownCallback);
  934.     instance->mouseDownCallback =
  935. (char *) NPN_MemAlloc(strlen(buffer2));
  936.     strlcpy(instance->mouseDownCallback, buffer2, strlen(buffer2));
  937.     NPN_GetURL(instance->mInstance,
  938.        instance->mouseDownCallback, "_self");
  939. }
  940.     }
  942.     if (event->type == GDK_BUTTON_RELEASE) {
  943. if (DEBUG)
  944.     printf("button released # %in", event->button);
  945. if (instance->mouseUpCallback != NULL) {
  946.     strlcpy(buffer1, instance->mouseUpCallback, 1024);
  947.     p = index(buffer1, '(');
  948.     if (p == NULL) {
  949. p = buffer1 + strlen(buffer1);
  950.     }
  951.     *p = '';
  952.     snprintf(buffer2, 1024, "%s(%i);", buffer1, event->button);
  953.     NPN_MemFree(instance->mouseUpCallback);
  954.     instance->mouseUpCallback =
  955. (char *) NPN_MemAlloc(strlen(buffer2));
  956.     strlcpy(instance->mouseUpCallback, buffer2, strlen(buffer2));
  958.     NPN_GetURL(instance->mInstance,
  959.        instance->mouseUpCallback, "_self");
  960. }
  961.     }
  963.     return FALSE;
  964. }
  966. gboolean mediaprogress_callback(GtkWidget * widget, GdkEventButton * event,
  967. nsPluginInstance * instance)
  968. {
  969.     GtkRequisition *req;
  970.     float percent;
  971.     float bytepercent;
  972.     float seektime;
  974.     req = (GtkRequisition *) NPN_MemAlloc(sizeof(GtkRequisition));
  975.     gtk_widget_size_request(widget, req);
  978.     percent = event->x / req->width;
  980.     if (instance->currentnode != NULL) {
  981. if (instance->currentnode->totalbytes != 0) {
  982.     bytepercent =
  983. (float) instance->currentnode->bytes /
  984. (float) instance->currentnode->totalbytes;
  985.     if (percent > bytepercent) {
  986. percent = bytepercent - 0.05;
  987.     }
  988. }
  989.     }
  990.     seektime = instance->mediaLength * percent;
  993.     if (DEBUG) {
  994. printf("widget size: %i x %in", req->width, req->height);
  995. printf("mouse click at %f x %fn", event->x, event->y);
  996. printf("percent = %fnseektime = %fn", percent, seektime);
  997.     }
  998.     if (seektime > 0)
  999. instance->Seek(seektime);
  1000.     NPN_MemFree(req);
  1002.     return TRUE;
  1003. }
  1006. gboolean mousenotify_callback(GtkWidget * widget, GdkEventCrossing * event,
  1007.       nsPluginInstance * instance)
  1008. {
  1009.     if (event->type == GDK_ENTER_NOTIFY) {
  1010. if (instance->mouseEnterCallback != NULL)
  1011.     NPN_GetURL(instance->mInstance,
  1012.        instance->mouseEnterCallback, "_self");
  1014.     }
  1016.     if (event->type == GDK_LEAVE_NOTIFY) {
  1017. if (instance->mouseLeaveCallback != NULL)
  1018.     NPN_GetURL(instance->mInstance,
  1019.        instance->mouseLeaveCallback, "_self");
  1021.     }
  1023.     return FALSE;
  1024. }
  1026. gboolean gtkgui_draw(void *data)
  1027. {
  1028.     nsPluginInstance *instance;
  1029.     GtkTooltips *tooltip;
  1031.     instance = (nsPluginInstance *) data;
  1033.     int width, height;
  1034.     int multiplier;
  1035.     int win_height, win_width;
  1037.     if (instance == NULL)
  1038. return FALSE;
  1039.     if (DEBUG > 1)
  1040. printf("panel_height = %inDrawn = %in", instance->panel_height,
  1041.        instance->panel_drawn);
  1043.     if (instance->mode == NP_EMBED && instance->window == 0)
  1044. return FALSE;
  1046.     if (instance->mode == NP_EMBED) {
  1047. win_height = instance->embed_height;
  1048. win_width = instance->embed_width;
  1049.     } else {
  1050. win_height = instance->window_height;
  1051. win_width = instance->window_width;
  1052.     }
  1054.     if (instance->targetplayer == 1) {
  1055. win_height = instance->movie_height + 16;
  1056. win_width = instance->movie_width;
  1057. if (instance->showcontrols && instance->movie_height)
  1058.     instance->panel_height = 16;
  1059.     }
  1061.     if (instance->panel_drawn == 0 && instance->window != 0) {
  1062. if (instance->mode == NP_FULL)
  1063.     instance->panel_height = instance->window_height;
  1064. if (instance->panel_height > 16)
  1065.     instance->panel_height = 16;
  1066. if (instance->panel_height <= 0)
  1067.     if (instance->showcontrols) {
  1068. instance->panel_height = 16;
  1069.     } else {
  1070. instance->panel_height = 0;
  1071.     }
  1072. if (DEBUG) {
  1073.     printf("drawing paneln height = %i panel= %in",
  1074.    win_height, instance->panel_height);
  1075.     printf("showbuttons = %inshowcontrols = %in",
  1076.    instance->showbuttons, instance->showcontrols);
  1077. }
  1078. if (instance->panel_height > 0 && instance->showcontrols == 1) {
  1079. #ifdef GTK2_ENABLED
  1080.     if (instance->autostart) {
  1081. instance->image_play =
  1082.     gtk_image_new_from_pixbuf(instance->pb_sm_play_down);
  1083. instance->image_stop =
  1084.     gtk_image_new_from_pixbuf(instance->pb_sm_stop_up);
  1085.     } else {
  1086. instance->image_play =
  1087.     gtk_image_new_from_pixbuf(instance->pb_sm_play_up);
  1088. instance->image_stop =
  1089.     gtk_image_new_from_pixbuf(instance->pb_sm_stop_down);
  1090.     }
  1091.     instance->image_pause =
  1092. gtk_image_new_from_pixbuf(instance->pb_sm_pause_up);
  1094.     instance->image_ff =
  1095. gtk_image_new_from_pixbuf(instance->pb_sm_ff_up);
  1096.     instance->image_rew =
  1097. gtk_image_new_from_pixbuf(instance->pb_sm_rew_up);
  1098.     instance->image_fs =
  1099. gtk_image_new_from_pixbuf(instance->pb_sm_fs_up);
  1100. #endif
  1101. #ifdef GTK1_ENABLED
  1102.     if (instance->autostart) {
  1103. instance->image_play =
  1104.     gtk_pixmap_new(instance->pb_sm_play_down, NULL);
  1105. instance->image_stop =
  1106.     gtk_pixmap_new(instance->pb_sm_stop_up, NULL);
  1108.     } else {
  1109. instance->image_play =
  1110.     gtk_pixmap_new(instance->pb_sm_play_up, NULL);
  1111. instance->image_stop =
  1112.     gtk_pixmap_new(instance->pb_sm_stop_down, NULL);
  1114.     }
  1115.     instance->image_pause =
  1116. gtk_pixmap_new(instance->pb_sm_pause_up, NULL);
  1117.     instance->image_ff =
  1118. gtk_pixmap_new(instance->pb_sm_ff_up, NULL);
  1119.     instance->image_rew =
  1120. gtk_pixmap_new(instance->pb_sm_rew_up, NULL);
  1121.     instance->image_fs =
  1122. gtk_pixmap_new(instance->pb_sm_fs_up, NULL);
  1123. #endif
  1124.     width = SMALL_BUTTON_WIDTH;
  1125.     height = SMALL_BUTTON_HEIGHT;
  1127. #ifdef GTK2_ENABLED
  1128.     g_signal_connect(G_OBJECT(instance->gtkwidget),
  1129.      "key_press_event",
  1130.      G_CALLBACK(keyboard_callback), instance);
  1131. #endif
  1132. #ifdef GTK1_ENABLED
  1133.     gtk_signal_connect(GTK_OBJECT(instance->gtkwidget),
  1134.        "key-press-event",
  1135.        GTK_SIGNAL_FUNC(keyboard_callback),
  1136.        instance);
  1137. #endif
  1138.     multiplier = 0;
  1139.     // rewind
  1140.     if ((instance->mmsstream == 0 && win_width > 126)
  1141. || instance->targetplayer == 1) {
  1142. instance->rew_event_box = gtk_event_box_new();
  1143. tooltip = gtk_tooltips_new();
  1144. gtk_tooltips_set_tip(tooltip, instance->rew_event_box,
  1145.      _("Rewind"), NULL);
  1146. gtk_widget_set_events(instance->rew_event_box,
  1147.       GDK_BUTTON_PRESS_MASK);
  1148. #ifdef GTK2_ENABLED
  1149. g_signal_connect(G_OBJECT(instance->rew_event_box),
  1150.  "button_press_event",
  1151.  G_CALLBACK(rew_callback), instance);
  1152. gtk_widget_set_size_request(GTK_WIDGET
  1153.     (instance->rew_event_box),
  1154.     width, height);
  1155. #endif
  1156. #ifdef GTK1_ENABLED
  1157. gtk_signal_connect(GTK_OBJECT(instance->rew_event_box),
  1158.    "button_press_event",
  1159.    GTK_SIGNAL_FUNC(rew_callback),
  1160.    instance);
  1161. gtk_widget_set_usize(GTK_WIDGET(instance->rew_event_box),
  1162.      width, height);
  1163. #endif
  1164. gtk_container_add(GTK_CONTAINER(instance->rew_event_box),
  1165.   instance->image_rew);
  1166. gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  1167.       instance->rew_event_box,
  1168.       width * multiplier++, win_height - height);
  1170. if (instance->showbuttons) {
  1171.     gtk_widget_show(instance->image_rew);
  1172.     gtk_widget_show(instance->rew_event_box);
  1173. }
  1174.     }
  1175.     // play
  1176.     instance->play_event_box = gtk_event_box_new();
  1177.     tooltip = gtk_tooltips_new();
  1178.     gtk_tooltips_set_tip(tooltip, instance->play_event_box,
  1179.  _("Play"), NULL);
  1180.     gtk_widget_set_events(instance->play_event_box,
  1181.   GDK_BUTTON_PRESS_MASK);
  1182. #ifdef GTK2_ENABLED
  1183.     g_signal_connect(G_OBJECT(instance->play_event_box),
  1184.      "button_press_event",
  1185.      G_CALLBACK(play_callback), instance);
  1186.     gtk_widget_set_size_request(GTK_WIDGET
  1187. (instance->play_event_box), width,
  1188. height);
  1189. #endif
  1190. #ifdef GTK1_ENABLED
  1191.     gtk_signal_connect(GTK_OBJECT(instance->play_event_box),
  1192.        "button_press_event",
  1193.        GTK_SIGNAL_FUNC(play_callback), instance);
  1194.     gtk_widget_set_usize(GTK_WIDGET(instance->play_event_box),
  1195.  width, height);
  1196. #endif
  1197.     gtk_container_add(GTK_CONTAINER(instance->play_event_box),
  1198.       instance->image_play);
  1199.     gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  1200.   instance->play_event_box, width * multiplier++,
  1201.   win_height - height);
  1202.     if (instance->showbuttons) {
  1203. gtk_widget_show(instance->image_play);
  1204. gtk_widget_show(instance->play_event_box);
  1205.     }
  1206.     // pause
  1207.     instance->pause_event_box = gtk_event_box_new();
  1208.     tooltip = gtk_tooltips_new();
  1209.     gtk_tooltips_set_tip(tooltip, instance->pause_event_box,
  1210.  _("Pause"), NULL);
  1211.     gtk_widget_set_events(instance->pause_event_box,
  1212.   GDK_BUTTON_PRESS_MASK);
  1213. #ifdef GTK2_ENABLED
  1214.     g_signal_connect(G_OBJECT(instance->pause_event_box),
  1215.      "button_press_event",
  1216.      G_CALLBACK(pause_callback), instance);
  1217.     gtk_widget_set_size_request(GTK_WIDGET
  1218. (instance->pause_event_box), width,
  1219. height);
  1220. #endif
  1221. #ifdef GTK1_ENABLED
  1222.     gtk_signal_connect(GTK_OBJECT(instance->pause_event_box),
  1223.        "button_press_event",
  1224.        GTK_SIGNAL_FUNC(pause_callback), instance);
  1225.     gtk_widget_set_usize(GTK_WIDGET(instance->pause_event_box),
  1226.  width, height);
  1227. #endif
  1228.     gtk_container_add(GTK_CONTAINER(instance->pause_event_box),
  1229.       instance->image_pause);
  1230.     if (win_width > 126 || instance->targetplayer == 1) {
  1232. gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  1233.       instance->pause_event_box,
  1234.       width * multiplier++, win_height - height);
  1235. if (instance->showbuttons) {
  1236.     gtk_widget_show(instance->image_pause);
  1237.     gtk_widget_show(instance->pause_event_box);
  1238. }
  1239.     }
  1240.     // stop
  1241.     instance->stop_event_box = gtk_event_box_new();
  1242.     tooltip = gtk_tooltips_new();
  1243.     gtk_tooltips_set_tip(tooltip, instance->stop_event_box,
  1244.  _("Stop"), NULL);
  1245.     gtk_widget_set_events(instance->stop_event_box,
  1246.   GDK_BUTTON_PRESS_MASK);
  1247. #ifdef GTK2_ENABLED
  1248.     g_signal_connect(G_OBJECT(instance->stop_event_box),
  1249.      "button_press_event",
  1250.      G_CALLBACK(stop_callback), instance);
  1251.     gtk_widget_set_size_request(GTK_WIDGET
  1252. (instance->stop_event_box), width,
  1253. height);
  1254. #endif
  1255. #ifdef GTK1_ENABLED
  1256.     gtk_signal_connect(GTK_OBJECT(instance->stop_event_box),
  1257.        "button_press_event",
  1258.        GTK_SIGNAL_FUNC(stop_callback), instance);
  1259.     gtk_widget_set_usize(GTK_WIDGET(instance->stop_event_box),
  1260.  width, height);
  1261. #endif
  1262.     gtk_container_add(GTK_CONTAINER(instance->stop_event_box),
  1263.       instance->image_stop);
  1264.     gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  1265.   instance->stop_event_box, width * multiplier++,
  1266.   win_height - height);
  1267.     if (instance->showbuttons) {
  1268. gtk_widget_show(instance->image_stop);
  1269. gtk_widget_show(instance->stop_event_box);
  1270.     }
  1271.     // fastforward
  1272.     if ((instance->mmsstream == 0 && win_width > 126)
  1273. || instance->targetplayer == 1) {
  1274. instance->ff_event_box = gtk_event_box_new();
  1275. tooltip = gtk_tooltips_new();
  1276. gtk_tooltips_set_tip(tooltip, instance->ff_event_box,
  1277.      _("Fast Forward"), NULL);
  1278. gtk_widget_set_events(instance->ff_event_box,
  1279.       GDK_BUTTON_PRESS_MASK);
  1280. #ifdef GTK2_ENABLED
  1281. g_signal_connect(G_OBJECT(instance->ff_event_box),
  1282.  "button_press_event",
  1283.  G_CALLBACK(ff_callback), instance);
  1284. gtk_widget_set_size_request(GTK_WIDGET
  1285.     (instance->ff_event_box),
  1286.     width, height);
  1287. #endif
  1288. #ifdef GTK1_ENABLED
  1289. gtk_signal_connect(GTK_OBJECT(instance->ff_event_box),
  1290.    "button_press_event",
  1291.    GTK_SIGNAL_FUNC(ff_callback), instance);
  1292. gtk_widget_set_usize(GTK_WIDGET(instance->ff_event_box),
  1293.      width, height);
  1294. #endif
  1295. gtk_container_add(GTK_CONTAINER(instance->ff_event_box),
  1296.   instance->image_ff);
  1297. gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  1298.       instance->ff_event_box, width * multiplier++,
  1299.       win_height - height);
  1300. if (instance->showbuttons) {
  1301.     gtk_widget_show(instance->image_ff);
  1302.     gtk_widget_show(instance->ff_event_box);
  1303. }
  1304.     }
  1305. //          if ((int) (width * multiplier + 10) <
  1306. //              (int) (win_width - 10 - width)) {
  1307.     instance->mediaprogress_bar =
  1308. GTK_PROGRESS_BAR(gtk_progress_bar_new());
  1309.     gtk_widget_set_events(GTK_WIDGET
  1310.   (instance->mediaprogress_bar),
  1311.   GDK_BUTTON_PRESS_MASK);
  1312. #ifdef GTK2_ENABLED
  1313.     g_signal_connect(G_OBJECT(instance->mediaprogress_bar),
  1314.      "button_press_event",
  1315.      G_CALLBACK(mediaprogress_callback), instance);
  1316.     gtk_widget_set_size_request(GTK_WIDGET
  1317. (instance->mediaprogress_bar),
  1318. (win_width -
  1319.  width * multiplier - 20 - width),
  1320. height - 2);
  1321. #endif
  1322. #ifdef GTK1_ENABLED
  1323.     gtk_signal_connect(GTK_OBJECT(instance->mediaprogress_bar),
  1324.        "button_press_event",
  1325.        GTK_SIGNAL_FUNC(mediaprogress_callback),
  1326.        instance);
  1327.     gtk_widget_set_usize(GTK_WIDGET
  1328.  (instance->mediaprogress_bar),
  1329.  (win_width -
  1330.   width * multiplier - 20 - width),
  1331.  height - 2);
  1332. #endif
  1333.     gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  1334.   GTK_WIDGET(instance->mediaprogress_bar),
  1335.   (width * multiplier + 10),
  1336.   win_height - height + 1);
  1337.     gtk_widget_realize(GTK_WIDGET(instance->mediaprogress_bar));
  1338. //          }
  1340.     if (instance->mode == NP_EMBED && instance->noembed == 0)
  1341. gtk_widget_hide(GTK_WIDGET(instance->progress_bar));
  1343.     // fullscreen
  1344.     instance->fs_event_box = gtk_event_box_new();
  1345.     tooltip = gtk_tooltips_new();
  1346.     gtk_tooltips_set_tip(tooltip, instance->fs_event_box,
  1347.  _("Full Screen"), NULL);
  1348.     gtk_widget_set_events(instance->fs_event_box,
  1349.   GDK_BUTTON_PRESS_MASK);
  1350. #ifdef GTK2_ENABLED
  1351.     g_signal_connect(G_OBJECT(instance->fs_event_box),
  1352.      "button_press_event",
  1353.      G_CALLBACK(fs_callback), instance);
  1354.     gtk_widget_set_size_request(GTK_WIDGET(instance->fs_event_box),
  1355. width, height);
  1356. #endif
  1357. #ifdef GTK1_ENABLED
  1358.     gtk_signal_connect(GTK_OBJECT(instance->fs_event_box),
  1359.        "button_press_event",
  1360.        GTK_SIGNAL_FUNC(fs_callback), instance);
  1361.     gtk_widget_set_usize(GTK_WIDGET(instance->fs_event_box), width,
  1362.  height);
  1363. #endif
  1364.     gtk_container_add(GTK_CONTAINER(instance->fs_event_box),
  1365.       instance->image_fs);
  1366.     if (win_width > 126 || instance->targetplayer == 1) {
  1367. gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  1368.       instance->fs_event_box,
  1369.       win_width - width, win_height - height);
  1370. if (instance->showfsbutton && instance->showbuttons) {
  1371.     gtk_widget_show(instance->image_fs);
  1372.     gtk_widget_show(instance->fs_event_box);
  1373. }
  1374.     }
  1375.     gtk_widget_show(instance->fixed_container);
  1376.     if (instance->targetplayer == 0)
  1377. gtk_widget_show(instance->gtkwidget);
  1379.     instance->controlsvisible = 1;
  1380.     instance->panel_drawn = 1;
  1381. }
  1382.     }
  1384.     return FALSE;
  1385. }
  1387. gboolean gtkgui_message(void *data)
  1388. {
  1389.     nsPluginInstance *instance;
  1391.     if (DEBUG > 1)
  1392. printf("in gtkgui_messagen");
  1394.     instance = (nsPluginInstance *) data;
  1395.     if (instance == NULL)
  1396. return FALSE;
  1397.     if (instance->mInitialized == FALSE)
  1398. return FALSE;
  1400.     if (instance->status != NULL && instance->lastmessage != NULL)
  1401. if (GTK_IS_LABEL(instance->status))
  1402.     gtk_label_set_text(instance->status, instance->lastmessage); //GTK_LABEL
  1404.     if (instance->js_state == JS_STATE_TRANSITIONING) {
  1405. if (GTK_IS_WIDGET(instance->image) && instance->showlogo)
  1406.     gtk_widget_show(GTK_WIDGET(instance->image));
  1408. if (GTK_IS_WIDGET(instance->status) && (!(instance->hidestatus)))
  1409.     gtk_widget_show(GTK_WIDGET(instance->status));
  1410.     }
  1412.     return FALSE;
  1413. }
  1415. gboolean gtkgui_progress(void *data)
  1416. {
  1417.     nsPluginInstance *instance;
  1419.     if (DEBUG > 1)
  1420. printf("in gtkgui_progressn");
  1422.     instance = (nsPluginInstance *) data;
  1423.     if (instance == NULL)
  1424. return FALSE;
  1425.     if (instance->progress_bar != NULL) {
  1426. if (GTK_IS_PROGRESS_BAR(instance->progress_bar)) {
  1427.     if ((instance->percent > 0.0) && (instance->percent < 1.0)) {
  1428. if (instance->movie_height == 0
  1429.     && instance->movie_width == 0)
  1430.     if (!(instance->hidestatus))
  1431. gtk_widget_show(GTK_WIDGET
  1432. (instance->progress_bar));
  1433. gtk_progress_bar_update(instance->progress_bar,
  1434. instance->percent);
  1435.     }
  1436.     if (instance->percent >= 0.99 || instance->percent == 0)
  1437. gtk_widget_hide(GTK_WIDGET(instance->progress_bar));
  1438. }
  1439.     }
  1441.     if (instance->js_state == JS_STATE_TRANSITIONING) {
  1442. if (GTK_IS_WIDGET(instance->image) && instance->showlogo)
  1443.     gtk_widget_show(GTK_WIDGET(instance->image));
  1445. if (GTK_IS_WIDGET(instance->status) && (!(instance->hidestatus)))
  1446.     gtk_widget_show(GTK_WIDGET(instance->status));
  1447.     }
  1449.     return FALSE;
  1450. }
  1452. gboolean gtkgui_resize(void *data)
  1453. {
  1454.     nsPluginInstance *instance;
  1455.     int new_width, new_height;
  1457.     instance = (nsPluginInstance *) data;
  1458.     if (instance == NULL)
  1459. return FALSE;
  1460.     if (instance->mInitialized == FALSE)
  1461. return FALSE;
  1463.     new_width = instance->movie_width;
  1464.     new_height = instance->movie_height;
  1466.     if (DEBUG > 1)
  1467. printf("in resize methodnNew size is %i x %in",
  1468.        instance->movie_width, instance->movie_height);
  1469.     if (instance->drawing_area != NULL) {
  1470. if (GTK_IS_WIDGET(instance->drawing_area)) {
  1471.     if (GTK_IS_WIDGET(instance->progress_bar))
  1472. gtk_widget_hide(GTK_WIDGET(instance->progress_bar));
  1473.     if (instance->mode == NP_FULL) {
  1474. if ((instance->movie_width + 10 >= instance->window_width)
  1475.     || (instance->movie_height + 100 >=
  1476. instance->window_height)) {
  1477.     if (instance->fullscreen == 0) {
  1478. if (GTK_IS_CONTAINER(instance->fixed_container)) {
  1479.     if (GTK_IS_WIDGET(instance->image))
  1480. gtk_widget_hide(GTK_WIDGET
  1481. (instance->image));
  1482.     if (GTK_IS_WIDGET(instance->status))
  1483. gtk_widget_hide(GTK_WIDGET
  1484. (instance->status));
  1485.     if (GTK_IS_WIDGET(instance->mediaprogress_bar))
  1486. gtk_widget_hide(GTK_WIDGET
  1487. (instance->
  1488.  mediaprogress_bar));
  1489.     instance->showtracker = 0;
  1490.     if (gtk_widget_get_parent_window(instance->drawing_area) == NULL) { 
  1491. gtk_fixed_put(GTK_FIXED
  1492.       (instance->fixed_container),
  1493.       instance->drawing_area, 0, 0);
  1494.     }
  1495. }
  1496.     }
  1497. }
  1499. if (instance->showcontrols) {
  1500.     if (instance->movie_width > instance->window_width
  1501. || instance->movie_height >
  1502. (instance->window_height - 17)) {
  1503. if (instance->movie_width > instance->window_width) {
  1504.     new_width = instance->window_width;
  1505.     new_height =
  1506. (instance->window_width *
  1507.  (instance->movie_height -
  1508.   17)) / instance->movie_width;
  1509. }
  1511. if (instance->movie_height >
  1512.     (instance->window_height - 17)) {
  1513.     new_height = (instance->window_height - 17);
  1514.     new_width =
  1515. ((instance->window_height -
  1516.   17) * instance->movie_width) /
  1517. instance->movie_height;
  1518. }
  1520.     } else {
  1521. new_width = instance->movie_width;
  1522. new_height = instance->movie_height;
  1524.     }
  1525. } else {
  1526.     if (instance->movie_width > instance->window_width
  1527. || instance->movie_height >
  1528. instance->window_height) {
  1529. if (instance->movie_width > instance->window_width) {
  1530.     new_width = instance->window_width;
  1531.     new_height =
  1532. (instance->window_width *
  1533.  instance->movie_height) /
  1534. instance->movie_width;
  1535. }
  1537. if (instance->movie_height >
  1538.     instance->window_height) {
  1539.     new_height = instance->window_height;
  1540.     new_width =
  1541. (instance->window_height *
  1542.  instance->movie_width) /
  1543. instance->movie_height;
  1544. }
  1546.     } else {
  1547. new_width = instance->movie_width;
  1548. new_height = instance->movie_height;
  1550.     }
  1551. }
  1552. gtk_widget_set_usize(instance->drawing_area,
  1553.      new_width, new_height);
  1555. if ((instance->movie_width + 10) >= instance->window_width
  1556.     || (instance->movie_height + 100) >=
  1557.     instance->window_height) {
  1558.     gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  1559.   instance->drawing_area, 0, 0);
  1560.     if (GTK_IS_WIDGET(instance->image))
  1561. gtk_widget_hide(GTK_WIDGET(instance->image));
  1562.     if (GTK_IS_WIDGET(instance->status))
  1563. gtk_widget_hide(GTK_WIDGET(instance->status));
  1564.     if (GTK_IS_WIDGET(instance->mediaprogress_bar))
  1565. gtk_widget_hide(GTK_WIDGET
  1566. (instance->mediaprogress_bar));
  1568. } else {
  1569.     if (gtk_widget_get_parent_window(instance->drawing_area) == NULL) { 
  1570. gtk_fixed_put(GTK_FIXED
  1571.       (instance->fixed_container),
  1572.       instance->drawing_area, 10, 100);
  1573.     }
  1574.     if (GTK_IS_WIDGET(instance->image))
  1575. gtk_widget_show(GTK_WIDGET(instance->image));
  1576.     if (GTK_IS_WIDGET(instance->status))
  1577. gtk_widget_show(GTK_WIDGET(instance->status));
  1578. }
  1580.     } else {
  1581. if (instance->targetplayer && instance->showcontrols) {
  1582.     gtk_widget_set_usize(instance->drawing_area,
  1583.  instance->movie_width,
  1584.  instance->movie_height + 16);
  1586. } else {
  1587.     if (instance->showcontrols) {
  1588. if (instance->movie_height >
  1589.     (instance->window_height - 16)) {
  1590.     gtk_widget_set_usize(GTK_WIDGET
  1591.  (instance->drawing_area),
  1592.  instance->movie_width,
  1593.  instance->window_height -
  1594.  16);
  1595. } else {
  1596.     gtk_widget_set_usize(GTK_WIDGET
  1597.  (instance->drawing_area),
  1598.  instance->movie_width,
  1599.  instance->movie_height);
  1600. }
  1601.     } else {
  1602. gtk_widget_set_usize(GTK_WIDGET
  1603.      (instance->drawing_area),
  1604.      instance->movie_width,
  1605.      instance->movie_height);
  1606.     }
  1608. }
  1610.     }
  1611. }
  1612.     }
  1615.     if (instance->targetplayer == 1) {
  1616. #ifdef GTK2_ENABLED
  1617. gtk_widget_set_size_request(instance->gtkwidget,
  1618.     instance->movie_width,
  1619.     instance->movie_height);
  1620. gtk_widget_set_size_request(instance->drawing_area,
  1621.     instance->movie_width,
  1622.     instance->movie_height);
  1623. gtk_window_resize(GTK_WINDOW(instance->gtkwidget),
  1624.   instance->movie_width,
  1625.   instance->movie_height + 16);
  1626. #endif
  1627. #ifdef GTK1_ENABLED
  1628. gtk_widget_set_usize(instance->gtkwidget,
  1629.      instance->movie_width,
  1630.      instance->movie_height + 16);
  1631. gtk_widget_set_usize(instance->drawing_area,
  1632.      instance->movie_width,
  1633.      instance->movie_height + 16);
  1634. #endif
  1635. instance->redrawbuttons = 1;
  1636. gtkgui_updatebuttons(data);
  1637.     }
  1639.     return FALSE;
  1641. }
  1643. gboolean gtkgui_stop(void *data)
  1644. {
  1645.     nsPluginInstance *instance;
  1647.     if (DEBUG > 1)
  1648. printf("in gtkgui_stopn");
  1650.     instance = (nsPluginInstance *) data;
  1651.     if (instance == NULL)
  1652. return FALSE;
  1653.     if (instance->mInitialized == FALSE)
  1654. return FALSE;
  1655.     if (instance->cancelled == 1)
  1656. return FALSE;
  1657.     stop_callback(NULL, NULL, instance);
  1658.     instance->SetFullscreen(0);
  1659.     if (DEBUG > 1)
  1660. printf("completed gtkgui_stopn");
  1661.     gtkgui_resize(data);
  1662.     gtk_widget_hide(instance->drawing_area);
  1663.     return FALSE;
  1664. }
  1666. gboolean gtkgui_save_enable(void *data)
  1667. {
  1668.     nsPluginInstance *instance;
  1669. #ifdef GTK2_ENABLED
  1670.     char *filename;
  1671.     char newlabel[1024];
  1672.     GtkLabel *label;
  1673. #endif
  1674.     if (DEBUG > 1)
  1675. printf("in gtkgui_save_enablen");
  1677.     instance = (nsPluginInstance *) data;
  1678.     if (instance == NULL)
  1679. return FALSE;
  1680.     if (instance->mInitialized == FALSE)
  1681. return FALSE;
  1682.     if (instance->currentnode == NULL)
  1683. return FALSE;
  1684.     if (instance->js_state != JS_STATE_PLAYING)
  1685. return FALSE;
  1687.     if (!isMms(instance->currentnode->url, instance->nomediacache)) {
  1688. pthread_mutex_lock(&(instance->playlist_mutex));
  1689. if (DEBUG > 1)
  1690.     printf("Save Enable called retrieved = %in",
  1691.    instance->currentnode->retrieved);
  1692. #ifdef GTK2_ENABLED
  1693. filename = getURLFilename(instance->currentnode->url);
  1694. if (filename != NULL) {
  1695.     snprintf(newlabel, 1024, _("Save as %s/%s"),
  1696.      instance->download_dir, filename);
  1697.     NPN_MemFree(filename);
  1699. } else {
  1700.     snprintf(newlabel, 1024, _("Save"));
  1701. }
  1703. if (GTK_IS_BIN(instance->menuitem_save)) {
  1704.     label =
  1705. GTK_LABEL(gtk_bin_get_child
  1706.   (GTK_BIN(instance->menuitem_save)));
  1707.     gtk_label_set_text(label, newlabel);
  1708. }
  1709. #endif
  1710. pthread_mutex_unlock(&(instance->playlist_mutex));
  1711. gtk_widget_set_sensitive(GTK_WIDGET(instance->menuitem_save),
  1712.  instance->currentnode->retrieved);
  1713.     } else {
  1714. #ifdef GTK2_ENABLED
  1715. snprintf(newlabel, 1024, _("Append URL to %s/playlist"),
  1716.  instance->download_dir);
  1717. label =
  1718.     GTK_LABEL(gtk_bin_get_child(GTK_BIN(instance->menuitem_save)));
  1719. gtk_label_set_text(label, newlabel);
  1720. #endif
  1721. gtk_widget_set_sensitive(GTK_WIDGET(instance->menuitem_save),
  1722.  TRUE);
  1723.     }
  1724.     return FALSE;
  1725. }
  1728. gboolean gtkgui_drawMediaProgress(void *data)
  1729. {
  1730.     nsPluginInstance *instance;
  1731.     int hour = 0, min = 0, length_hour = 0, length_min = 0;
  1732.     long int seconds, length_seconds;
  1733.     char display[35];
  1735.     if (DEBUG > 1)
  1736. printf("in drawMediaProgress methodn");
  1738.     instance = (nsPluginInstance *) data;
  1739.     if (instance == NULL)
  1740. return FALSE;
  1741.     if (instance->mInitialized == FALSE)
  1742. return FALSE;
  1745.     if (instance->mediaprogress_bar != NULL) {
  1746. if (GTK_IS_PROGRESS_BAR(instance->mediaprogress_bar)) {
  1747.     if (((int) instance->mediaLength > 0)
  1748. && (instance->mediaPercent <= 100)) {
  1749. if (instance->controlsvisible && instance->showtracker) {
  1750.     gtk_widget_show(GTK_WIDGET
  1751.     (instance->mediaprogress_bar));
  1752.     gtk_progress_bar_update(instance->mediaprogress_bar,
  1753.     instance->mediaPercent /
  1754.     100.0);
  1756. #ifdef GTK2_ENABLED
  1757.     if (((int) instance->mediaTime > 0)
  1758. && (instance->showtime == 1)) {
  1759. seconds = (int) instance->mediaTime;
  1760. if (seconds >= 3600) {
  1761.     hour = seconds / 3600;
  1762.     seconds = seconds - (hour * 3600);
  1763. }
  1764. if (seconds >= 60) {
  1765.     min = seconds / 60;
  1766.     seconds = seconds - (min * 60);
  1767. }
  1768. length_seconds = (int) instance->mediaLength;
  1769. if (length_seconds >= 3600) {
  1770.     length_hour = length_seconds / 3600;
  1771.     length_seconds =
  1772. length_seconds - (length_hour * 3600);
  1773. }
  1774. if (length_seconds >= 60) {
  1775.     length_min = length_seconds / 60;
  1776.     length_seconds =
  1777. length_seconds - (length_min * 60);
  1778. }
  1780. if ((int) (instance->percent * 100) > 0
  1781.     && (int) (instance->percent * 100) < 99
  1782.     && instance->mmsstream == 0) {
  1784.     if (hour == 0 && length_hour == 0) {
  1785. snprintf(display, 30,
  1786.  _
  1787.  ("%2i:%02i / %2i:%02i | %2i%% 342226274"),
  1788.  min, (int) seconds, length_min,
  1789.  (int) length_seconds,
  1790.  (int) (instance->percent * 100));
  1791.     } else {
  1792. snprintf(display, 30,
  1793.  _
  1794.  ("%i:%02i:%02i / %i:%02i:%02i | %2i%% 342226274"),
  1795.  hour, min, (int) seconds,
  1796.  length_hour, length_min,
  1797.  (int) length_seconds,
  1798.  (int) (instance->percent * 100));
  1799.     }
  1801. } else {
  1803.     if (hour == 0 && length_hour == 0) {
  1804. snprintf(display, 30,
  1805.  "%2i:%02i / %2i:%02i", min,
  1806.  (int) seconds, length_min,
  1807.  (int) length_seconds);
  1808.     } else {
  1809. snprintf(display, 30,
  1810.  "%i:%02i:%02i / %i:%02i:%02i",
  1811.  hour, min, (int) seconds,
  1812.  length_hour, length_min,
  1813.  (int) length_seconds);
  1814.     }
  1816. }
  1818. gtk_progress_bar_set_text(instance->
  1819.   mediaprogress_bar,
  1820.   display);
  1821.     } else {
  1822. if ((int) (instance->percent * 100) > 0
  1823.     && (int) (instance->percent * 100) < 99
  1824.     && instance->mmsstream == 0) {
  1826.     snprintf(display, 30, _("%2i%% 342226274"),
  1827.      (int) (instance->percent * 100));
  1828.     if (gtk_progress_bar_get_text
  1829. (instance->mediaprogress_bar) != NULL)
  1830. gtk_progress_bar_set_text(instance->
  1831.   mediaprogress_bar,
  1832.   display);
  1834. } else {
  1836.     if (gtk_progress_bar_get_text
  1837. (instance->mediaprogress_bar) != NULL)
  1838. gtk_progress_bar_set_text(instance->
  1839.   mediaprogress_bar,
  1840.   NULL);
  1841. }
  1842.     }
  1843. #endif
  1845. } else {
  1846.     gtk_widget_hide(GTK_WIDGET
  1847.     (instance->mediaprogress_bar));
  1848. }
  1849.     } else {
  1850. gtk_widget_hide(GTK_WIDGET(instance->mediaprogress_bar));
  1851.     }
  1852. }
  1853.     }
  1855.     if (instance->movie_width != 0 && instance->movie_height != 0) {
  1856. if (GTK_IS_WIDGET(instance->progress_bar))
  1857.     gtk_widget_hide(GTK_WIDGET(instance->progress_bar));
  1858.     }
  1860.     return FALSE;
  1861. }
  1863. gboolean gtkgui_refreshbuttonstate(void *data)
  1864. {
  1865.     nsPluginInstance *instance;
  1867.     if (DEBUG > 1)
  1868. printf("in refreshbuttonstate methodn");
  1869.     instance = (nsPluginInstance *) data;
  1870.     if (instance == NULL)
  1871. return FALSE;
  1872.     if (instance->mInitialized == FALSE)
  1873. return FALSE;
  1874.     if (instance->panel_drawn == 1 && instance->controlsvisible) {
  1876. if (instance->mmsstream == 0) {
  1877.     if (instance->rew_event_box != NULL) {
  1878. if (instance->showcontrols && instance->showbuttons
  1879.     && instance->controlsvisible) {
  1880.     if (instance->redrawbuttons)
  1881. gtk_widget_hide(GTK_WIDGET
  1882. (instance->rew_event_box));
  1883.     gtk_widget_show(GTK_WIDGET(instance->rew_event_box));
  1884. }
  1885.     }
  1886. } else {
  1887.     if (GTK_IS_WIDGET(instance->rew_event_box))
  1888. gtk_widget_hide(GTK_WIDGET(instance->rew_event_box));
  1889. }
  1890. if (instance->mmsstream == 0) {
  1891.     if (instance->ff_event_box != NULL) {
  1892. if (instance->showcontrols && instance->showbuttons
  1893.     && instance->controlsvisible) {
  1894.     if (instance->redrawbuttons)
  1895. gtk_widget_hide(GTK_WIDGET
  1896. (instance->ff_event_box));
  1897.     gtk_widget_show(GTK_WIDGET(instance->ff_event_box));
  1898. }
  1899.     }
  1900. } else {
  1901.     if (GTK_IS_WIDGET(instance->ff_event_box))
  1902. gtk_widget_hide(GTK_WIDGET(instance->ff_event_box));
  1903. }
  1904. if (instance->showcontrols && instance->showbuttons
  1905.     && instance->controlsvisible) {
  1906.     if (instance->redrawbuttons) {
  1907. gtk_widget_hide(GTK_WIDGET(instance->play_event_box));
  1908. gtk_widget_hide(GTK_WIDGET(instance->pause_event_box));
  1909. gtk_widget_hide(GTK_WIDGET(instance->stop_event_box));
  1910. gtk_widget_hide(GTK_WIDGET(instance->fs_event_box));
  1911.     }
  1912.     gtk_widget_show(GTK_WIDGET(instance->play_event_box));
  1913.     gtk_widget_show(GTK_WIDGET(instance->pause_event_box));
  1914.     gtk_widget_show(GTK_WIDGET(instance->stop_event_box));
  1915.     gtk_widget_show(GTK_WIDGET(instance->fs_event_box));
  1916. }
  1917.     }
  1919.     instance->redrawbuttons = 0;
  1920. //    gtk_widget_queue_draw_area(instance->gtkwidget,0,0,instance->embed_width,instance->embed_height);
  1922.     return FALSE;
  1923. }
  1925. gboolean gtkgui_updatebuttons(void *data)
  1926. {
  1927.     nsPluginInstance *instance;
  1928.     int height, width, multiplier;
  1929.     int win_height, win_width;
  1931.     if (DEBUG > 1)
  1932. printf("in updatebuttons methodn");
  1934.     instance = (nsPluginInstance *) data;
  1936.     if (instance == NULL)
  1937. return FALSE;
  1938.     if (instance->mInitialized == FALSE)
  1939. return FALSE;
  1941.     if (instance->mode == NP_EMBED) {
  1942. win_height = instance->embed_height;
  1943. win_width = instance->embed_width;
  1944.     } else {
  1945. win_height = instance->window_height;
  1946. win_width = instance->window_width;
  1947.     }
  1949.     if (instance->targetplayer) {
  1950. win_height = instance->movie_height + 16;
  1951. win_width = instance->movie_width;
  1952.     }
  1954.     if (DEBUG)
  1955. printf("buttons are at %i x %in", win_height, win_width);
  1957.     if (instance->panel_drawn == 1) {
  1958. height = 16;
  1959. width = 21;
  1961. multiplier = 0;
  1963. if (instance->mmsstream == 0) {
  1964.     if (instance->rew_event_box != NULL) {
  1965. if (instance->showcontrols && instance->showbuttons) {
  1966.     gtk_widget_show(GTK_WIDGET(instance->rew_event_box));
  1967.     gtk_fixed_move(GTK_FIXED
  1968.    (instance->fixed_container),
  1969.    GTK_WIDGET(instance->rew_event_box),
  1970.    width * multiplier++,
  1971.    win_height - height);
  1972. }
  1973.     }
  1974. } else {
  1975.     if (GTK_IS_WIDGET(instance->rew_event_box)) {
  1976.      gtk_widget_hide(GTK_WIDGET(instance->rew_event_box));
  1977.     }
  1978. }
  1979. gtk_fixed_move(GTK_FIXED(instance->fixed_container),
  1980.        GTK_WIDGET(instance->play_event_box),
  1981.        width * multiplier++, win_height - height);
  1982. gtk_fixed_move(GTK_FIXED(instance->fixed_container),
  1983.        GTK_WIDGET(instance->pause_event_box),
  1984.        width * multiplier++, win_height - height);
  1985. gtk_fixed_move(GTK_FIXED(instance->fixed_container),
  1986.        GTK_WIDGET(instance->stop_event_box),
  1987.        width * multiplier++, win_height - height);
  1988. if (instance->mmsstream == 0) {
  1989.     if (instance->ff_event_box != NULL) {
  1990. if (instance->showcontrols && instance->showbuttons) {
  1991.     gtk_widget_show(GTK_WIDGET(instance->rew_event_box));
  1992.     gtk_fixed_move(GTK_FIXED
  1993.    (instance->fixed_container),
  1994.    GTK_WIDGET(instance->ff_event_box),
  1995.    width * multiplier++,
  1996.    win_height - height);
  1997. }
  1998.     }
  1999. } else {
  2000.     if (GTK_IS_WIDGET(instance->ff_event_box)) {
  2001.      gtk_widget_hide(GTK_WIDGET(instance->ff_event_box));
  2002.     }
  2003. }
  2004. gtk_fixed_move(GTK_FIXED(instance->fixed_container),
  2005.        GTK_WIDGET(instance->mediaprogress_bar),
  2006.        (width * multiplier + 10), win_height - height + 2);
  2007. gtk_fixed_move(GTK_FIXED(instance->fixed_container),
  2008.        GTK_WIDGET(instance->fs_event_box),
  2009.        (win_width - width), win_height - height + 2);
  2011. gtk_widget_show(GTK_WIDGET(instance->mediaprogress_bar));
  2012. gtk_widget_set_usize(GTK_WIDGET(instance->mediaprogress_bar),
  2013.      win_width - (width * (multiplier + 1) +
  2014.   20), height - 4);
  2016.     }
  2017.     return FALSE;
  2018. }
  2020. gboolean gtkgui_updatefullscreen(void *data)
  2021. {
  2022.     nsPluginInstance *instance;
  2024.     if (DEBUG > 1)
  2025. printf("in updatefullscreen methodn");
  2027.     instance = (nsPluginInstance *) data;
  2029.     if (instance == NULL)
  2030. return FALSE;
  2031.     if (instance->mInitialized == FALSE)
  2032. return FALSE;
  2034.     instance->SetFullscreen(instance->fullscreen);
  2036.     return FALSE;
  2037. }
  2040. gint popup_handler(GtkWidget * widget, GdkEvent * event)
  2041. {
  2042.     GtkMenu *menu;
  2043.     GdkEventButton *event_button;
  2045.     if (DEBUG)
  2046. printf("popup menu callbackn");
  2048.     menu = GTK_MENU(widget);
  2049.     if (DEBUG)
  2050. printf("event type # %in", event->type);
  2051.     if (event->type == GDK_BUTTON_PRESS) {
  2052. event_button = (GdkEventButton *) event;
  2053. if (DEBUG)
  2054.     printf("button press # %in", event_button->button);
  2055. if (event_button->button == 3) {
  2056.     gtk_menu_popup(menu, NULL, NULL, NULL, NULL,
  2057.    event_button->button, event_button->time);
  2058.     return TRUE;
  2059. }
  2060.     }
  2061.     return FALSE;
  2062. }
  2064. void menuitem_play_callback(GtkMenuItem * menuitem,
  2065.     nsPluginInstance * instance)
  2066. {
  2067.     play_callback(GTK_WIDGET(menuitem), NULL, instance);
  2068. }
  2070. void menuitem_pause_callback(GtkMenuItem * menuitem,
  2071.      nsPluginInstance * instance)
  2072. {
  2073.     pause_callback(GTK_WIDGET(menuitem), NULL, instance);
  2074. }
  2076. void menuitem_stop_callback(GtkMenuItem * menuitem,
  2077.     nsPluginInstance * instance)
  2078. {
  2079.     stop_callback(GTK_WIDGET(menuitem), NULL, instance);
  2080. }
  2082. void menuitem_showcontrols_callback(GtkCheckMenuItem * menuitem,
  2083.     nsPluginInstance * instance)
  2084. {
  2085. #ifdef GTK2_ENABLED
  2086.     instance->SetShowControls(gtk_check_menu_item_get_active(menuitem));
  2087. #endif
  2088. #ifdef GTK1_ENABLED
  2089.     instance->SetShowControls(menuitem->active);
  2090. #endif
  2091. }
  2093. void menuitem_fullscreen_callback(GtkCheckMenuItem * menuitem,
  2094.   nsPluginInstance * instance)
  2095. {
  2096. #ifdef GTK2_ENABLED
  2097.     instance->SetFullscreen(gtk_check_menu_item_get_active(menuitem));
  2098. #endif
  2099. #ifdef GTK1_ENABLED
  2100.     instance->SetFullscreen(menuitem->active);
  2101. #endif
  2103. }
  2105. void store_filename(GtkWidget * widget, nsPluginInstance * instance)
  2106. {
  2107.     const gchar *filename;
  2108.     FILE *fin, *fout;
  2109.     char buffer[1000];
  2110.     int count;
  2111.     Node *n, *lastplayed;
  2113.     if (instance->mInitialized == FALSE)
  2114. return;
  2115.     pthread_mutex_lock(&(instance->playlist_mutex));
  2117.     lastplayed = NULL;
  2119.     if (instance->currentnode != NULL) {
  2120. lastplayed = instance->currentnode;
  2121.     } else {
  2122. n = instance->list;
  2123. while (n != NULL) {
  2124.     if (n->played == 1)
  2125. lastplayed = n;
  2126.     n = n->next;
  2127. }
  2128.     }
  2130.     if (DEBUG)
  2131. printf("lastplayed = %pn", lastplayed);
  2133.     if (lastplayed != NULL) {
  2134. filename =
  2135.     gtk_file_selection_get_filename(GTK_FILE_SELECTION
  2136.     (instance->file_selector));
  2137. if (DEBUG)
  2138.     printf("filename = %sn", filename);
  2140. if (filename) {
  2141.     if (lastplayed->retrieved == 1) {
  2142. if (DEBUG) {
  2143.     printf("lastplayed->fname = %sn", lastplayed->fname);
  2144. }
  2146. if (rename(lastplayed->fname, filename) == 0) {
  2147.     snprintf(lastplayed->fname, 1024, "%s", filename);
  2148.     lastplayed->remove = 0;
  2149. } else {
  2151.     // rename failed (probably cross partitions), copy the file
  2152.     fin = fopen(lastplayed->fname, "rb");
  2153.     fout = fopen(filename, "wb");
  2154.     if (fin != NULL && fout != NULL) {
  2155. while (!feof(fin)) {
  2156.     count = fread(buffer, 1, 1000, fin);
  2157.     fwrite(buffer, 1, count, fout);
  2158. }
  2159. fclose(fout);
  2160. fclose(fin);
  2161.     }
  2162. }
  2163.     }
  2164. }
  2165.     }
  2166.     pthread_mutex_unlock(&(instance->playlist_mutex));
  2167.     gtk_widget_destroy(instance->file_selector);
  2168.     instance->file_selector = NULL;
  2169. }
  2173. void menuitem_save_callback(GtkMenuItem * menuitem,
  2174.     nsPluginInstance * instance)
  2175. {
  2176.     const gchar *filename;
  2177.     char mmsplaylist[1024];
  2178.     FILE *playlist;
  2179.     Node *n, *lastplayed;
  2181.     if (instance->mInitialized == FALSE)
  2182. return;
  2183.     pthread_mutex_lock(&(instance->playlist_mutex));
  2185.     lastplayed = NULL;
  2187.     if (instance->currentnode != NULL) {
  2188. lastplayed = instance->currentnode;
  2189.     } else {
  2190. n = instance->list;
  2191. while (n != NULL) {
  2192.     if (n->played == 1)
  2193. lastplayed = n;
  2194.     n = n->next;
  2195. }
  2196.     }
  2198.     if (lastplayed != NULL) {
  2199. filename = getURLFilename(lastplayed->url);
  2200. if (filename) {
  2201.     instance->file_selector =
  2202. gtk_file_selection_new
  2203. (_("Save As..."));
  2205.     gtk_file_selection_set_filename(GTK_FILE_SELECTION
  2206.     (instance->file_selector),
  2207.     filename);
  2208. #ifdef GTK2_ENABLED
  2209.     g_signal_connect(GTK_FILE_SELECTION(instance->file_selector)->
  2210.      ok_button, "clicked",
  2211.      G_CALLBACK(store_filename), instance);
  2213.     g_signal_connect_swapped(GTK_FILE_SELECTION
  2214.      (instance->file_selector)->ok_button,
  2215.      "clicked",
  2216.      G_CALLBACK(gtk_widget_destroy),
  2217.      instance->file_selector);
  2219.     g_signal_connect_swapped(GTK_FILE_SELECTION
  2220.      (instance->file_selector)->
  2221.      cancel_button, "clicked",
  2222.      G_CALLBACK(gtk_widget_destroy),
  2223.      instance->file_selector);
  2224. #endif
  2225. #ifdef GTK1_ENABLED
  2226.     gtk_signal_connect(GTK_OBJECT
  2227.        (GTK_FILE_SELECTION
  2228. (instance->file_selector)->ok_button),
  2229.        "clicked", GTK_SIGNAL_FUNC(store_filename),
  2230.        instance);
  2232.     gtk_signal_connect_object(GTK_OBJECT
  2233.       (GTK_FILE_SELECTION
  2234.        (instance->file_selector)->
  2235.        ok_button), "clicked",
  2236.       GTK_SIGNAL_FUNC(gtk_widget_destroy),
  2237.       GTK_OBJECT(instance->file_selector));
  2239.     gtk_signal_connect_object(GTK_OBJECT
  2240.       (GTK_FILE_SELECTION
  2241.        (instance->file_selector)->
  2242.        cancel_button), "clicked",
  2243.       GTK_SIGNAL_FUNC(gtk_widget_destroy),
  2244.       GTK_OBJECT(instance->file_selector));
  2247. #endif
  2248.     /* Display that dialog */
  2250.     gtk_widget_show(instance->file_selector);
  2252. }
  2253. if (lastplayed->mmsstream) {
  2254.     snprintf(mmsplaylist, sizeof(mmsplaylist),
  2255.      "%s/playlist", instance->download_dir);
  2256.     playlist = fopen(mmsplaylist, "a");
  2257.     if (playlist != NULL) {
  2258. fprintf(playlist, "%sn", instance->list->url);
  2259. fclose(playlist);
  2260.     }
  2261. }
  2262.     }
  2263.     pthread_mutex_unlock(&(instance->playlist_mutex));
  2264. }
  2266. void menuitem_copy_callback(GtkMenuItem * menuitem,
  2267.     nsPluginInstance * instance)
  2268. {
  2269.     Node *n, *lastplayed;
  2270.     char *localurl;
  2271. #ifdef GTK2_ENABLED
  2272.     GtkClipboard *clipboard;
  2273. #endif
  2274. #ifdef GTK1_ENABLED
  2275.     GtkWidget *ge;
  2276. #endif
  2277.     localurl = (char *) malloc(1024);
  2279.     lastplayed = NULL;
  2281.     if (instance->currentnode != NULL) {
  2282. lastplayed = instance->currentnode;
  2283.     } else {
  2284. n = instance->list;
  2285. while (n != NULL) {
  2286.     if (n->played == 1)
  2287. lastplayed = n;
  2288.     n = n->next;
  2289. }
  2290.     }
  2292.     if (lastplayed != NULL) {
  2293. fullyQualifyURL(instance, lastplayed->url, localurl);
  2294. #ifdef GTK2_ENABLED
  2295. clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
  2296. gtk_clipboard_set_text(clipboard, localurl, -1);
  2297. clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
  2298. gtk_clipboard_set_text(clipboard, localurl, -1);
  2299. #endif
  2300. #ifdef GTK1_ENABLED
  2301. ge = gtk_entry_new_with_max_length(strlen(localurl));
  2302. gtk_entry_set_text((GtkEntry *) ge, localurl);
  2303. gtk_editable_select_region((GtkEditable *) ge, 0,
  2304.    strlen(localurl));
  2305. gtk_editable_copy_clipboard((GtkEditable *) ge);
  2306. #endif
  2307.     }
  2308. }
  2310. gint CloseConfig(GtkWidget * widget, nsPluginInstance * instance)
  2311. {
  2313.     if (GTK_IS_WIDGET(instance->conf_window))
  2314. gtk_widget_destroy(instance->conf_window);
  2315.     instance->conf_window = NULL;
  2317.     return (FALSE);
  2319. }
  2321. gint CloseConfigEvent(GtkWidget * widget, GdkEvent * event,
  2322.       nsPluginInstance * instance)
  2323. {
  2325.     if (GTK_IS_WIDGET(instance->conf_window))
  2326. gtk_widget_destroy(instance->conf_window);
  2327.     instance->conf_window = NULL;
  2328.     return (FALSE);
  2330. }
  2332. #ifdef GTK2_ENABLED
  2333. gint ApplyConfig(GtkWidget * widget, nsPluginInstance * instance)
  2334. {
  2335.     FILE *input;
  2336.     FILE *output;
  2337.     char config_name[1000];
  2338.     char tmp_name[1000];
  2339.     char buffer[1000];
  2340.     int ret;
  2342.     instance->cachesize =
  2343. (int) gtk_range_get_value(GTK_RANGE(instance->conf_cachesize));
  2344.     instance->cache_percent = (int)
  2345. gtk_range_get_value(GTK_RANGE(instance->conf_cachepercent));
  2347. #ifdef GTK24_ENABLED
  2348.     if (instance->vo != NULL)
  2349. free(instance->vo);
  2350.     instance->vo =
  2351. strdup(gtk_entry_get_text
  2352.        (GTK_ENTRY(GTK_BIN(instance->conf_vo)->child)));
  2354.     if (instance->ao != NULL)
  2355. free(instance->ao);
  2356.     instance->ao =
  2357. strdup(gtk_entry_get_text
  2358.        (GTK_ENTRY(GTK_BIN(instance->conf_ao)->child)));
  2360.     if (instance->download_dir != NULL)
  2361. free(instance->download_dir);
  2362.     instance->download_dir =
  2363. strdup(gtk_entry_get_text
  2364.        (GTK_ENTRY(GTK_BIN(instance->conf_dir)->child)));
  2365. #endif
  2367.     instance->showtime =
  2368. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2369.      (instance->conf_showtime));
  2370.     instance->enable_wmp =
  2371. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2372.      (instance->conf_enable_wmp));
  2373.     instance->enable_qt =
  2374. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2375.      (instance->conf_enable_qt));
  2376.     instance->enable_rm =
  2377. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2378.      (instance->conf_enable_rm));
  2379.     instance->enable_gmp =
  2380. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2381.      (instance->conf_enable_gmp));
  2382.     instance->enable_dvx =
  2383. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2384.      (instance->conf_enable_dvx));
  2385.     instance->enable_mpeg =
  2386. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2387.      (instance->conf_enable_mpeg));
  2388.     instance->enable_mp3 =
  2389. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2390.      (instance->conf_enable_mp3));
  2391.     instance->enable_ogg =
  2392. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2393.      (instance->conf_enable_ogg));
  2394.     instance->enable_midi =
  2395. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2396.      (instance->conf_enable_midi));
  2397.     instance->enable_pls =
  2398. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2399.      (instance->conf_enable_pls));
  2400.     instance->enable_smil =
  2401. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2402.      (instance->conf_enable_smil));
  2403.     instance->enable_helix =
  2404. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2405.      (instance->conf_enable_helix));
  2407.     instance->nomediacache =
  2408. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2409.      (instance->conf_nomediacache));
  2411.     instance->rtsp_use_tcp =
  2412. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2413.      (instance->conf_rtsptcp));
  2415.     instance->rtsp_use_http =
  2416. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2417.      (instance->conf_rtsphttp));
  2419.     instance->nopauseonhide =
  2420. !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
  2421.       (instance->conf_pauseonhide));
  2423.     gtk_widget_destroy(instance->conf_window);
  2424.     instance->conf_window = NULL;
  2426.     // write the setting to the conf file now
  2428.     snprintf(config_name, 1000, "%s", getenv("HOME"));
  2429.     strlcat(config_name, "/.download/downloadplug-in.conf", 1000);
  2431.     snprintf(tmp_name, 1000, "%s", getenv("HOME"));
  2432.     strlcat(tmp_name, "/.download/downloadplug-in.conf.tmp", 1000);
  2434.     if (DEBUG) {
  2435. printf("config %sn", config_name);
  2436. printf("tmp %sn", tmp_name);
  2438.     }
  2440.     input = fopen(config_name, "r");
  2441.     output = fopen(tmp_name, "w");
  2443.     if (input != NULL && output != NULL) {
  2444. if (DEBUG)
  2445.     printf("update existing confign");
  2446. if (strlen(instance->vo) > 0)
  2447.     fprintf(output, "vo=%sn", instance->vo);
  2448. if (strlen(instance->ao) > 0)
  2449.     fprintf(output, "ao=%sn", instance->ao);
  2450. fprintf(output, "cachesize=%in", instance->cachesize);
  2451. fprintf(output, "cache-percent=%in", instance->cache_percent);
  2452. if (strlen(instance->download_dir) > 0)
  2453.     fprintf(output, "dload-dir=%sn", instance->download_dir);
  2454. fprintf(output, "showtime=%in", instance->showtime);
  2455. fprintf(output, "enable-wmp=%in", instance->enable_wmp);
  2456. fprintf(output, "enable-qt=%in", instance->enable_qt);
  2457. fprintf(output, "enable-rm=%in", instance->enable_rm);
  2458. fprintf(output, "enable-gmp=%in", instance->enable_gmp);
  2459. fprintf(output, "enable-dvx=%in", instance->enable_dvx);
  2460. fprintf(output, "enable-mpeg=%in", instance->enable_mpeg);
  2461. fprintf(output, "enable-mp3=%in", instance->enable_mp3);
  2462. fprintf(output, "enable-ogg=%in", instance->enable_ogg);
  2463. fprintf(output, "enable-midi=%in", instance->enable_midi);
  2464. fprintf(output, "enable-pls=%in", instance->enable_pls);
  2465. fprintf(output, "enable-smil=%in", instance->enable_smil);
  2466. fprintf(output, "enable-helix=%in", instance->enable_helix);
  2467. fprintf(output, "nomediacache=%in", instance->nomediacache);
  2468. fprintf(output, "nopauseonhide=%in", instance->nopauseonhide);
  2469. fprintf(output, "rtsp-use-tcp=%in", instance->rtsp_use_tcp);
  2470. fprintf(output, "rtsp-use-http=%in", instance->rtsp_use_http);
  2473. while (fgets(buffer, sizeof(buffer), input) != NULL) {
  2474.     if (strncasecmp(buffer, "vo", 2) == 0) {
  2475.     } else if (strncasecmp(buffer, "ao", 2) == 0) {
  2476.     } else if (strncasecmp(buffer, "cachesize", 9) == 0) {
  2477.     } else if (strncasecmp(buffer, "cache-percent", 13) == 0) {
  2478.     } else if (strncasecmp(buffer, "dload-dir", 9) == 0) {
  2479.     } else if (strncasecmp(buffer, "showtime", 8) == 0) {
  2480.     } else if (strncasecmp(buffer, "enable-wmp", 10) == 0) {
  2481.     } else if (strncasecmp(buffer, "enable-qt", 9) == 0) {
  2482.     } else if (strncasecmp(buffer, "enable-rm", 9) == 0) {
  2483.     } else if (strncasecmp(buffer, "enable-mpeg", 11) == 0) {
  2484.     } else if (strncasecmp(buffer, "enable-mp3", 10) == 0) {
  2485.     } else if (strncasecmp(buffer, "enable-midi", 11) == 0) {
  2486.     } else if (strncasecmp(buffer, "enable-pls", 10) == 0) {
  2487.     } else if (strncasecmp(buffer, "enable-ogg", 10) == 0) {
  2488.     } else if (strncasecmp(buffer, "enable-gmp", 10) == 0) {
  2489.     } else if (strncasecmp(buffer, "enable-dvx", 10) == 0) {
  2490.     } else if (strncasecmp(buffer, "enable-smil", 11) == 0) {
  2491.     } else if (strncasecmp(buffer, "enable-helix", 12) == 0) {
  2492.     } else if (strncasecmp(buffer, "nomediacache", 12) == 0) {
  2493.     } else if (strncasecmp(buffer, "nopauseonhide", 13) == 0) {
  2494.     } else if (strncasecmp(buffer, "rtsp-use-tcp", 12) == 0) {
  2495.     } else if (strncasecmp(buffer, "rtsp-use-http", 13) == 0) {
  2496.     } else {
  2497. fprintf(output, "%s", buffer);
  2498.     }
  2500. }
  2501. fclose(input);
  2502. fclose(output);
  2503. ret = unlink(config_name);
  2504. if (ret == 0) {
  2505.     ret = rename(tmp_name, config_name);
  2506.     if (ret == -1) {
  2507. ret = errno;
  2508. if (DEBUG) {
  2509.     printf("Unable to rename the file %s to %sn",
  2510.    tmp_name, config_name);
  2511.     printf("Error code: %i - %sn", ret, strerror(ret));
  2512. }
  2513.     }
  2514. } else {
  2515.     ret = errno;
  2516.     if (DEBUG) {
  2517. printf("Unable to delete the file %sn", config_name);
  2518. printf("Error code: %i - %sn", ret, strerror(ret));
  2519.     }
  2520. }
  2521.     } else {
  2522. if (DEBUG)
  2523.     printf("write new config filen");
  2524. if (output != NULL) {
  2525.     if (strlen(instance->vo) > 0)
  2526. fprintf(output, "vo=%sn", instance->vo);
  2527.     if (strlen(instance->ao) > 0)
  2528. fprintf(output, "ao=%sn", instance->ao);
  2529.     fprintf(output, "cachesize=%in", instance->cachesize);
  2530.     fprintf(output, "cache-percent=%in", instance->cache_percent);
  2531.     if (strlen(instance->download_dir) > 0)
  2532. fprintf(output, "dload-dir=%sn", instance->download_dir);
  2533.     fprintf(output, "showtime=%in", instance->showtime);
  2534.     fprintf(output, "enable-wmp=%in", instance->enable_wmp);
  2535.     fprintf(output, "enable-qt=%in", instance->enable_qt);
  2536.     fprintf(output, "enable-rm=%in", instance->enable_rm);
  2537.     fprintf(output, "enable-gmp=%in", instance->enable_gmp);
  2538.     fprintf(output, "enable-dvx=%in", instance->enable_dvx);
  2539.     fprintf(output, "enable-mpeg=%in", instance->enable_mpeg);
  2540.     fprintf(output, "enable-mp3=%in", instance->enable_mp3);
  2541.     fprintf(output, "enable-midi=%in", instance->enable_midi);
  2542.     fprintf(output, "enable-pls=%in", instance->enable_pls);
  2543.     fprintf(output, "enable-ogg=%in", instance->enable_ogg);
  2544.     fprintf(output, "enable-smil=%in", instance->enable_smil);
  2545.     fprintf(output, "enable-helix=%in", instance->enable_helix);
  2546.     fprintf(output, "nomediacache=%in", instance->nomediacache);
  2547.     fprintf(output, "nopauseonhide=%in", instance->nopauseonhide);
  2548.     fprintf(output, "rtsp-use-tcp=%in", instance->rtsp_use_tcp);
  2549.     fprintf(output, "rtsp-use-http=%in", instance->rtsp_use_http);
  2550.     fclose(output);
  2551.     ret = rename(tmp_name, config_name);
  2552.     if (ret == -1) {
  2553. ret = errno;
  2554. if (DEBUG) {
  2555.     printf("Unable to rename the file %s to %sn",
  2556.    tmp_name, config_name);
  2557.     printf("Error code: %i - %sn", ret, strerror(ret));
  2558. }
  2559.     }
  2560. }
  2562.     }
  2564.     snprintf(buffer, 1000, "%s", getenv("HOME"));
  2565.     strlcat(buffer, "/.mozilla/pluginreg.dat", 1000);
  2566.     unlink(buffer);
  2567.     snprintf(buffer, 1000, "%s", getenv("HOME"));
  2568.     strlcat(buffer, "/.firefox/pluginreg.dat", 1000);
  2569.     unlink(buffer);
  2570.     snprintf(buffer, 1000, "%s", getenv("HOME"));
  2571.     strlcat(buffer, "/.mozilla/firefox/pluginreg.dat", 1000);
  2572.     unlink(buffer);
  2573.     NPN_ReloadPlugins(FALSE);
  2575.     return (FALSE);
  2576. }
  2578. void menuitem_config_callback(GtkMenuItem * menuitem,
  2579.       nsPluginInstance * instance)
  2580. {
  2581.     GtkWidget *conf_vbox;
  2582.     GtkWidget *conf_hbutton_box;
  2583.     GtkWidget *conf_ok;
  2584.     GtkWidget *conf_cancel;
  2585.     GtkWidget *conf_table;
  2586.     GtkWidget *conf_label;
  2587.     int row = 0;
  2588.     if (instance->conf_window != NULL)
  2589. return;
  2591.     instance->conf_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  2592.     gtk_widget_realize(instance->conf_window);
  2593.     gtk_window_set_resizable(GTK_WINDOW(instance->conf_window), FALSE);
  2595.     conf_vbox = gtk_vbox_new(FALSE, 10);
  2596.     conf_hbutton_box = gtk_hbutton_box_new();
  2597.     conf_table = gtk_table_new(20, 2, FALSE);
  2599.     gtk_container_add(GTK_CONTAINER(conf_vbox), conf_table);
  2600.     gtk_container_add(GTK_CONTAINER(conf_vbox), conf_hbutton_box);
  2601.     gtk_container_add(GTK_CONTAINER(instance->conf_window), conf_vbox);
  2602.     gtk_window_set_title(GTK_WINDOW(instance->conf_window),
  2603.  _("downloadplug-in configuration"));
  2604.     gtk_container_set_border_width(GTK_CONTAINER
  2605.    (instance->conf_window), 5);
  2606.     g_signal_connect(GTK_OBJECT(instance->conf_window), "delete_event",
  2607.      GTK_SIGNAL_FUNC(CloseConfigEvent), instance);
  2609. #ifdef GTK24_ENABLED
  2610.     instance->conf_vo = gtk_combo_box_entry_new_text();
  2611.     if (instance->conf_vo != NULL) {
  2612. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_vo), "gl");
  2613. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_vo), "x11");
  2614. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_vo), "xv");
  2615. if (instance->vo != NULL) {
  2616.     if (strcmp(instance->vo, "gl") == 0)
  2617. gtk_combo_box_set_active(GTK_COMBO_BOX
  2618.  (instance->conf_vo), 0);
  2619.     if (strcmp(instance->vo, "x11") == 0)
  2620. gtk_combo_box_set_active(GTK_COMBO_BOX
  2621.  (instance->conf_vo), 1);
  2622.     if (strcmp(instance->vo, "xv") == 0)
  2623. gtk_combo_box_set_active(GTK_COMBO_BOX
  2624.  (instance->conf_vo), 2);
  2625.     if (gtk_combo_box_get_active(GTK_COMBO_BOX(instance->conf_vo))
  2626. == -1) {
  2627. gtk_combo_box_append_text(GTK_COMBO_BOX
  2628.   (instance->conf_vo),
  2629.   instance->vo);
  2630. gtk_combo_box_set_active(GTK_COMBO_BOX
  2631.  (instance->conf_vo), 3);
  2632.     }
  2633. }
  2634.     }
  2636.     instance->conf_ao = gtk_combo_box_entry_new_text();
  2637.     if (instance->conf_ao != NULL) {
  2638. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_ao),
  2639.   "alsa");
  2640. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_ao),
  2641.   "arts");
  2642. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_ao), "esd");
  2643. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_ao),
  2644.   "jack");
  2645. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_ao), "oss");
  2646. if (instance->ao != NULL) {
  2647.     if (strcmp(instance->ao, "alsa") == 0)
  2648. gtk_combo_box_set_active(GTK_COMBO_BOX
  2649.  (instance->conf_ao), 0);
  2650.     if (strcmp(instance->ao, "arts") == 0)
  2651. gtk_combo_box_set_active(GTK_COMBO_BOX
  2652.  (instance->conf_ao), 1);
  2653.     if (strcmp(instance->ao, "esd") == 0)
  2654. gtk_combo_box_set_active(GTK_COMBO_BOX
  2655.  (instance->conf_ao), 2);
  2656.     if (strcmp(instance->ao, "jack") == 0)
  2657. gtk_combo_box_set_active(GTK_COMBO_BOX
  2658.  (instance->conf_ao), 3);
  2659.     if (strcmp(instance->ao, "oss") == 0)
  2660. gtk_combo_box_set_active(GTK_COMBO_BOX
  2661.  (instance->conf_ao), 4);
  2662.     if (gtk_combo_box_get_active(GTK_COMBO_BOX(instance->conf_ao))
  2663. == -1) {
  2664. gtk_combo_box_append_text(GTK_COMBO_BOX
  2665.   (instance->conf_ao),
  2666.   instance->ao);
  2667. gtk_combo_box_set_active(GTK_COMBO_BOX
  2668.  (instance->conf_ao), 4);
  2669.     }
  2670. }
  2671.     }
  2673.     instance->conf_dir = gtk_combo_box_entry_new_text();
  2674.     if (instance->conf_dir != NULL) {
  2675. gtk_combo_box_append_text(GTK_COMBO_BOX(instance->conf_dir),
  2676.   "$HOME");
  2677. if (instance->download_dir != NULL) {
  2678.     if (strcmp(instance->download_dir, "$HOME") == 0)
  2679. gtk_combo_box_set_active(GTK_COMBO_BOX
  2680.  (instance->conf_dir), 0);
  2681.     if (gtk_combo_box_get_active(GTK_COMBO_BOX(instance->conf_dir))
  2682. == -1) {
  2683. gtk_combo_box_append_text(GTK_COMBO_BOX
  2684.   (instance->conf_dir),
  2685.   instance->download_dir);
  2686. gtk_combo_box_set_active(GTK_COMBO_BOX
  2687.  (instance->conf_dir), 1);
  2688.     }
  2689. }
  2690.     }
  2691. #endif
  2693.     conf_ok = gtk_button_new_with_label(_("OK"));
  2694.     g_signal_connect(GTK_OBJECT(conf_ok), "clicked",
  2695.      GTK_SIGNAL_FUNC(ApplyConfig), instance);
  2697.     conf_cancel = gtk_button_new_with_label(_("Cancel"));
  2698.     g_signal_connect(GTK_OBJECT(conf_cancel), "clicked",
  2699.      GTK_SIGNAL_FUNC(CloseConfig), instance);
  2701. #ifdef GTK24_ENABLED
  2702.     conf_label = gtk_label_new(_("Video Output:"));
  2703.     gtk_misc_set_alignment(GTK_MISC(conf_label), 0.0, 0.0);
  2704.     gtk_table_attach_defaults(GTK_TABLE(conf_table), conf_label, 0, 1,
  2705.       0, 1);
  2706.     gtk_widget_show(conf_label);
  2707.     gtk_table_attach_defaults(GTK_TABLE(conf_table), instance->conf_vo,
  2708.       1, 2, 0, 1);
  2710.     conf_label = gtk_label_new(_("Audio Output:"));
  2711.     gtk_misc_set_alignment(GTK_MISC(conf_label), 0.0, 0.0);
  2712.     gtk_table_attach_defaults(GTK_TABLE(conf_table), conf_label, 0, 1,
  2713.       1, 2);
  2714.     gtk_widget_show(conf_label);
  2715.     gtk_misc_set_alignment(GTK_MISC(conf_label), 0.0, 0.0);
  2716.     gtk_table_attach_defaults(GTK_TABLE(conf_table), instance->conf_ao,
  2717.       1, 2, 1, 2);
  2718.     conf_label = gtk_label_new(_("Save to Location:"));
  2719.     gtk_table_attach_defaults(GTK_TABLE(conf_table), conf_label, 0, 1,
  2720.       2, 3);
  2721.     gtk_widget_show(conf_label);
  2722.     gtk_misc_set_alignment(GTK_MISC(conf_label), 0.0, 0.0);
  2723.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2724.       instance->conf_dir, 1, 2, 2, 3);
  2725. #endif
  2727.     conf_label = gtk_label_new(_("Minimum Cache Size:"));
  2728.     gtk_misc_set_alignment(GTK_MISC(conf_label), 0.0, 0.0);
  2729.     gtk_table_attach_defaults(GTK_TABLE(conf_table), conf_label, 0, 1,
  2730.       3, 4);
  2731.     gtk_widget_show(conf_label);
  2732.     instance->conf_cachesize = gtk_hscale_new_with_range(0, 32767, 512);
  2733.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2734.       instance->conf_cachesize, 1, 2, 3, 4);
  2735.     gtk_range_set_value(GTK_RANGE(instance->conf_cachesize),
  2736. instance->cachesize);
  2737.     gtk_widget_show(instance->conf_cachesize);
  2739.     conf_label = gtk_label_new(_("Percent of Media to Cache:"));
  2740.     gtk_misc_set_alignment(GTK_MISC(conf_label), 0.0, 0.0);
  2741.     gtk_table_attach_defaults(GTK_TABLE(conf_table), conf_label, 0, 1,
  2742.       4, 5);
  2743.     gtk_widget_show(conf_label);
  2744.     instance->conf_cachepercent = gtk_hscale_new_with_range(0, 100, 5);
  2745.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2746.       instance->conf_cachepercent, 1, 2, 4, 5);
  2747.     gtk_range_set_value(GTK_RANGE(instance->conf_cachepercent),
  2748. instance->cache_percent);
  2749.     gtk_widget_show(instance->conf_cachepercent);
  2751.     row = 5;
  2752.     instance->conf_showtime =
  2753. gtk_check_button_new_with_label(_("Show time in progress bar"));
  2754.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2755.       instance->conf_showtime, 1, 2, row, row + 1);
  2756.     row++;
  2757.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2758.  (instance->conf_showtime),
  2759.  instance->showtime);
  2760.     gtk_widget_show(instance->conf_showtime);
  2762.     instance->conf_enable_wmp =
  2763. gtk_check_button_new_with_label(_
  2764. ("Enable Windows Media Player Support"));
  2765.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2766.       instance->conf_enable_wmp, 1, 2, row,
  2767.       row + 1);
  2768.     row++;
  2769.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2770.  (instance->conf_enable_wmp),
  2771.  instance->enable_wmp);
  2772.     gtk_widget_show(instance->conf_enable_wmp);
  2774.     instance->conf_enable_qt =
  2775. gtk_check_button_new_with_label(_("Enable QuickTime Support"));
  2776.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2777.       instance->conf_enable_qt, 1, 2, row,
  2778.       row + 1);
  2779.     row++;
  2780.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2781.  (instance->conf_enable_qt),
  2782.  instance->enable_qt);
  2783.     gtk_widget_show(instance->conf_enable_qt);
  2785.     instance->conf_enable_rm =
  2786. gtk_check_button_new_with_label(_("Enable RealMedia Support"));
  2787.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2788.       instance->conf_enable_rm, 1, 2, row,
  2789.       row + 1);
  2790.     row++;
  2791.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2792.  (instance->conf_enable_rm),
  2793.  instance->enable_rm);
  2794.     gtk_widget_show(instance->conf_enable_rm);
  2796.     instance->conf_enable_smil =
  2797. gtk_check_button_new_with_label(_
  2798. ("Enable SMIL Support (Effects QuickTime and RealMedia)"));
  2799.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2800.       instance->conf_enable_smil, 1, 2, row,
  2801.       row + 1);
  2802.     row++;
  2803.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2804.  (instance->conf_enable_smil),
  2805.  instance->enable_smil);
  2806.     gtk_widget_show(instance->conf_enable_smil);
  2808.     instance->conf_enable_helix =
  2809. gtk_check_button_new_with_label(_("Enable Helix Emulation"));
  2810.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2811.       instance->conf_enable_helix, 1, 2, row,
  2812.       row + 1);
  2813.     row++;
  2814.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2815.  (instance->conf_enable_helix),
  2816.  instance->enable_helix);
  2817.     gtk_widget_show(instance->conf_enable_helix);
  2819.     instance->conf_enable_gmp =
  2820. gtk_check_button_new_with_label(_
  2821. ("Enable Google Media Player Support"));
  2822.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2823.       instance->conf_enable_gmp, 1, 2, row,
  2824.       row + 1);
  2825.     row++;
  2826.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2827.  (instance->conf_enable_gmp),
  2828.  instance->enable_gmp);
  2829.     gtk_widget_show(instance->conf_enable_gmp);
  2831.     instance->conf_enable_mpeg =
  2832. gtk_check_button_new_with_label(_("Enable MPEG Support"));
  2833.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2834.       instance->conf_enable_mpeg, 1, 2, row,
  2835.       row + 1);
  2836.     row++;
  2837.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2838.  (instance->conf_enable_mpeg),
  2839.  instance->enable_mpeg);
  2840.     gtk_widget_show(instance->conf_enable_mpeg);
  2842.     instance->conf_enable_mp3 =
  2843. gtk_check_button_new_with_label(_
  2844. ("Enable MP3 Support (Requires MPEG Support)"));
  2845.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2846.       instance->conf_enable_mp3, 1, 2, row,
  2847.       row + 1);
  2848.     row++;
  2849.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2850.  (instance->conf_enable_mp3),
  2851.  instance->enable_mp3);
  2852.     gtk_widget_show(instance->conf_enable_mp3);
  2854.     instance->conf_enable_ogg =
  2855. gtk_check_button_new_with_label(_("Enable Ogg Support"));
  2856.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2857.       instance->conf_enable_ogg, 1, 2, row,
  2858.       row + 1);
  2859.     row++;
  2860.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2861.  (instance->conf_enable_ogg),
  2862.  instance->enable_ogg);
  2863.     gtk_widget_show(instance->conf_enable_ogg);
  2865.     instance->conf_enable_midi =
  2866. gtk_check_button_new_with_label(_("Enable MIDI Support"));
  2867.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2868.       instance->conf_enable_midi, 1, 2, row,
  2869.       row + 1);
  2870.     row++;
  2871.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2872.  (instance->conf_enable_midi),
  2873.  instance->enable_midi);
  2874.     gtk_widget_show(instance->conf_enable_midi);
  2876.     instance->conf_enable_pls =
  2877. gtk_check_button_new_with_label(_("Enable Shoutcast PLS Support"));
  2878.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2879.       instance->conf_enable_pls, 1, 2, row,
  2880.       row + 1);
  2881.     row++;
  2882.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2883.  (instance->conf_enable_pls),
  2884.  instance->enable_pls);
  2885.     gtk_widget_show(instance->conf_enable_pls);
  2887.     instance->conf_enable_dvx =
  2888. gtk_check_button_new_with_label(_("Enable DivX Support"));
  2889.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2890.       instance->conf_enable_dvx, 1, 2, row,
  2891.       row + 1);
  2892.     row++;
  2893.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2894.  (instance->conf_enable_dvx),
  2895.  instance->enable_dvx);
  2896.     gtk_widget_show(instance->conf_enable_dvx);
  2898.     instance->conf_nomediacache =
  2899. gtk_check_button_new_with_label(_
  2900. ("Play media directly from site (No Caching)"));
  2901.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2902.       instance->conf_nomediacache, 1, 2, row,
  2903.       row + 1);
  2904.     row++;
  2905.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2906.  (instance->conf_nomediacache),
  2907.  instance->nomediacache);
  2908.     gtk_widget_show(instance->conf_nomediacache);
  2910.     instance->conf_rtsptcp =
  2911. gtk_check_button_new_with_label(_
  2912. ("Connect to RTSP Media over TCP"));
  2913.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2914.       instance->conf_rtsptcp, 1, 2, row, row + 1);
  2915.     row++;
  2916.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2917.  (instance->conf_rtsptcp),
  2918.  instance->rtsp_use_tcp);
  2919.     gtk_widget_show(instance->conf_rtsptcp);
  2921.     instance->conf_rtsphttp =
  2922. gtk_check_button_new_with_label(_("Use HTTP instead of RTSP"));
  2923.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2924.       instance->conf_rtsphttp, 1, 2, row, row + 1);
  2925.     row++;
  2926.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2927.  (instance->conf_rtsphttp),
  2928.  instance->rtsp_use_http);
  2929.     gtk_widget_show(instance->conf_rtsphttp);
  2931.     instance->conf_pauseonhide =
  2932. gtk_check_button_new_with_label(_("Pause Video when hidden"));
  2933.     gtk_table_attach_defaults(GTK_TABLE(conf_table),
  2934.       instance->conf_pauseonhide, 1, 2, row,
  2935.       row + 1);
  2936.     row++;
  2937.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
  2938.  (instance->conf_pauseonhide),
  2939.  !instance->nopauseonhide);
  2940.     gtk_widget_show(instance->conf_pauseonhide);
  2943.     gtk_container_add(GTK_CONTAINER(conf_hbutton_box), conf_ok);
  2944.     gtk_container_add(GTK_CONTAINER(conf_hbutton_box), conf_cancel);
  2946. #ifdef GTK24_ENABLED
  2947.     if (instance->conf_vo != NULL)
  2948. gtk_widget_show(instance->conf_vo);
  2949.     if (instance->conf_ao != NULL)
  2950. gtk_widget_show(instance->conf_ao);
  2951.     if (instance->conf_dir != NULL)
  2952. gtk_widget_show(instance->conf_dir);
  2953. #endif
  2954.     gtk_widget_show(conf_ok);
  2955.     gtk_widget_show(conf_cancel);
  2956.     gtk_widget_show(conf_table);
  2957.     gtk_widget_show(conf_hbutton_box);
  2958.     gtk_widget_show(conf_vbox);
  2959.     gtk_widget_show(instance->conf_window);
  2961. }
  2963. gboolean window_visible(GtkWidget * widget, GdkEvent * event,
  2964. nsPluginInstance * instance)
  2965. {
  2967.     //if (DEBUG)
  2968.     //      printf("**************nnnn in window_visible %innnnn******************n",GTK_WIDGET_VISIBLE(widget));
  2970.     // only pause if video is present, if we have streaming audio we want to keep playing
  2972.     if (instance->cancelled == 0) {
  2974. if (event->type == GDK_VISIBILITY_NOTIFY) {
  2976.     if (((GdkEventVisibility *) event)->state ==
  2977. GDK_VISIBILITY_FULLY_OBSCURED) {
  2978. if (instance->paused == 0 && instance->threadsignaled
  2979.     && instance->nopauseonhide == 0) {
  2981.     if (instance->movie_width != 0
  2982. && instance->movie_height != 0) {
  2983. instance->Pause();
  2984. instance->paused_wheninvisible = 1;
  2985.     }
  2986. }
  2988. if (instance->onHiddenCallback != NULL)
  2989.     NPN_GetURL(instance->mInstance,
  2990.        instance->onHiddenCallback, "_self");
  2992.     } else {
  2993. if (instance->paused_wheninvisible == 1
  2994.     && instance->threadsignaled
  2995.     && instance->nopauseonhide == 0) {
  2997.     if (instance->movie_width != 0
  2998. && instance->movie_height != 0) {
  2999. instance->Play();
  3000. instance->paused_wheninvisible = 0;
  3001.     }
  3002. }
  3004. if (instance->onVisibleCallback != NULL)
  3005.     NPN_GetURL(instance->mInstance,
  3006.        instance->onVisibleCallback, "_self");
  3008.     }
  3010. }
  3011.     }
  3012.     return (FALSE);
  3014. }
  3016. gboolean load_href_callback(GtkWidget * widget, GdkEventExpose * event,
  3017.     nsPluginInstance * instance)
  3018. {
  3019.     Node *n;
  3020.     GdkEventButton *event_button;
  3022.     if (DEBUG)
  3023. printf("image clickedn");
  3025.     if (event->type == GDK_BUTTON_PRESS) {
  3026. event_button = (GdkEventButton *) event;
  3028. if (event_button->button == 3) {
  3029.     gtk_menu_popup(instance->popup_menu, NULL, NULL, NULL,
  3030.    NULL, event_button->button, event_button->time);
  3031.     return TRUE;
  3032. }
  3034. if (event_button->button == 1) {
  3035.     n = instance->list;
  3037.     while (n != NULL) {
  3038. if (strcmp(n->url, instance->href) == 0)
  3039.     break;
  3040. else
  3041.     n = n->next;
  3042.     }
  3044.     if (n == NULL) {
  3045. n = newNode();
  3046. snprintf(n->url, 1024, "%s", instance->href);
  3047. n->frombutton = 1;
  3048. addToEnd(instance->td->list, n);
  3049. NPN_GetURL(instance->mInstance, instance->href, NULL);
  3050. if (instance->targetplayer == 0)
  3051.     gtk_widget_hide(instance->src_event_box);
  3052.     } else {
  3053. if (instance->targetplayer == 0)
  3054.     gtk_widget_hide(instance->src_event_box);
  3055. n->play = 1;
  3056. instance->Play();
  3057.     }
  3059.     if (instance->targetplayer == 1)
  3060. gtk_widget_show(instance->gtkwidget);
  3062.     return TRUE;
  3063. }
  3064.     }
  3066.     return FALSE;
  3068. }
  3069. #endif
  3070. #endif // GTK_ENABLED
  3072. int srcToButton(char *url, nsPluginInstance * instance)
  3073. {
  3074. #ifndef GTK2_ENABLED
  3075.     return FALSE;
  3076. #endif
  3078. #ifdef GTK2_ENABLED
  3080.     gchar *command;
  3081.     GError *error = NULL;
  3082.     int exit_status;
  3083.     gchar *dirname = NULL;
  3084.     gchar *filename = NULL;
  3085.     gboolean result;
  3086.     GtkWidget *fixed_button_container;
  3088.     if (DEBUG)
  3089. printf("In srcToButtonn");
  3091.     // try to load the file natively
  3093.     instance->pb_src = gdk_pixbuf_new_from_file(url, &error);
  3095.     if (instance->pb_src == NULL) {
  3096. // setup tmp directory
  3097. dirname =
  3098.     g_strdup_printf("%s", tempnam("/tmp", "downloadplug-inXXXXXX"));
  3099. filename = g_strdup_printf("%s/00000001.jpg", dirname);
  3101. // run download and try to get the first frame and convert it to a jpeg
  3102. command =
  3103.     g_strdup_printf("download -vo jpeg:outdir=%s -frames 1 %s",
  3104.     dirname, url);
  3105. if (!g_spawn_command_line_sync
  3106.     (command, NULL, NULL, &exit_status, &error))
  3107.     printf("Error when running When running command: %sn%sn",
  3108.    command, error->message);
  3110. if (fexists(filename)) {
  3111.     error = NULL;
  3112.     instance->pb_src = gdk_pixbuf_new_from_file(filename, &error);
  3113. } else {
  3114.     instance->pb_src =
  3115. gdk_pixbuf_new_from_xpm_data((const char **) start);
  3116. }
  3118.     }
  3120.     if (instance->pb_src != NULL) {
  3121. if (instance->targetplayer == 0) {
  3122.     instance->src_event_box = gtk_event_box_new();
  3123.     instance->image_src =
  3124. gtk_image_new_from_pixbuf(instance->pb_src);
  3125.     gtk_container_add(GTK_CONTAINER(instance->src_event_box),
  3126.       instance->image_src);
  3127.     g_signal_connect(G_OBJECT(instance->src_event_box),
  3128.      "button_press_event",
  3129.      G_CALLBACK(load_href_callback), instance);
  3130.     gtk_fixed_put(GTK_FIXED(instance->fixed_container),
  3131.   instance->src_event_box, 0, 0);
  3132.     gtk_widget_set_size_request(GTK_WIDGET
  3133. (instance->src_event_box),
  3134. instance->embed_width,
  3135. instance->embed_height);
  3136.     gtk_widget_show(GTK_WIDGET(instance->image_src));
  3137.     gtk_widget_show(instance->src_event_box);
  3138.     gtk_widget_show(instance->fixed_container);
  3139. } else {
  3140.     gtk_widget_add_events(instance->button_window,
  3141.   GDK_BUTTON_PRESS_MASK);
  3142.     gtk_widget_realize(instance->button_window);
  3143.     instance->src_event_box = gtk_event_box_new();
  3144.     instance->image_src =
  3145. gtk_image_new_from_pixbuf(instance->pb_src);
  3146.     g_signal_connect(G_OBJECT(instance->src_event_box),
  3147.      "button_press_event",
  3148.      G_CALLBACK(load_href_callback), instance);
  3150.     gtk_widget_set_size_request(GTK_WIDGET
  3151. (instance->src_event_box),
  3152. instance->embed_width,
  3153. instance->embed_height);
  3154.     gtk_container_add(GTK_CONTAINER(instance->src_event_box),
  3155.       instance->image_src);
  3156.     fixed_button_container = gtk_fixed_new();
  3157.     gtk_widget_set_size_request(GTK_WIDGET
  3158. (fixed_button_container),
  3159. instance->embed_width,
  3160. instance->embed_height);
  3161.     gtk_container_add(GTK_CONTAINER(instance->button_window),
  3162.       fixed_button_container);
  3163.     gtk_fixed_put(GTK_FIXED(fixed_button_container),
  3164.   instance->src_event_box, 0, 0);
  3165.     gtk_widget_show(GTK_WIDGET(instance->image_src));
  3166.     gtk_widget_show(instance->src_event_box);
  3167.     gtk_widget_show(fixed_button_container);
  3168.     gtk_widget_show(instance->button_window);
  3169.     g_idle_add(gtkgui_draw, instance);
  3171. }
  3172. result = TRUE;
  3173.     } else {
  3174. if (instance->targetplayer == 1)
  3175.     gtk_widget_show(instance->gtkwidget);
  3176. result = FALSE;
  3177.     }
  3179.     if (filename != NULL) {
  3180. remove(filename);
  3181. g_free(filename);
  3182.     }
  3184.     if (dirname != NULL) {
  3185. remove(dirname);
  3186. g_free(dirname);
  3187.     }
  3189.     return result;
  3191. #endif
  3192. }
  3194. #ifdef GTK_ENABLED
  3195. gboolean target_hide_callback(GtkWidget * widget, GdkEvent * event,
  3196.       nsPluginInstance * instance)
  3197. {
  3198.     if (DEBUG)
  3199. printf("Hiding gtkwidget, windown");
  3200.     gtk_widget_hide(GTK_WIDGET(instance->gtkwidget));
  3201.     instance->Quit();
  3202.     return TRUE;
  3203. }
  3205. #endif // GTK_ENABLED