libvlc_audio_*: remove useless exception parameters
[vlc.git] / projects / mozilla / vlcplugin.cpp
1 /*****************************************************************************
2  * vlcplugin.cpp: a VLC plugin for Mozilla
3  *****************************************************************************
4  * Copyright (C) 2002-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Samuel Hocevar <sam@zoy.org>
8  *          Damien Fouilleul <damienf.fouilleul@laposte.net>
9  *          Jean-Paul Saman <jpsaman@videolan.org>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29 #include "config.h"
30
31 #ifdef HAVE_MOZILLA_CONFIG_H
32 #   include <mozilla-config.h>
33 #endif
34
35 #include "vlcplugin.h"
36 #include "control/npolibvlc.h"
37
38 #include <ctype.h>
39
40 /*****************************************************************************
41  * VlcPlugin constructor and destructor
42  *****************************************************************************/
43 VlcPlugin::VlcPlugin( NPP instance, uint16 mode ) :
44     i_npmode(mode),
45     b_stream(0),
46     b_autoplay(1),
47     b_toolbar(0),
48     psz_text(NULL),
49     psz_target(NULL),
50     playlist_index(-1),
51     libvlc_instance(NULL),
52     libvlc_media_list(NULL),
53     libvlc_media_player(NULL),
54     p_scriptClass(NULL),
55     p_browser(instance),
56     psz_baseURL(NULL)
57 #if XP_WIN
58     ,pf_wndproc(NULL)
59 #endif
60 #if XP_UNIX
61     ,i_width((unsigned)-1)
62     ,i_height((unsigned)-1)
63     ,i_tb_width(0)
64     ,i_tb_height(0)
65     ,i_last_position(0)
66     ,p_btnPlay(NULL)
67     ,p_btnPause(NULL)
68     ,p_btnStop(NULL)
69     ,p_btnMute(NULL)
70     ,p_btnUnmute(NULL)
71     ,p_btnFullscreen(NULL)
72     ,p_btnTime(NULL)
73     ,p_timeline(NULL)
74 #endif
75 {
76     memset(&npwindow, 0, sizeof(NPWindow));
77 #if XP_UNIX
78     memset(&npvideo, 0, sizeof(Window));
79     memset(&npcontrol, 0, sizeof(Window));
80 #endif
81 }
82
83 static bool boolValue(const char *value) {
84     return ( !strcmp(value, "1") ||
85              !strcasecmp(value, "true") ||
86              !strcasecmp(value, "yes") );
87 }
88
89 NPError VlcPlugin::init(int argc, char* const argn[], char* const argv[])
90 {
91     /* prepare VLC command line */
92     const char *ppsz_argv[32];
93     int ppsz_argc = 0;
94
95 #ifndef NDEBUG
96     ppsz_argv[ppsz_argc++] = "--no-plugins-cache";
97 #endif
98
99     /* locate VLC module path */
100 #ifdef XP_MACOSX
101     ppsz_argv[ppsz_argc++] = "--plugin-path=/Library/Internet\\ Plug-Ins/VLC\\ Plugin.plugin/Contents/MacOS/modules";
102     ppsz_argv[ppsz_argc++] = "--vout=minimal_macosx";
103 #elif defined(XP_WIN)
104     HKEY h_key;
105     DWORD i_type, i_data = MAX_PATH + 1;
106     char p_data[MAX_PATH + 1];
107     if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, "Software\\VideoLAN\\VLC",
108                       0, KEY_READ, &h_key ) == ERROR_SUCCESS )
109     {
110          if( RegQueryValueEx( h_key, "InstallDir", 0, &i_type,
111                               (LPBYTE)p_data, &i_data ) == ERROR_SUCCESS )
112          {
113              if( i_type == REG_SZ )
114              {
115                  strcat( p_data, "\\plugins" );
116                  ppsz_argv[ppsz_argc++] = "--plugin-path";
117                  ppsz_argv[ppsz_argc++] = p_data;
118              }
119          }
120          RegCloseKey( h_key );
121     }
122     ppsz_argv[ppsz_argc++] = "--no-one-instance";
123
124 #endif /* XP_MACOSX */
125
126     /* common settings */
127     ppsz_argv[ppsz_argc++] = "-vv";
128     ppsz_argv[ppsz_argc++] = "--no-stats";
129     ppsz_argv[ppsz_argc++] = "--no-media-library";
130     ppsz_argv[ppsz_argc++] = "--intf=dummy";
131     ppsz_argv[ppsz_argc++] = "--no-video-title-show";
132
133     const char *progid = NULL;
134
135     /* parse plugin arguments */
136     for( int i = 0; (i < argc) && (ppsz_argc < 32); i++ )
137     {
138        /* fprintf(stderr, "argn=%s, argv=%s\n", argn[i], argv[i]); */
139
140         if( !strcmp( argn[i], "target" )
141          || !strcmp( argn[i], "mrl")
142          || !strcmp( argn[i], "filename")
143          || !strcmp( argn[i], "src") )
144         {
145             psz_target = argv[i];
146         }
147         else if( !strcmp( argn[i], "text" ) )
148         {
149             free( psz_text );
150             psz_text = strdup( argv[i] );
151         }
152         else if( !strcmp( argn[i], "autoplay")
153               || !strcmp( argn[i], "autostart") )
154         {
155             b_autoplay = boolValue(argv[i]);
156         }
157         else if( !strcmp( argn[i], "fullscreen" ) )
158         {
159             if( boolValue(argv[i]) )
160             {
161                 ppsz_argv[ppsz_argc++] = "--fullscreen";
162             }
163             else
164             {
165                 ppsz_argv[ppsz_argc++] = "--no-fullscreen";
166             }
167         }
168         else if( !strcmp( argn[i], "mute" ) )
169         {
170             if( boolValue(argv[i]) )
171             {
172                 ppsz_argv[ppsz_argc++] = "--volume=0";
173             }
174         }
175         else if( !strcmp( argn[i], "loop")
176               || !strcmp( argn[i], "autoloop") )
177         {
178             if( boolValue(argv[i]) )
179             {
180                 ppsz_argv[ppsz_argc++] = "--loop";
181             }
182             else
183             {
184                 ppsz_argv[ppsz_argc++] = "--no-loop";
185             }
186         }
187         else if( !strcmp( argn[i], "version")
188               || !strcmp( argn[i], "progid") )
189         {
190             progid = argv[i];
191         }
192         else if( !strcmp( argn[i], "toolbar" ) )
193         {
194 /* FIXME: Remove this when toolbar functionality has been implemented on
195  * MacOS X and Win32 for Firefox/Mozilla/Safari. */
196 #ifdef XP_UNIX
197             b_toolbar = boolValue(argv[i]);
198 #endif
199         }
200     }
201
202     libvlc_exception_t ex;
203     libvlc_exception_init(&ex);
204
205     libvlc_instance = libvlc_new(ppsz_argc, ppsz_argv, &ex);
206     if( libvlc_exception_raised(&ex) )
207     {
208         libvlc_exception_clear(&ex);
209         return NPERR_GENERIC_ERROR;
210     }
211
212     libvlc_media_list = libvlc_media_list_new(libvlc_instance,&ex);
213     if( libvlc_exception_raised(&ex) )
214     {
215         libvlc_exception_clear(&ex);
216         return NPERR_GENERIC_ERROR;
217     }
218
219     /*
220     ** fetch plugin base URL, which is the URL of the page containing the plugin
221     ** this URL is used for making absolute URL from relative URL that may be
222     ** passed as an MRL argument
223     */
224     NPObject *plugin = NULL;
225
226     if( NPERR_NO_ERROR == NPN_GetValue(p_browser, NPNVWindowNPObject, &plugin) )
227     {
228         /*
229         ** is there a better way to get that info ?
230         */
231         static const char docLocHref[] = "document.location.href";
232         NPString script;
233         NPVariant result;
234
235         script.utf8characters = docLocHref;
236         script.utf8length = sizeof(docLocHref)-1;
237
238         if( NPN_Evaluate(p_browser, plugin, &script, &result) )
239         {
240             if( NPVARIANT_IS_STRING(result) )
241             {
242                 NPString &location = NPVARIANT_TO_STRING(result);
243
244                 psz_baseURL = (char *) malloc(location.utf8length+1);
245                 if( psz_baseURL )
246                 {
247                     strncpy(psz_baseURL, location.utf8characters, location.utf8length);
248                     psz_baseURL[location.utf8length] = '\0';
249                 }
250             }
251             NPN_ReleaseVariantValue(&result);
252         }
253         NPN_ReleaseObject(plugin);
254     }
255
256     if( psz_target )
257     {
258         // get absolute URL from src
259         char *psz_absurl = getAbsoluteURL(psz_target);
260         psz_target = psz_absurl ? psz_absurl : strdup(psz_target);
261     }
262
263     /* assign plugin script root class */
264     /* new APIs */
265     p_scriptClass = RuntimeNPClass<LibvlcRootNPObject>::getClass();
266
267     return NPERR_NO_ERROR;
268 }
269
270 VlcPlugin::~VlcPlugin()
271 {
272     free(psz_baseURL);
273     free(psz_target);
274     free(psz_text);
275
276     if( libvlc_media_player )
277         libvlc_media_player_release( libvlc_media_player );
278     if( libvlc_media_list )
279         libvlc_media_list_release( libvlc_media_list );
280     if( libvlc_instance )
281         libvlc_release(libvlc_instance);
282 }
283
284 /*****************************************************************************
285  * VlcPlugin playlist replacement methods
286  *****************************************************************************/
287 void VlcPlugin::set_player_window( libvlc_exception_t *ex )
288 {
289 #ifdef XP_UNIX
290     libvlc_media_player_set_xwindow(libvlc_media_player,
291                                     (libvlc_drawable_t)getVideoWindow(),
292                                     ex);
293 #endif
294 #ifdef XP_MACOSX
295     // XXX FIXME insert appropriate call here
296 #endif
297 #ifdef XP_WIN
298     libvlc_media_player_set_hwnd(libvlc_media_player,
299                                  getWindow().window,
300                                  ex);
301 #endif
302 }
303
304 int VlcPlugin::playlist_add( const char *mrl, libvlc_exception_t *ex )
305 {
306     int item = -1;
307     libvlc_media_t *p_m = libvlc_media_new(libvlc_instance,mrl,ex);
308     if( libvlc_exception_raised(ex) )
309         return -1;
310
311     libvlc_media_list_lock(libvlc_media_list);
312     libvlc_media_list_add_media(libvlc_media_list,p_m,ex);
313     if( !libvlc_exception_raised(ex) )
314         item = libvlc_media_list_count(libvlc_media_list,ex)-1;
315     libvlc_media_list_unlock(libvlc_media_list);
316
317     libvlc_media_release(p_m);
318
319     return item;
320 }
321
322 int VlcPlugin::playlist_add_extended_untrusted( const char *mrl, const char *name,
323                     int optc, const char **optv, libvlc_exception_t *ex )
324 {
325     libvlc_media_t *p_m = libvlc_media_new(libvlc_instance, mrl,ex);
326     int item = -1;
327     if( libvlc_exception_raised(ex) )
328         return -1;
329
330     for( int i = 0; i < optc; ++i )
331         libvlc_media_add_option_flag(p_m, optv[i], libvlc_media_option_unique);
332
333     libvlc_media_list_lock(libvlc_media_list);
334     libvlc_media_list_add_media(libvlc_media_list,p_m,ex);
335     if( !libvlc_exception_raised(ex) )
336         item = libvlc_media_list_count(libvlc_media_list,ex)-1;
337     libvlc_media_list_unlock(libvlc_media_list);
338     libvlc_media_release(p_m);
339
340     return item;
341 }
342
343 bool VlcPlugin::playlist_select( int idx, libvlc_exception_t *ex )
344 {
345     libvlc_media_t *p_m = NULL;
346
347     libvlc_media_list_lock(libvlc_media_list);
348
349     int count = libvlc_media_list_count(libvlc_media_list,ex);
350     if( libvlc_exception_raised(ex) )
351         goto bad_unlock;
352
353     if( idx<0||idx>=count )
354         goto bad_unlock;
355
356     playlist_index = idx;
357
358     p_m = libvlc_media_list_item_at_index(libvlc_media_list,playlist_index,ex);
359     libvlc_media_list_unlock(libvlc_media_list);
360
361     if( libvlc_exception_raised(ex) )
362         return false;
363
364     if( libvlc_media_player )
365     {
366         libvlc_media_player_release( libvlc_media_player );
367         libvlc_media_player = NULL;
368     }
369
370     libvlc_media_player = libvlc_media_player_new_from_media(p_m,ex);
371     if( libvlc_media_player )
372         set_player_window(ex);
373
374     libvlc_media_release( p_m );
375     return !libvlc_exception_raised(ex);
376
377 bad_unlock:
378     libvlc_media_list_unlock(libvlc_media_list);
379     return false;
380 }
381
382 void VlcPlugin::playlist_delete_item( int idx, libvlc_exception_t *ex )
383 {
384     libvlc_media_list_lock(libvlc_media_list);
385     libvlc_media_list_remove_index(libvlc_media_list,idx,ex);
386     libvlc_media_list_unlock(libvlc_media_list);
387 }
388
389 void VlcPlugin::playlist_clear( libvlc_exception_t *ex )
390 {
391     if( libvlc_media_list )
392         libvlc_media_list_release(libvlc_media_list);
393     libvlc_media_list = libvlc_media_list_new(getVLC(),ex);
394 }
395
396 int VlcPlugin::playlist_count( libvlc_exception_t *ex )
397 {
398     int items_count = 0;
399     libvlc_media_list_lock(libvlc_media_list);
400     items_count = libvlc_media_list_count(libvlc_media_list,ex);
401     libvlc_media_list_unlock(libvlc_media_list);
402     return items_count;
403 }
404
405 void VlcPlugin::toggle_fullscreen( libvlc_exception_t *ex )
406 {
407     if( playlist_isplaying(ex) )
408         libvlc_toggle_fullscreen(libvlc_media_player,ex);
409 }
410 void VlcPlugin::set_fullscreen( int yes, libvlc_exception_t *ex )
411 {
412     if( playlist_isplaying(ex) )
413         libvlc_set_fullscreen(libvlc_media_player,yes,ex);
414 }
415 int  VlcPlugin::get_fullscreen( libvlc_exception_t *ex )
416 {
417     int r = 0;
418     if( playlist_isplaying(ex) )
419         r = libvlc_get_fullscreen(libvlc_media_player,ex);
420     return r;
421 }
422
423 bool  VlcPlugin::player_has_vout( libvlc_exception_t *ex )
424 {
425     bool r = false;
426     if( playlist_isplaying(ex) )
427         r = libvlc_media_player_has_vout(libvlc_media_player, ex);
428     return r;
429 }
430
431 /*****************************************************************************
432  * VlcPlugin methods
433  *****************************************************************************/
434
435 char *VlcPlugin::getAbsoluteURL(const char *url)
436 {
437     if( NULL != url )
438     {
439         // check whether URL is already absolute
440         const char *end=strchr(url, ':');
441         if( (NULL != end) && (end != url) )
442         {
443             // validate protocol header
444             const char *start = url;
445             char c = *start;
446             if( isalpha(c) )
447             {
448                 ++start;
449                 while( start != end )
450                 {
451                     c  = *start;
452                     if( ! (isalnum(c)
453                        || ('-' == c)
454                        || ('+' == c)
455                        || ('.' == c)
456                        || ('/' == c)) ) /* VLC uses / to allow user to specify a demuxer */
457                         // not valid protocol header, assume relative URL
458                         goto relativeurl;
459                     ++start;
460                 }
461                 /* we have a protocol header, therefore URL is absolute */
462                 return strdup(url);
463             }
464             // not a valid protocol header, assume relative URL
465         }
466
467 relativeurl:
468
469         if( psz_baseURL )
470         {
471             size_t baseLen = strlen(psz_baseURL);
472             char *href = (char *) malloc(baseLen+strlen(url)+1);
473             if( href )
474             {
475                 /* prepend base URL */
476                 memcpy(href, psz_baseURL, baseLen+1);
477
478                 /*
479                 ** relative url could be empty,
480                 ** in which case return base URL
481                 */
482                 if( '\0' == *url )
483                     return href;
484
485                 /*
486                 ** locate pathname part of base URL
487                 */
488
489                 /* skip over protocol part  */
490                 char *pathstart = strchr(href, ':');
491                 char *pathend = href+baseLen;
492                 if( pathstart )
493                 {
494                     if( '/' == *(++pathstart) )
495                     {
496                         if( '/' == *(++pathstart) )
497                         {
498                             ++pathstart;
499                         }
500                     }
501                     /* skip over host part */
502                     pathstart = strchr(pathstart, '/');
503                     if( ! pathstart )
504                     {
505                         // no path, add a / past end of url (over '\0')
506                         pathstart = pathend;
507                         *pathstart = '/';
508                     }
509                 }
510                 else
511                 {
512                     /* baseURL is just a UNIX path */
513                     if( '/' != *href )
514                     {
515                         /* baseURL is not an absolute path */
516                         free(href);
517                         return NULL;
518                     }
519                     pathstart = href;
520                 }
521
522                 /* relative URL made of an absolute path ? */
523                 if( '/' == *url )
524                 {
525                     /* replace path completely */
526                     strcpy(pathstart, url);
527                     return href;
528                 }
529
530                 /* find last path component and replace it */
531                 while( '/' != *pathend)
532                     --pathend;
533
534                 /*
535                 ** if relative url path starts with one or more '../',
536                 ** factor them out of href so that we return a
537                 ** normalized URL
538                 */
539                 while( pathend != pathstart )
540                 {
541                     const char *p = url;
542                     if( '.' != *p )
543                         break;
544                     ++p;
545                     if( '\0' == *p  )
546                     {
547                         /* relative url is just '.' */
548                         url = p;
549                         break;
550                     }
551                     if( '/' == *p  )
552                     {
553                         /* relative url starts with './' */
554                         url = ++p;
555                         continue;
556                     }
557                     if( '.' != *p )
558                         break;
559                     ++p;
560                     if( '\0' == *p )
561                     {
562                         /* relative url is '..' */
563                     }
564                     else
565                     {
566                         if( '/' != *p )
567                             break;
568                         /* relative url starts with '../' */
569                         ++p;
570                     }
571                     url = p;
572                     do
573                     {
574                         --pathend;
575                     }
576                     while( '/' != *pathend );
577                 }
578                 /* skip over '/' separator */
579                 ++pathend;
580                 /* concatenate remaining base URL and relative URL */
581                 strcpy(pathend, url);
582             }
583             return href;
584         }
585     }
586     return NULL;
587 }
588
589 #if XP_UNIX
590 int  VlcPlugin::setSize(unsigned width, unsigned height)
591 {
592     int diff = (width != i_width) || (height != i_height);
593
594     i_width = width;
595     i_height = height;
596
597     /* return size */
598     return diff;
599 }
600
601 #define BTN_SPACE ((unsigned int)4)
602 void VlcPlugin::showToolbar()
603 {
604     const NPWindow& window = getWindow();
605     Window control = getControlWindow();
606     Window video = getVideoWindow();
607     Display *p_display = ((NPSetWindowCallbackStruct *)window.ws_info)->display;
608     unsigned int i_height = 0, i_width = BTN_SPACE;
609
610     /* load icons */
611     if( !p_btnPlay )
612         XpmReadFileToImage( p_display, DATA_PATH "/mozilla/play.xpm",
613                             &p_btnPlay, NULL, NULL);
614     if( p_btnPlay )
615     {
616         i_height = __MAX( i_height, p_btnPlay->height );
617     }
618     if( !p_btnPause )
619         XpmReadFileToImage( p_display, DATA_PATH "/mozilla/pause.xpm",
620                             &p_btnPause, NULL, NULL);
621     if( p_btnPause )
622     {
623         i_height = __MAX( i_height, p_btnPause->height );
624     }
625     i_width += __MAX( p_btnPause->width, p_btnPlay->width );
626
627     if( !p_btnStop )
628         XpmReadFileToImage( p_display, DATA_PATH "/mozilla/stop.xpm",
629                             &p_btnStop, NULL, NULL );
630     if( p_btnStop )
631     {
632         i_height = __MAX( i_height, p_btnStop->height );
633         i_width += BTN_SPACE + p_btnStop->width;
634     }
635     if( !p_timeline )
636         XpmReadFileToImage( p_display, DATA_PATH "/mozilla/time_line.xpm",
637                             &p_timeline, NULL, NULL);
638     if( p_timeline )
639     {
640         i_height = __MAX( i_height, p_timeline->height );
641         i_width += BTN_SPACE + p_timeline->width;
642     }
643     if( !p_btnTime )
644         XpmReadFileToImage( p_display, DATA_PATH "/mozilla/time_icon.xpm",
645                             &p_btnTime, NULL, NULL);
646     if( p_btnTime )
647     {
648         i_height = __MAX( i_height, p_btnTime->height );
649         i_width += BTN_SPACE + p_btnTime->width;
650     }
651     if( !p_btnFullscreen )
652         XpmReadFileToImage( p_display, DATA_PATH "/mozilla/fullscreen.xpm",
653                             &p_btnFullscreen, NULL, NULL);
654     if( p_btnFullscreen )
655     {
656         i_height = __MAX( i_height, p_btnFullscreen->height );
657         i_width += BTN_SPACE + p_btnFullscreen->width;
658     }
659     if( !p_btnMute )
660         XpmReadFileToImage( p_display, DATA_PATH "/mozilla/volume_max.xpm",
661                             &p_btnMute, NULL, NULL);
662     if( p_btnMute )
663     {
664         i_height = __MAX( i_height, p_btnMute->height );
665     }
666     if( !p_btnUnmute )
667         XpmReadFileToImage( p_display, DATA_PATH "/mozilla/volume_mute.xpm",
668                             &p_btnUnmute, NULL, NULL);
669     if( p_btnUnmute )
670     {
671         i_height = __MAX( i_height, p_btnUnmute->height );
672     }
673     i_width += BTN_SPACE + __MAX( p_btnUnmute->width, p_btnMute->width );
674
675     setToolbarSize( i_width, i_height );
676
677     if( !p_btnPlay || !p_btnPause || !p_btnStop || !p_timeline ||
678         !p_btnTime || !p_btnFullscreen || !p_btnMute || !p_btnUnmute )
679         fprintf(stderr, "Error: some button images not found in %s\n", DATA_PATH );
680
681     /* reset panels position and size */
682     /* XXX  use i_width */
683     XResizeWindow( p_display, video, window.width, window.height - i_height);
684     XMoveWindow( p_display, control, 0, window.height - i_height );
685     XResizeWindow( p_display, control, window.width, i_height -1);
686
687     b_toolbar = 1; /* says toolbar is now shown */
688     redrawToolbar();
689 }
690
691 void VlcPlugin::hideToolbar()
692 {
693     const NPWindow& window = getWindow();
694     Display *p_display = ((NPSetWindowCallbackStruct *)window.ws_info)->display;
695     Window control = getControlWindow();
696     Window video = getVideoWindow();
697
698     i_tb_width = i_tb_height = 0;
699
700     if( p_btnPlay )  XDestroyImage( p_btnPlay );
701     if( p_btnPause ) XDestroyImage( p_btnPause );
702     if( p_btnStop )  XDestroyImage( p_btnStop );
703     if( p_timeline ) XDestroyImage( p_timeline );
704     if( p_btnTime )  XDestroyImage( p_btnTime );
705     if( p_btnFullscreen ) XDestroyImage( p_btnFullscreen );
706     if( p_btnMute )  XDestroyImage( p_btnMute );
707     if( p_btnUnmute ) XDestroyImage( p_btnUnmute );
708
709     p_btnPlay = NULL;
710     p_btnPause = NULL;
711     p_btnStop = NULL;
712     p_timeline = NULL;
713     p_btnTime = NULL;
714     p_btnFullscreen = NULL;
715     p_btnMute = NULL;
716     p_btnUnmute = NULL;
717
718     /* reset panels position and size */
719     /* XXX  use i_width */
720     XResizeWindow( p_display, video, window.width, window.height );
721     XMoveWindow( p_display, control, 0, window.height-1 );
722     XResizeWindow( p_display, control, window.width, 1 );
723
724     b_toolbar = 0; /* says toolbar is now hidden */
725     redrawToolbar();
726 }
727
728 void VlcPlugin::redrawToolbar()
729 {
730     libvlc_exception_t ex;
731     int is_playing = 0;
732     bool b_mute = false;
733     unsigned int dst_x, dst_y;
734     GC gc;
735     XGCValues gcv;
736     unsigned int i_tb_width, i_tb_height;
737
738     /* This method does nothing if toolbar is hidden. */
739     if( !b_toolbar )
740         return;
741
742     const NPWindow& window = getWindow();
743     Window control = getControlWindow();
744     Display *p_display = ((NPSetWindowCallbackStruct *)window.ws_info)->display;
745
746     getToolbarSize( &i_tb_width, &i_tb_height );
747
748     libvlc_exception_init( &ex );
749
750     /* get mute info */
751     b_mute = libvlc_audio_get_mute( getVLC() );
752
753     gcv.foreground = BlackPixel( p_display, 0 );
754     gc = XCreateGC( p_display, control, GCForeground, &gcv );
755
756     XFillRectangle( p_display, control, gc,
757                     0, 0, window.width, i_tb_height );
758     gcv.foreground = WhitePixel( p_display, 0 );
759     XChangeGC( p_display, gc, GCForeground, &gcv );
760
761     /* position icons */
762     dst_x = BTN_SPACE;
763     dst_y = i_tb_height >> 1; /* baseline = vertical middle */
764
765     if( p_btnPause && (is_playing == 1) )
766     {
767         XPutImage( p_display, control, gc, p_btnPause, 0, 0, dst_x,
768                    dst_y - (p_btnPause->height >> 1),
769                    p_btnPause->width, p_btnPause->height );
770         dst_x += BTN_SPACE + p_btnPause->width;
771     }
772     else if( p_btnPlay )
773     {
774         XPutImage( p_display, control, gc, p_btnPlay, 0, 0, dst_x,
775                    dst_y - (p_btnPlay->height >> 1),
776                    p_btnPlay->width, p_btnPlay->height );
777         dst_x += BTN_SPACE + p_btnPlay->width;
778     }
779
780     if( p_btnStop )
781         XPutImage( p_display, control, gc, p_btnStop, 0, 0, dst_x,
782                    dst_y - (p_btnStop->height >> 1),
783                    p_btnStop->width, p_btnStop->height );
784
785     dst_x += BTN_SPACE + ( p_btnStop ? p_btnStop->width : 0 );
786
787     if( p_btnFullscreen )
788         XPutImage( p_display, control, gc, p_btnFullscreen, 0, 0, dst_x,
789                    dst_y - (p_btnFullscreen->height >> 1),
790                    p_btnFullscreen->width, p_btnFullscreen->height );
791
792     dst_x += BTN_SPACE + ( p_btnFullscreen ? p_btnFullscreen->width : 0 );
793
794     if( p_btnUnmute && b_mute )
795     {
796         XPutImage( p_display, control, gc, p_btnUnmute, 0, 0, dst_x,
797                    dst_y - (p_btnUnmute->height >> 1),
798                    p_btnUnmute->width, p_btnUnmute->height );
799
800         dst_x += BTN_SPACE + ( p_btnUnmute ? p_btnUnmute->width : 0 );
801     }
802     else if( p_btnMute )
803     {
804         XPutImage( p_display, control, gc, p_btnMute, 0, 0, dst_x,
805                    dst_y - (p_btnMute->height >> 1),
806                    p_btnMute->width, p_btnMute->height );
807
808         dst_x += BTN_SPACE + ( p_btnMute ? p_btnMute->width : 0 );
809     }
810
811     if( p_timeline )
812         XPutImage( p_display, control, gc, p_timeline, 0, 0, dst_x,
813                    dst_y - (p_timeline->height >> 1),
814                    (window.width-(dst_x+BTN_SPACE)), p_timeline->height );
815
816     /* get movie position in % */
817     if( playlist_isplaying(&ex) )
818     {
819         i_last_position = (int)((window.width-(dst_x+BTN_SPACE))*
820                    libvlc_media_player_get_position(libvlc_media_player,&ex));
821     }
822     libvlc_exception_clear( &ex );
823
824     if( p_btnTime )
825         XPutImage( p_display, control, gc, p_btnTime,
826                    0, 0, (dst_x+i_last_position),
827                    dst_y - (p_btnTime->height >> 1),
828                    p_btnTime->width, p_btnTime->height );
829
830     XFreeGC( p_display, gc );
831 }
832
833 vlc_toolbar_clicked_t VlcPlugin::getToolbarButtonClicked( int i_xpos, int i_ypos )
834 {
835     unsigned int i_dest = BTN_SPACE;
836     int is_playing = 0;
837     bool b_mute = false;
838     libvlc_exception_t ex;
839
840 #ifndef NDEBUG
841     fprintf( stderr, "ToolbarButtonClicked:: "
842                      "trying to match (%d,%d) (%d,%d)\n",
843              i_xpos, i_ypos, i_tb_height, i_tb_width );
844 #endif
845     if( i_ypos >= i_tb_width )
846         return clicked_Unknown;
847
848     /* Note: the order of testing is dependend on the original
849      * drawing positions of the icon buttons. Buttons are tested
850      * left to right.
851      */
852
853     /* get isplaying */
854     libvlc_exception_init( &ex );
855     is_playing = playlist_isplaying( &ex );
856     libvlc_exception_clear( &ex );
857
858     /* get mute info */
859     b_mute = libvlc_audio_get_mute( getVLC() );
860
861     /* is Pause of Play button clicked */
862     if( (is_playing != 1) &&
863         (i_xpos >= (BTN_SPACE>>1)) &&
864         (i_xpos <= i_dest + p_btnPlay->width + (BTN_SPACE>>1)) )
865         return clicked_Play;
866     else if( (i_xpos >= (BTN_SPACE>>1))  &&
867              (i_xpos <= i_dest + p_btnPause->width) )
868         return clicked_Pause;
869
870     /* is Stop button clicked */
871     if( is_playing != 1 )
872         i_dest += (p_btnPlay->width + (BTN_SPACE>>1));
873     else
874         i_dest += (p_btnPause->width + (BTN_SPACE>>1));
875
876     if( (i_xpos >= i_dest) &&
877         (i_xpos <= i_dest + p_btnStop->width + (BTN_SPACE>>1)) )
878         return clicked_Stop;
879
880     /* is Fullscreen button clicked */
881     i_dest += (p_btnStop->width + (BTN_SPACE>>1));
882     if( (i_xpos >= i_dest) &&
883         (i_xpos <= i_dest + p_btnFullscreen->width + (BTN_SPACE>>1)) )
884         return clicked_Fullscreen;
885
886     /* is Mute or Unmute button clicked */
887     i_dest += (p_btnFullscreen->width + (BTN_SPACE>>1));
888     if( !b_mute && (i_xpos >= i_dest) &&
889         (i_xpos <= i_dest + p_btnMute->width + (BTN_SPACE>>1)) )
890         return clicked_Mute;
891     else if( (i_xpos >= i_dest) &&
892              (i_xpos <= i_dest + p_btnUnmute->width + (BTN_SPACE>>1)) )
893         return clicked_Unmute;
894
895     /* is timeline clicked */
896     if( !b_mute )
897         i_dest += (p_btnMute->width + (BTN_SPACE>>1));
898     else
899         i_dest += (p_btnUnmute->width + (BTN_SPACE>>1));
900     if( (i_xpos >= i_dest) &&
901         (i_xpos <= i_dest + p_timeline->width + (BTN_SPACE>>1)) )
902         return clicked_timeline;
903
904     /* is time button clicked */
905     i_dest += (p_timeline->width + (BTN_SPACE>>1));
906     if( (i_xpos >= i_dest) &&
907         (i_xpos <= i_dest + p_btnTime->width + (BTN_SPACE>>1)) )
908         return clicked_Time;
909
910     return clicked_Unknown;
911 }
912 #undef BTN_SPACE
913 #endif