vlcplugin_gtk.cpp 17.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*****************************************************************************
 * vlcplugin_gtk.cpp: a VLC plugin for Mozilla (GTK+ interface)
 *****************************************************************************
 * Copyright (C) 2002-2010 the VideoLAN team
 * $Id$
 *
 * Authors: Cheng Sun <chengsun9@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

24 25 26 27
#include "vlcplugin_gtk.h"
#include <gdk/gdkx.h>
#include <cstring>

Cheng Sun's avatar
Cheng Sun committed
28 29
static uint32_t get_xid(GtkWidget *widget)
{
30 31 32 33 34 35 36 37
    GdkDrawable *video_drawable = gtk_widget_get_window(widget);
    return (uint32_t)gdk_x11_drawable_get_xid(video_drawable);
}

VlcPluginGtk::VlcPluginGtk(NPP instance, NPuint16_t mode) :
    VlcPluginBase(instance, mode),
    parent(NULL),
    parent_vbox(NULL),
38 39 40
    video_container(NULL),
    toolbar(NULL),
    fullscreen_win(NULL),
41 42
    is_fullscreen(false),
    is_toolbar_visible(false)
43
{
44
    memset(&video_xwindow, 0, sizeof(Window));
45 46 47 48 49 50
    GtkIconTheme *icon_theme = gtk_icon_theme_get_default();
    cone_icon = gdk_pixbuf_copy(gtk_icon_theme_load_icon(
                    icon_theme, "vlc", 128, GTK_ICON_LOOKUP_FORCE_SIZE, NULL));
    if (!cone_icon) {
        fprintf(stderr, "WARNING: could not load VLC icon\n");
    }
51 52 53 54 55 56 57 58 59
}

VlcPluginGtk::~VlcPluginGtk()
{
}

void VlcPluginGtk::set_player_window()
{
    libvlc_media_player_set_xwindow(libvlc_media_player,
60
                                    video_xwindow);
61
    libvlc_video_set_mouse_input(libvlc_media_player, 0);
62 63 64 65
}

void VlcPluginGtk::toggle_fullscreen()
{
66
    set_fullscreen(!get_fullscreen());
67 68
}

69
void VlcPluginGtk::do_set_fullscreen(bool yes)
70
{
71 72 73 74 75
    /* we have to reparent windows */
    /* note that the xid of video_container changes after reparenting */
    Display *display = get_display();
    g_signal_handler_block(video_container, video_container_size_handler_id);

Cheng Sun's avatar
Cheng Sun committed
76 77
    XUnmapWindow(display, video_xwindow);
    XReparentWindow(display, video_xwindow,
78
                    gdk_x11_get_default_root_xwindow(), 0, 0);
Cheng Sun's avatar
Cheng Sun committed
79
    if (yes) {
80 81 82 83 84
        g_object_ref(G_OBJECT(parent_vbox));
        gtk_container_remove(GTK_CONTAINER(parent), parent_vbox);
        gtk_container_add(GTK_CONTAINER(fullscreen_win), parent_vbox);
        g_object_unref(G_OBJECT(parent_vbox));
        gtk_widget_show_all(fullscreen_win);
85 86 87
        gtk_window_fullscreen(GTK_WINDOW(fullscreen_win));
    } else {
        gtk_widget_hide(fullscreen_win);
88 89 90 91
        g_object_ref(G_OBJECT(parent_vbox));
        gtk_container_remove(GTK_CONTAINER(fullscreen_win), parent_vbox);
        gtk_container_add(GTK_CONTAINER(parent), parent_vbox);
        g_object_unref(G_OBJECT(parent_vbox));
92 93
        gtk_widget_show_all(GTK_WIDGET(parent));
    }
94
    XSync(get_display(), false);
95
    XReparentWindow(display, video_xwindow, get_xid(video_container), 0, 0);
Cheng Sun's avatar
Cheng Sun committed
96

97 98
//    libvlc_set_fullscreen(libvlc_media_player, yes);
    g_signal_handler_unblock(video_container, video_container_size_handler_id);
99 100
    gtk_widget_queue_resize(video_container);
    update_controls();
101 102

    is_fullscreen = yes;
103 104
}

105 106
void VlcPluginGtk::set_fullscreen(int yes)
{
107
    if (!get_enable_fs()) return;
108 109 110 111 112 113 114 115 116
    if (yes == is_fullscreen) return;
    if (yes) {
        gtk_widget_show(fullscreen_win);
    } else {
        gtk_widget_hide(fullscreen_win);
    }
}

int VlcPluginGtk::get_fullscreen()
117
{
118
    return is_fullscreen;
119 120
}

121
void VlcPluginGtk::set_toolbar_visible(bool yes)
122
{
123 124 125 126 127 128 129 130 131 132 133 134
    if (yes == is_toolbar_visible) return;

    if (yes) {
        gtk_box_pack_start(GTK_BOX(parent_vbox), toolbar, false, false, 0);
        gtk_widget_show_all(toolbar);
        update_controls();
        g_object_unref(G_OBJECT(toolbar));
    } else {
        g_object_ref(G_OBJECT(toolbar));
        gtk_widget_hide(toolbar);
        gtk_container_remove(GTK_CONTAINER(parent_vbox), toolbar);
    }
135 136
    resize_windows();
    gtk_container_resize_children(GTK_CONTAINER(parent));
137
    is_toolbar_visible = yes;
138 139
}

140
bool VlcPluginGtk::get_toolbar_visible()
141
{
142
    return is_toolbar_visible;
143 144
}

145 146 147 148 149
void VlcPluginGtk::resize_video_xwindow(GdkRectangle *rect)
{
    Display *display = get_display();
    XResizeWindow(display, video_xwindow,
                  rect->width, rect->height);
150
    XSync(display, false);
151 152
}

153 154 155 156 157 158 159 160 161 162
struct tool_actions_t
{
    const gchar *stock_id;
    vlc_toolbar_clicked_t clicked;
};
static const tool_actions_t tool_actions[] = {
    {GTK_STOCK_MEDIA_PLAY, clicked_Play},
    {GTK_STOCK_MEDIA_PAUSE, clicked_Pause},
    {GTK_STOCK_MEDIA_STOP, clicked_Stop},
    {"gtk-volume-muted", clicked_Mute},
163 164
    {"gtk-volume-unmuted", clicked_Unmute},
    {GTK_STOCK_FULLSCREEN, clicked_Fullscreen}
165 166
};

Cheng Sun's avatar
Cheng Sun committed
167
static void toolbar_handler(GtkToolButton *btn, gpointer user_data)
168
{
Cheng Sun's avatar
Cheng Sun committed
169
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
170 171 172 173 174 175 176
    const gchar *stock_id = gtk_tool_button_get_stock_id(btn);
    for (int i = 0; i < sizeof(tool_actions)/sizeof(tool_actions_t); ++i) {
        if (!strcmp(stock_id, tool_actions[i].stock_id)) {
            plugin->control_handler(tool_actions[i].clicked);
            return;
        }
    }
Cheng Sun's avatar
Cheng Sun committed
177
    fprintf(stderr, "WARNING: No idea what toolbar button you just clicked on (%s)\n", stock_id?stock_id:"NULL");
178 179
}

180 181 182 183
static void menu_handler(GtkMenuItem *menuitem, gpointer user_data)
{
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
    const gchar *stock_id = gtk_menu_item_get_label(GTK_MENU_ITEM(menuitem));
184 185 186 187
    if (!strcmp(stock_id, VLCPLUGINGTK_MENU_TOOLBAR)) {
        plugin->set_toolbar_visible(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)));
        return;
    }
188 189 190 191 192 193 194 195 196
    for (int i = 0; i < sizeof(tool_actions)/sizeof(tool_actions_t); ++i) {
        if (!strcmp(stock_id, tool_actions[i].stock_id)) {
            plugin->control_handler(tool_actions[i].clicked);
            return;
        }
    }
    fprintf(stderr, "WARNING: No idea what menu item you just clicked on (%s)\n", stock_id?stock_id:"NULL");
}

197
void VlcPluginGtk::popup_menu()
198 199
{
    /* construct menu */
200
    GtkWidget *popupmenu = gtk_menu_new();
201 202 203 204 205 206 207 208
    GtkWidget *menuitem;

    /* play/pause */
    menuitem = gtk_image_menu_item_new_from_stock(
                        playlist_isplaying() ?
                        GTK_STOCK_MEDIA_PAUSE :
                        GTK_STOCK_MEDIA_PLAY, NULL);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(menu_handler), this);
209
    gtk_menu_shell_append(GTK_MENU_SHELL(popupmenu), menuitem);
210 211 212 213
    /* stop */
    menuitem = gtk_image_menu_item_new_from_stock(
                                GTK_STOCK_MEDIA_STOP, NULL);
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(menu_handler), this);
214
    gtk_menu_shell_append(GTK_MENU_SHELL(popupmenu), menuitem);
215
    /* set fullscreen */
216
    if (get_enable_fs()) {
217 218 219 220 221
        menuitem = gtk_image_menu_item_new_from_stock(
                                    GTK_STOCK_FULLSCREEN, NULL);
        g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(menu_handler), this);
        gtk_menu_shell_append(GTK_MENU_SHELL(popupmenu), menuitem);
    }
222 223 224 225 226 227
    /* toolbar */
    menuitem = gtk_check_menu_item_new_with_label(
                                VLCPLUGINGTK_MENU_TOOLBAR);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), get_toolbar_visible());
    g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(menu_handler), this);
    gtk_menu_shell_append(GTK_MENU_SHELL(popupmenu), menuitem);
228

229
    /* show menu */
230
    gtk_widget_show_all(popupmenu);
231
    gtk_menu_attach_to_widget(GTK_MENU(popupmenu), video_container, NULL);
232 233
    gtk_menu_popup(GTK_MENU(popupmenu), NULL, NULL, NULL, NULL,
                   0, gtk_get_current_event_time());
234 235 236 237 238 239
}

static bool video_button_handler(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
    if (event->button == 3 && event->type == GDK_BUTTON_PRESS) {
240
        plugin->popup_menu();
241 242
        return true;
    }
243 244 245
    if (event->button == 1 && event->type == GDK_2BUTTON_PRESS) {
        plugin->toggle_fullscreen();
    }
246 247 248
    return false;
}

249 250
static bool video_popup_handler(GtkWidget *widget, gpointer user_data)
{
251
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
252
    plugin->popup_menu();
253 254 255
    return true;
}

256 257
static bool video_size_handler(GtkWidget *widget, GdkRectangle *rect, gpointer user_data)
{
258 259 260 261 262
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
    plugin->resize_video_xwindow(rect);
    return true;
}

263 264 265 266 267 268 269 270 271 272 273 274
static bool video_expose_handler(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
    GdkEventExpose *event_expose = (GdkEventExpose *) event;
    GdkWindow *window = event_expose->window;
    GdkPixbuf *cone_icon = plugin->cone_icon;
    if (!cone_icon) return false;

    int winwidth   = gdk_window_get_width(window),
        winheight  = gdk_window_get_height(window),
        iconwidth  = gdk_pixbuf_get_width(cone_icon),
        iconheight = gdk_pixbuf_get_height(cone_icon);
275 276 277 278 279 280 281 282 283 284
    double widthratio  = (double) winwidth / iconwidth,
           heightratio = (double) winheight / iconheight;
    double sizeratio = widthratio < heightratio ? widthratio : heightratio;
    if (sizeratio < 1.0) {
        cone_icon = gdk_pixbuf_scale_simple(cone_icon, iconwidth * sizeratio, iconheight * sizeratio, GDK_INTERP_BILINEAR);
        if (!cone_icon) return false;
        iconwidth  = gdk_pixbuf_get_width(cone_icon);
        iconheight = gdk_pixbuf_get_height(cone_icon);
    }

285 286 287 288 289
    cairo_t *cr = gdk_cairo_create(window);
    gdk_cairo_set_source_pixbuf(cr, cone_icon,
            (winwidth-iconwidth)/2.0, (winheight-iconheight)/2.0);
    gdk_cairo_region(cr, event_expose->region);
    cairo_fill(cr);
290
    cairo_destroy(cr);
291 292 293 294

    return true;
}

Cheng Sun's avatar
Cheng Sun committed
295
static bool time_slider_handler(GtkRange *range, GtkScrollType scroll, gdouble value, gpointer user_data)
296
{
Cheng Sun's avatar
Cheng Sun committed
297
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
298 299 300
    libvlc_media_player_t *md = plugin->getMD();
    if (md)
        libvlc_media_player_set_position(md, value/100.0);
301 302 303
    return false;
}

Cheng Sun's avatar
Cheng Sun committed
304
static bool vol_slider_handler(GtkRange *range, GtkScrollType scroll, gdouble value, gpointer user_data)
305
{
Cheng Sun's avatar
Cheng Sun committed
306
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
307 308 309
    libvlc_media_player_t *md = plugin->getMD();
    if (md)
        libvlc_audio_set_volume(md, value);
310
    return false;
311 312
}

313 314 315
static void fullscreen_win_visibility_handler(GtkWidget *widget, gpointer user_data)
{
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
316
    plugin->do_set_fullscreen(gtk_widget_get_visible(widget));
317 318
}

319 320
void VlcPluginGtk::update_controls()
{
321
    if (libvlc_media_player) {
322 323 324 325 326
        libvlc_state_t state = libvlc_media_player_get_state(libvlc_media_player);
        bool is_stopped = (state == libvlc_Stopped) ||
                          (state == libvlc_Ended) ||
                          (state == libvlc_Error);
        if (is_stopped) {
327 328 329 330 331 332
            XUnmapWindow(display, video_xwindow);
        } else {
            XMapWindow(display, video_xwindow);
        }
    }

333 334 335 336 337 338 339 340 341 342 343 344 345 346
    if (get_toolbar_visible()) {
        GtkToolItem *toolbutton;

        /* play/pause button */
        const gchar *stock_id = playlist_isplaying() ? GTK_STOCK_MEDIA_PAUSE : GTK_STOCK_MEDIA_PLAY;
        toolbutton = gtk_toolbar_get_nth_item(GTK_TOOLBAR(toolbar), 0);
        if (strcmp(gtk_tool_button_get_stock_id(GTK_TOOL_BUTTON(toolbutton)), stock_id)) {
            gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(toolbutton), stock_id);
            /* work around firefox not displaying the icon properly after change */
            g_object_ref(toolbutton);
            gtk_container_remove(GTK_CONTAINER(toolbar), GTK_WIDGET(toolbutton));
            gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolbutton, 0);
            g_object_unref(toolbutton);
        }
347

348 349 350 351 352 353 354 355 356 357
        /* time slider */
        if (!libvlc_media_player ||
                !libvlc_media_player_is_seekable(libvlc_media_player)) {
            gtk_widget_set_sensitive(time_slider, false);
            gtk_range_set_value(GTK_RANGE(time_slider), 0);
        } else {
            gtk_widget_set_sensitive(time_slider, true);
            gdouble timepos = 100*libvlc_media_player_get_position(libvlc_media_player);
            gtk_range_set_value(GTK_RANGE(time_slider), timepos);
        }
358

359 360
        gtk_widget_show_all(toolbar);
    }
361 362 363 364
}

bool VlcPluginGtk::create_windows()
{
365 366
    display = ( (NPSetWindowCallbackStruct *) npwindow.ws_info )->display;

367
    Window socket = (Window) npwindow.window;
368
    GdkColor color_bg;
369
    gdk_color_parse(get_bg_color().c_str(), &color_bg);
370 371

    parent = gtk_plug_new(socket);
372
    gtk_widget_modify_bg(parent, GTK_STATE_NORMAL, &color_bg);
373 374 375 376
    gtk_widget_add_events(parent,
            GDK_BUTTON_PRESS_MASK
          | GDK_BUTTON_RELEASE_MASK);
    g_signal_connect(G_OBJECT(parent), "button-press-event", G_CALLBACK(video_button_handler), this);
377 378 379 380

    parent_vbox = gtk_vbox_new(false, 0);
    gtk_container_add(GTK_CONTAINER(parent), parent_vbox);

381
    video_container = gtk_drawing_area_new();
382
    gtk_widget_modify_bg(video_container, GTK_STATE_NORMAL, &color_bg);
383
    gtk_widget_add_events(video_container,
384 385
            GDK_BUTTON_PRESS_MASK
          | GDK_BUTTON_RELEASE_MASK);
386
    g_signal_connect(G_OBJECT(video_container), "expose-event", G_CALLBACK(video_expose_handler), this);
387 388 389
    g_signal_connect(G_OBJECT(video_container), "button-press-event", G_CALLBACK(video_button_handler), this);
    g_signal_connect(G_OBJECT(video_container), "popup-menu", G_CALLBACK(video_popup_handler), this);
    gtk_box_pack_start(GTK_BOX(parent_vbox), video_container, true, true, 0);
390 391 392

    gtk_widget_show_all(parent);

393 394
    /* fullscreen top-level */
    fullscreen_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
395
    gtk_widget_modify_bg(fullscreen_win, GTK_STATE_NORMAL, &color_bg);
396 397 398 399 400 401 402 403 404 405
    gtk_window_set_decorated(GTK_WINDOW(fullscreen_win), false);
    g_signal_connect(G_OBJECT(fullscreen_win), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), this);
    g_signal_connect(G_OBJECT(fullscreen_win), "show", G_CALLBACK(fullscreen_win_visibility_handler), this);
    g_signal_connect(G_OBJECT(fullscreen_win), "hide", G_CALLBACK(fullscreen_win_visibility_handler), this);

    /* actual video window */
    /* libvlc is handed this window's xid. A raw X window is used because
     * GTK+ is incapable of reparenting without changing xid
     */
    Display *display = get_display();
406 407 408 409 410
    Colormap colormap = DefaultColormap(display, DefaultScreen(display));
    bg_color.red   = color_bg.red;
    bg_color.green = color_bg.green;
    bg_color.blue  = color_bg.blue;
    XAllocColor(display, colormap, &bg_color);
411 412
    video_xwindow = XCreateSimpleWindow(display, get_xid(video_container), 0, 0,
                   1, 1,
413
                   0, bg_color.pixel, bg_color.pixel);
414 415 416 417 418 419

    /* connect video_container resizes to video_xwindow */
    video_container_size_handler_id = g_signal_connect(
                G_OBJECT(video_container), "size-allocate",
                G_CALLBACK(video_size_handler), this);
    gtk_widget_queue_resize_no_redraw(video_container);
Cheng Sun's avatar
Cheng Sun committed
420 421 422

    /*** TOOLBAR ***/

423
    toolbar = gtk_toolbar_new();
424
    g_object_ref(G_OBJECT(toolbar));
425
    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
Cheng Sun's avatar
Cheng Sun committed
426
    gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
    GtkToolItem *toolitem;
    /* play/pause */
    toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);
    g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(toolbar_handler), this);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
    /* stop */
    toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_STOP);
    g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(toolbar_handler), this);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);

    /* time slider */
    toolitem = gtk_tool_item_new();
    time_slider = gtk_hscale_new_with_range(0, 100, 10);
    gtk_scale_set_draw_value(GTK_SCALE(time_slider), false);
    g_signal_connect(G_OBJECT(time_slider), "change-value", G_CALLBACK(time_slider_handler), this);
    gtk_container_add(GTK_CONTAINER(toolitem), time_slider);
    gtk_tool_item_set_expand(toolitem, true);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
    
    /* volume slider */
    toolitem = gtk_tool_item_new();
    GtkWidget *vol_slider = gtk_hscale_new_with_range(0, 200, 10);
    gtk_scale_set_draw_value(GTK_SCALE(vol_slider), false);
    g_signal_connect(G_OBJECT(vol_slider), "change-value", G_CALLBACK(vol_slider_handler), this);
    gtk_range_set_value(GTK_RANGE(vol_slider), 100);
    gtk_widget_set_size_request(vol_slider, 100, -1);
    gtk_container_add(GTK_CONTAINER(toolitem), vol_slider);
    gtk_tool_item_set_expand(toolitem, false);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);

457 458 459 460 461 462 463 464 465 466 467 468 469
    return true;
}

bool VlcPluginGtk::resize_windows()
{
    GtkRequisition req;
    req.width = npwindow.width;
    req.height = npwindow.height;
    gtk_widget_size_request(parent, &req);
}

bool VlcPluginGtk::destroy_windows()
{
470
    Display *display = get_display();
471 472 473 474

    /* destroy x window */
    XDestroyWindow(display, video_xwindow);

475 476 477 478
    /* destroy GTK top-levels */
    gtk_widget_destroy(parent);
    gtk_widget_destroy(fullscreen_win);

479
    /* free colors */
480 481
    Colormap colormap = DefaultColormap(display, DefaultScreen(display));
    XFreeColors(display, colormap, &bg_color.pixel, 1, 0);
482
}