vlcplugin_gtk.cpp 19.4 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
    video_container(NULL),
    toolbar(NULL),
40 41
    time_slider(NULL),
    vol_slider(NULL),
42
    fullscreen_win(NULL),
43
    is_fullscreen(false),
44 45 46
    is_toolbar_visible(false),
    time_slider_timeout_id(0),
    vol_slider_timeout_id(0)
47
{
48
    memset(&video_xwindow, 0, sizeof(Window));
49 50 51 52 53 54
    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");
    }
55 56 57 58 59 60 61 62
}

VlcPluginGtk::~VlcPluginGtk()
{
}

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

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

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

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

    is_fullscreen = yes;
107 108
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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;

275 276 277 278 279 280 281 282 283
    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),
284
        iconheight = gdk_pixbuf_get_height(cone_icon);
285 286 287 288 289 290 291 292 293 294
    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);
    }

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

    return true;
}

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

    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);
327 328 329
    return false;
}

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

    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);
352
    return false;
353 354
}

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

361 362
void VlcPluginGtk::update_controls()
{
363 364
    if (get_player().is_open()) {
        libvlc_state_t state = libvlc_media_player_get_state(get_player().get_mp());
365 366 367 368
        bool is_stopped = (state == libvlc_Stopped) ||
                          (state == libvlc_Ended) ||
                          (state == libvlc_Error);
        if (is_stopped) {
369 370 371 372 373 374
            XUnmapWindow(display, video_xwindow);
        } else {
            XMapWindow(display, video_xwindow);
        }
    }

375 376 377 378 379 380 381 382 383 384 385 386 387 388
    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);
        }
389

390
        /* toolbar sensitivity */
391
        gtk_widget_set_sensitive(toolbar, get_player().is_open() );
392

393
        /* time slider */
394 395
        if (!get_player().is_open() ||
                !libvlc_media_player_is_seekable(get_player().get_mp())) {
396 397 398 399
            gtk_widget_set_sensitive(time_slider, false);
            gtk_range_set_value(GTK_RANGE(time_slider), 0);
        } else {
            gtk_widget_set_sensitive(time_slider, true);
400
            gdouble timepos = 100*libvlc_media_player_get_position(get_player().get_mp());
401 402 403 404
            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);
            }
405
        }
406

407 408
        gtk_widget_show_all(toolbar);
    }
409 410 411 412
}

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

415
    Window socket = (Window) npwindow.window;
416
    GdkColor color_bg;
417
    gdk_color_parse(get_options().get_bg_color().c_str(), &color_bg);
418 419

    parent = gtk_plug_new(socket);
420
    gtk_widget_modify_bg(parent, GTK_STATE_NORMAL, &color_bg);
421 422 423 424
    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);
425 426 427 428

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

429
    video_container = gtk_drawing_area_new();
430
    gtk_widget_modify_bg(video_container, GTK_STATE_NORMAL, &color_bg);
431
    gtk_widget_add_events(video_container,
432 433
            GDK_BUTTON_PRESS_MASK
          | GDK_BUTTON_RELEASE_MASK);
434
    g_signal_connect(G_OBJECT(video_container), "expose-event", G_CALLBACK(video_expose_handler), this);
435 436 437
    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);
438 439 440

    gtk_widget_show_all(parent);

441 442
    /* fullscreen top-level */
    fullscreen_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
443
    gtk_widget_modify_bg(fullscreen_win, GTK_STATE_NORMAL, &color_bg);
444 445 446 447 448 449 450 451 452 453
    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();
454 455 456 457 458
    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);
459 460
    video_xwindow = XCreateSimpleWindow(display, get_xid(video_container), 0, 0,
                   1, 1,
461
                   0, bg_color.pixel, bg_color.pixel);
462 463 464 465 466 467

    /* 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
468 469 470

    /*** TOOLBAR ***/

471
    toolbar = gtk_toolbar_new();
472
    g_object_ref(G_OBJECT(toolbar));
473
    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
Cheng Sun's avatar
Cheng Sun committed
474
    gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
475 476 477 478 479 480 481 482 483 484 485 486 487 488
    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);
489
    gtk_range_set_increments(GTK_RANGE(time_slider), 2, 10);
490 491 492 493
    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);
494

495 496
    /* volume slider */
    toolitem = gtk_tool_item_new();
497
    vol_slider = gtk_hscale_new_with_range(0, 200, 10);
498
    gtk_range_set_increments(GTK_RANGE(vol_slider), 5, 20);
499 500 501 502 503 504 505 506
    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);

507 508 509 510 511 512 513 514 515
    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
516
    return true;
517 518 519 520
}

bool VlcPluginGtk::destroy_windows()
{
521
    Display *display = get_display();
522 523 524 525

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

526 527 528 529
    /* destroy GTK top-levels */
    gtk_widget_destroy(parent);
    gtk_widget_destroy(fullscreen_win);

530
    /* free colors */
531 532
    Colormap colormap = DefaultColormap(display, DefaultScreen(display));
    XFreeColors(display, colormap, &bg_color.pixel, 1, 0);
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
533
    return true;
534
}