vlcplugin_gtk.cpp 19.9 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
#include "vlcplugin_gtk.h"
#include <gdk/gdkx.h>
26
#include <gdk/gdkkeysyms.h>
27 28
#include <cstring>

Cheng Sun's avatar
Cheng Sun committed
29 30
static uint32_t get_xid(GtkWidget *widget)
{
31 32 33 34 35 36 37 38
    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),
39 40
    video_container(NULL),
    toolbar(NULL),
41 42
    time_slider(NULL),
    vol_slider(NULL),
43
    fullscreen_win(NULL),
44
    is_fullscreen(false),
45 46 47
    is_toolbar_visible(false),
    time_slider_timeout_id(0),
    vol_slider_timeout_id(0)
48
{
49
    memset(&video_xwindow, 0, sizeof(Window));
50 51 52 53 54 55
    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");
    }
56 57 58 59 60 61 62 63
}

VlcPluginGtk::~VlcPluginGtk()
{
}

void VlcPluginGtk::set_player_window()
{
64
    libvlc_media_player_set_xwindow(get_player().get_mp(),
65
                                    video_xwindow);
66
    libvlc_video_set_mouse_input(get_player().get_mp(), 0);
67 68 69 70
}

void VlcPluginGtk::toggle_fullscreen()
{
71
    set_fullscreen(!get_fullscreen());
72 73
}

74
void VlcPluginGtk::do_set_fullscreen(bool yes)
75
{
76 77 78 79 80
    /* 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
81 82
    XUnmapWindow(display, video_xwindow);
    XReparentWindow(display, video_xwindow,
83
                    gdk_x11_get_default_root_xwindow(), 0, 0);
Cheng Sun's avatar
Cheng Sun committed
84
    if (yes) {
85 86 87 88 89
        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);
90 91 92
        gtk_window_fullscreen(GTK_WINDOW(fullscreen_win));
    } else {
        gtk_widget_hide(fullscreen_win);
93 94 95 96
        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));
97 98
        gtk_widget_show_all(GTK_WIDGET(parent));
    }
99
    XSync(get_display(), false);
100
    XReparentWindow(display, video_xwindow, get_xid(video_container), 0, 0);
Cheng Sun's avatar
Cheng Sun committed
101

102 103
//    libvlc_set_fullscreen(libvlc_media_player, yes);
    g_signal_handler_unblock(video_container, video_container_size_handler_id);
104 105
    gtk_widget_queue_resize(video_container);
    update_controls();
106 107

    is_fullscreen = yes;
108 109
}

110 111
void VlcPluginGtk::set_fullscreen(int yes)
{
112
    if (!get_options().get_enable_fs()) return;
113 114 115 116 117 118 119 120 121
    if (yes == is_fullscreen) return;
    if (yes) {
        gtk_widget_show(fullscreen_win);
    } else {
        gtk_widget_hide(fullscreen_win);
    }
}

int VlcPluginGtk::get_fullscreen()
122
{
123
    return is_fullscreen;
124 125
}

126
void VlcPluginGtk::set_toolbar_visible(bool yes)
127
{
128 129 130 131 132 133 134 135 136 137 138 139
    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);
    }
140 141
    resize_windows();
    gtk_container_resize_children(GTK_CONTAINER(parent));
142
    is_toolbar_visible = yes;
143 144
}

145
bool VlcPluginGtk::get_toolbar_visible()
146
{
147
    return is_toolbar_visible;
148 149
}

150 151 152 153 154
void VlcPluginGtk::resize_video_xwindow(GdkRectangle *rect)
{
    Display *display = get_display();
    XResizeWindow(display, video_xwindow,
                  rect->width, rect->height);
155
    XSync(display, false);
156 157
}

158 159 160 161 162 163 164 165 166 167
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},
168 169
    {"gtk-volume-unmuted", clicked_Unmute},
    {GTK_STOCK_FULLSCREEN, clicked_Fullscreen}
170 171
};

Cheng Sun's avatar
Cheng Sun committed
172
static void toolbar_handler(GtkToolButton *btn, gpointer user_data)
173
{
Cheng Sun's avatar
Cheng Sun committed
174
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
175 176 177 178 179 180 181
    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
182
    fprintf(stderr, "WARNING: No idea what toolbar button you just clicked on (%s)\n", stock_id?stock_id:"NULL");
183 184
}

185 186 187 188
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));
189 190 191 192
    if (!strcmp(stock_id, VLCPLUGINGTK_MENU_TOOLBAR)) {
        plugin->set_toolbar_visible(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)));
        return;
    }
193 194 195 196 197 198 199 200 201
    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");
}

202
void VlcPluginGtk::popup_menu()
203 204
{
    /* construct menu */
205
    GtkWidget *popupmenu = gtk_menu_new();
206 207 208 209 210 211 212 213
    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);
214
    gtk_menu_shell_append(GTK_MENU_SHELL(popupmenu), menuitem);
215 216 217 218
    /* 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);
219
    gtk_menu_shell_append(GTK_MENU_SHELL(popupmenu), menuitem);
220
    /* set fullscreen */
221
    if (get_options().get_enable_fs()) {
222 223 224 225 226
        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);
    }
227 228 229 230 231 232
    /* 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);
233

234
    /* show menu */
235
    gtk_widget_show_all(popupmenu);
236
    gtk_menu_attach_to_widget(GTK_MENU(popupmenu), video_container, NULL);
237 238
    gtk_menu_popup(GTK_MENU(popupmenu), NULL, NULL, NULL, NULL,
                   0, gtk_get_current_event_time());
239 240 241 242 243 244
}

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) {
245
        plugin->popup_menu();
246 247
        return true;
    }
248 249 250
    if (event->button == 1 && event->type == GDK_2BUTTON_PRESS) {
        plugin->toggle_fullscreen();
    }
251 252 253
    return false;
}

254 255
static bool video_popup_handler(GtkWidget *widget, gpointer user_data)
{
256
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
257
    plugin->popup_menu();
258 259 260
    return true;
}

261 262
static bool video_size_handler(GtkWidget *widget, GdkRectangle *rect, gpointer user_data)
{
263 264 265 266 267
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
    plugin->resize_video_xwindow(rect);
    return true;
}

268 269 270 271 272 273 274 275
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;

276 277 278 279 280 281 282 283 284
    int winwidth, winheight;
#   if GTK_CHECK_VERSION(2, 24, 0)
        winwidth  = gdk_window_get_width(window);
        winheight = gdk_window_get_height(window);
#   else
        gdk_drawable_get_size(GDK_DRAWABLE(window), &winwidth, &winheight);
#   endif

    int iconwidth  = gdk_pixbuf_get_width(cone_icon),
285
        iconheight = gdk_pixbuf_get_height(cone_icon);
286 287 288 289 290 291 292 293 294 295
    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);
    }

296 297 298 299 300
    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);
301
    cairo_destroy(cr);
302 303 304 305

    return true;
}

306
static gboolean do_time_slider_handler(gpointer user_data)
307
{
Cheng Sun's avatar
Cheng Sun committed
308
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
309
    libvlc_media_player_t *md = plugin->getMD();
310 311
    if (md) {
        gdouble value = gtk_range_get_value(GTK_RANGE(plugin->time_slider));
312
        libvlc_media_player_set_position(md, value/100.0);
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
    }

    plugin->time_slider_timeout_id = 0;
    return FALSE;
}

static bool time_slider_handler(GtkRange *range, GtkScrollType scroll, gdouble value, gpointer user_data)
{
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
    if (plugin->time_slider_timeout_id != 0)
        return false;

    plugin->time_slider_timeout_id = g_timeout_add(500,
                                                  do_time_slider_handler,
                                                  user_data);
328 329 330
    return false;
}

331
static gboolean do_vol_slider_handler(gpointer user_data)
332
{
Cheng Sun's avatar
Cheng Sun committed
333
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
334
    libvlc_media_player_t *md = plugin->getMD();
335 336
    if (md) {
        gdouble value = gtk_range_get_value(GTK_RANGE(plugin->vol_slider));
337
        libvlc_audio_set_volume(md, value);
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
    }

    plugin->vol_slider_timeout_id = 0;
    return FALSE;
}

static bool vol_slider_handler(GtkRange *range, GtkScrollType scroll, gdouble value, gpointer user_data)
{
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
    if (plugin->vol_slider_timeout_id != 0)
        return false;

    plugin->vol_slider_timeout_id = g_timeout_add(100,
                                                  do_vol_slider_handler,
                                                  user_data);
353
    return false;
354 355
}

356 357 358
static void fullscreen_win_visibility_handler(GtkWidget *widget, gpointer user_data)
{
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
359
    plugin->do_set_fullscreen(gtk_widget_get_visible(widget));
360 361
}

362 363 364 365 366
static gboolean fullscreen_win_keypress_handler(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
{
    VlcPluginGtk *plugin = (VlcPluginGtk *) user_data;
    switch (event->keyval)
    {
367
    case GDK_KEY_space:
368
        plugin->playlist_togglePause();
369
        return True;
370 371 372 373 374 375 376 377
    case GDK_KEY_Escape:
        plugin->set_fullscreen(false);
        return True;
    default:
        return False;
    }
}

378 379
void VlcPluginGtk::update_controls()
{
380 381
    if (get_player().is_open()) {
        libvlc_state_t state = libvlc_media_player_get_state(get_player().get_mp());
382 383 384 385
        bool is_stopped = (state == libvlc_Stopped) ||
                          (state == libvlc_Ended) ||
                          (state == libvlc_Error);
        if (is_stopped) {
386 387 388 389 390 391
            XUnmapWindow(display, video_xwindow);
        } else {
            XMapWindow(display, video_xwindow);
        }
    }

392 393 394 395 396 397 398 399 400 401 402 403 404 405
    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);
        }
406

407
        /* toolbar sensitivity */
408
        gtk_widget_set_sensitive(toolbar, get_player().is_open() );
409

410
        /* time slider */
411 412
        if (!get_player().is_open() ||
                !libvlc_media_player_is_seekable(get_player().get_mp())) {
413 414 415 416
            gtk_widget_set_sensitive(time_slider, false);
            gtk_range_set_value(GTK_RANGE(time_slider), 0);
        } else {
            gtk_widget_set_sensitive(time_slider, true);
417
            gdouble timepos = 100*libvlc_media_player_get_position(get_player().get_mp());
418 419 420 421
            if (time_slider_timeout_id == 0) {
                /* only set the time if the user is not dragging the slider */
                gtk_range_set_value(GTK_RANGE(time_slider), timepos);
            }
422
        }
423

424 425
        gtk_widget_show_all(toolbar);
    }
426 427 428 429
}

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

432
    Window socket = (Window) npwindow.window;
433
    GdkColor color_bg;
434
    gdk_color_parse(get_options().get_bg_color().c_str(), &color_bg);
435 436

    parent = gtk_plug_new(socket);
437
    gtk_widget_modify_bg(parent, GTK_STATE_NORMAL, &color_bg);
438 439 440 441
    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);
442 443 444 445

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

446
    video_container = gtk_drawing_area_new();
447
    gtk_widget_modify_bg(video_container, GTK_STATE_NORMAL, &color_bg);
448
    gtk_widget_add_events(video_container,
449 450
            GDK_BUTTON_PRESS_MASK
          | GDK_BUTTON_RELEASE_MASK);
451
    g_signal_connect(G_OBJECT(video_container), "expose-event", G_CALLBACK(video_expose_handler), this);
452 453 454
    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);
455 456 457

    gtk_widget_show_all(parent);

458 459
    /* fullscreen top-level */
    fullscreen_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
460
    gtk_widget_modify_bg(fullscreen_win, GTK_STATE_NORMAL, &color_bg);
461 462 463 464
    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);
465
    g_signal_connect(G_OBJECT(fullscreen_win), "key_press_event", G_CALLBACK(fullscreen_win_keypress_handler), this);
466 467 468 469 470 471

    /* 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();
472 473 474 475 476
    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);
477 478
    video_xwindow = XCreateSimpleWindow(display, get_xid(video_container), 0, 0,
                   1, 1,
479
                   0, bg_color.pixel, bg_color.pixel);
480 481 482 483 484 485

    /* 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
486 487 488

    /*** TOOLBAR ***/

489
    toolbar = gtk_toolbar_new();
490
    g_object_ref(G_OBJECT(toolbar));
491
    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
Cheng Sun's avatar
Cheng Sun committed
492
    gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
493 494 495 496 497 498 499 500 501 502 503 504 505 506
    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);
507
    gtk_range_set_increments(GTK_RANGE(time_slider), 2, 10);
508 509 510 511
    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);
512

513 514
    /* volume slider */
    toolitem = gtk_tool_item_new();
515
    vol_slider = gtk_hscale_new_with_range(0, 200, 10);
516
    gtk_range_set_increments(GTK_RANGE(vol_slider), 5, 20);
517 518 519 520 521 522 523 524
    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);

525 526 527 528 529 530 531 532 533
    return true;
}

bool VlcPluginGtk::resize_windows()
{
    GtkRequisition req;
    req.width = npwindow.width;
    req.height = npwindow.height;
    gtk_widget_size_request(parent, &req);
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
534
    return true;
535 536 537 538
}

bool VlcPluginGtk::destroy_windows()
{
539
    Display *display = get_display();
540 541 542 543

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

544 545 546 547
    /* destroy GTK top-levels */
    gtk_widget_destroy(parent);
    gtk_widget_destroy(fullscreen_win);

548
    /* free colors */
549 550
    Colormap colormap = DefaultColormap(display, DefaultScreen(display));
    XFreeColors(display, colormap, &bg_color.pixel, 1, 0);
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
551
    return true;
552
}