interface.cpp

video linux conference

                      wxBitmap( fast_xpm ), wxU(_(HELP_FAST)) );
    toolbar->AddTool( NextStream_Event, wxT(""), wxBitmap( next_xpm ),
                      wxU(_(HELP_PLN)) );
    toolbar->AddSeparator();
    toolbar->AddTool( Playlist_Event, wxT(""), wxBitmap( playlist_xpm ),
                      wxU(_(HELP_PLO)) );
    }

    wxControl *p_dummy_ctrl =
        new wxControl( toolbar, -1, wxDefaultPosition,
                       wxSize(35, 16 ), wxBORDER_NONE );

    toolbar->AddControl( p_dummy_ctrl );

    volctrl = new VLCVolCtrl( p_intf, toolbar );
    toolbar->AddControl( volctrl );

    toolbar->Realize();

#if wxUSE_DRAG_AND_DROP
    /* Associate drop targets with the toolbar */
    toolbar->SetDropTarget( new DragAndDrop( p_intf ) );
#endif
}

void Interface::CreateOurSlider()
{
    /* Create a new frame and sizer containing the slider */
    slider_frame = new wxPanel( this, -1, wxDefaultPosition, wxDefaultSize );
    slider_frame->SetAutoLayout( TRUE );
    slider_sizer = new wxBoxSizer( wxHORIZONTAL );
    //slider_sizer->SetMinSize( -1, 50 );

    /* Create slider */
    slider = new wxSlider( slider_frame, SliderScroll_Event, 0, 0,
                           SLIDER_MAX_POS, wxDefaultPosition, wxDefaultSize );

    /* Add Disc Buttons */
    disc_frame = new wxPanel( slider_frame, -1, wxDefaultPosition,
                              wxDefaultSize );
    disc_frame->SetAutoLayout( TRUE );
    disc_sizer = new wxBoxSizer( wxHORIZONTAL );

    disc_menu_button = new wxBitmapButton( disc_frame, DiscMenu_Event,
                                           wxBitmap( playlist_xpm ) );
    disc_prev_button = new wxBitmapButton( disc_frame, DiscPrev_Event,
                                           wxBitmap( prev_xpm ) );
    disc_next_button = new wxBitmapButton( disc_frame, DiscNext_Event,
                                           wxBitmap( next_xpm ) );

    disc_sizer->Add( disc_menu_button, 1, wxEXPAND | wxLEFT | wxRIGHT, 1 );
    disc_sizer->Add( disc_prev_button, 1, wxEXPAND | wxLEFT | wxRIGHT, 1 );
    disc_sizer->Add( disc_next_button, 1, wxEXPAND | wxLEFT | wxRIGHT, 1 );

    disc_frame->SetSizer( disc_sizer );
    disc_sizer->Layout();

    /* Add everything to the frame */
    slider_sizer->Add( slider, 1, wxEXPAND | wxALL, 5 );
    slider_sizer->Add( disc_frame, 0, wxALL, 2 );
    slider_frame->SetSizer( slider_sizer );

    disc_frame->Hide();
    slider_sizer->Hide( disc_frame );

    slider_sizer->Layout();
    slider_sizer->Fit( slider_frame );

    /* Hide the slider by default */
    slider_frame->Hide();
}

static int ConvertHotkeyModifiers( int i_hotkey )
{
    int i_accel_flags = 0;
    if( i_hotkey & KEY_MODIFIER_ALT ) i_accel_flags |= wxACCEL_ALT;
    if( i_hotkey & KEY_MODIFIER_CTRL ) i_accel_flags |= wxACCEL_CTRL;
    if( i_hotkey & KEY_MODIFIER_SHIFT ) i_accel_flags |= wxACCEL_SHIFT;
    if( !i_accel_flags ) i_accel_flags = wxACCEL_NORMAL;
    return i_accel_flags;
}

static int ConvertHotkey( int i_hotkey )
{
    int i_key = i_hotkey & ~KEY_MODIFIER;
    if( i_key & KEY_ASCII ) return i_key & KEY_ASCII;
    else if( i_key & KEY_SPECIAL )
    {
        switch ( i_key )
        {
        case KEY_LEFT: return WXK_LEFT;
        case KEY_RIGHT: return WXK_RIGHT;
        case KEY_UP: return WXK_UP;
        case KEY_DOWN: return WXK_DOWN;
        case KEY_SPACE: return WXK_SPACE;
        case KEY_ENTER: return WXK_RETURN;
        case KEY_F1: return WXK_F1;
        case KEY_F2: return WXK_F2;
        case KEY_F3: return WXK_F3;
        case KEY_F4: return WXK_F4;
        case KEY_F5: return WXK_F5;
        case KEY_F6: return WXK_F6;
        case KEY_F7: return WXK_F7;
        case KEY_F8: return WXK_F8;
        case KEY_F9: return WXK_F9;
        case KEY_F10: return WXK_F10;
        case KEY_F11: return WXK_F11;
        case KEY_F12: return WXK_F12;
        case KEY_HOME: return WXK_HOME;
        case KEY_END: return WXK_END;
        case KEY_INSERT: return WXK_INSERT;
        case KEY_DELETE: return WXK_DELETE;
        case KEY_MENU: return WXK_MENU;
        case KEY_ESC: return WXK_ESCAPE;
        case KEY_PAGEUP: return WXK_PRIOR;
        case KEY_PAGEDOWN: return WXK_NEXT;
        case KEY_TAB: return WXK_TAB;
        case KEY_BACKSPACE: return WXK_BACK;
        }
    }
    return WXK_F24;
}

void Interface::SetupHotkeys()
{
    struct vlc_t::hotkey *p_hotkeys = p_intf->p_vlc->p_hotkeys;
    int i_hotkeys;

    /* Count number of hoteys */
    for( i_hotkeys = 0; p_hotkeys[i_hotkeys].psz_action != NULL; i_hotkeys++ );

    p_intf->p_sys->i_first_hotkey_event = wxID_HIGHEST + 7000;
    p_intf->p_sys->i_hotkeys = i_hotkeys;

    wxAcceleratorEntry *p_entries = new wxAcceleratorEntry[i_hotkeys];

    /* Setup the hotkeys as accelerators */
    for( int i = 0; i < i_hotkeys; i++ )
    {
        int i_mod = ConvertHotkeyModifiers( p_hotkeys[i].i_key );
        int i_key = ConvertHotkey( p_hotkeys[i].i_key );

#ifdef WIN32
        if( !(p_hotkeys[i].i_key & KEY_SPECIAL) && i_mod )
            i_key = toupper(i_key);
#endif

        p_entries[i].Set( i_mod, i_key,
                          p_intf->p_sys->i_first_hotkey_event + i );
    }

    wxAcceleratorTable accel( i_hotkeys, p_entries );

    if( !accel.Ok() )
    {
        msg_Err( p_intf, "invalid accelerator table" );
    }
    else
    {
        SetAcceleratorTable( accel );
    }

    delete [] p_entries;
}

void Interface::HideSlider( bool layout )
{
    ShowSlider( false, layout );
}

void Interface::ShowSlider( bool show, bool layout )
{
    if( show )
    {
        //prevent the hide timers from hiding it now
        m_slider_timer.Stop();
        m_controls_timer.Stop();

        //prevent continuous layout
        if( slider_frame->IsShown() ) return;
    }
    else
    {
        //prevent continuous layout
        if( !slider_frame->IsShown() ) return;
    }

    if( layout && p_intf->p_sys->b_video_autosize )
        UpdateVideoWindow( p_intf, video_window );

    slider_frame->Show( show );
    frame_sizer->Show( slider_frame, show );

    if( layout )
    {
        frame_sizer->Layout();
        if( p_intf->p_sys->b_video_autosize ) frame_sizer->Fit( this );
    }
}

void Interface::HideDiscFrame( bool layout )
{
    ShowDiscFrame( false, layout );
}

void Interface::ShowDiscFrame( bool show, bool layout )
{
    if( show )
    {
        //prevent the hide timer from hiding it now
        m_controls_timer.Stop();

        //prevent continuous layout
        if( disc_frame->IsShown() ) return;
    }
    else
    {
        //prevent continuous layout
        if( !disc_frame->IsShown() ) return;
    }

    if( layout && p_intf->p_sys->b_video_autosize )
        UpdateVideoWindow( p_intf, video_window );

    disc_frame->Show( show );
    slider_sizer->Show( disc_frame, show );

    if( layout )
    {
        slider_sizer->Layout();
        if( p_intf->p_sys->b_video_autosize )
            slider_sizer->Fit( slider_frame );
    }
}

/*****************************************************************************
 * Event Handlers.
 *****************************************************************************/
void Interface::OnControlsTimer( wxTimerEvent& WXUNUSED(event) )
{
    if( p_intf->p_sys->b_video_autosize )
        UpdateVideoWindow( p_intf, video_window );

    /* Hide slider and Disc Buttons */
    //postpone layout, we'll do it ourselves
    HideDiscFrame( false );
    HideSlider( false );

    slider_sizer->Layout();
    if( p_intf->p_sys->b_video_autosize )
    {
        slider_sizer->Fit( slider_frame );
        frame_sizer->Fit( this );
    }
}

void Interface::OnSliderTimer( wxTimerEvent& WXUNUSED(event) )
{
    HideSlider();
}

void Interface::OnMenuOpen( wxMenuEvent& event )
{
#if defined( __WXMSW__ )
#   define GetEventObject GetMenu
#endif

    if( event.GetEventObject() == p_settings_menu )
    {
        p_settings_menu = SettingsMenu( p_intf, this, p_settings_menu );

        /* Add static items */
        p_settings_menu->AppendCheckItem( Extended_Event,
            wxU(_("Extended &GUI\tCtrl-G") ) );
        if( b_extra ) p_settings_menu->Check( Extended_Event, TRUE );
#if 0
        p_settings_menu->AppendCheckItem( Undock_Event,
            wxU(_("&Undock Ext. GUI") ) );
        if( b_undock ) p_settings_menu->Check( Undock_Event, TRUE );
#endif
        p_settings_menu->Append( Bookmarks_Event,
                                 wxU(_("&Bookmarks...\tCtrl-B") ) );
        p_settings_menu->Append( Prefs_Event,
                                 wxU(_("Preference&s...\tCtrl-S")) );
    }

    else if( event.GetEventObject() == p_audio_menu )
    {
        p_audio_menu = AudioMenu( p_intf, this, p_audio_menu );
    }

    else if( event.GetEventObject() == p_video_menu )
    {
        p_video_menu = VideoMenu( p_intf, this, p_video_menu );
    }

    else if( event.GetEventObject() == p_navig_menu )
    {
        p_navig_menu = NavigMenu( p_intf, this, p_navig_menu );
    }

#if defined( __WXMSW__ )
#   undef GetEventObject
#endif
}

#if defined( __WXMSW__ ) || defined( __WXMAC__ )
void Interface::OnContextMenu2(wxContextMenuEvent& event)
{
    /* Only show the context menu for the main interface */
    if( GetId() != event.GetId() )
    {
        event.Skip();
        return;
    }

    if( p_intf->p_sys->pf_show_dialog )
        p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_POPUPMENU, 1, 0 );
}
#endif
void Interface::OnContextMenu(wxMouseEvent& event)
{
    if( p_intf->p_sys->pf_show_dialog )
        p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_POPUPMENU, 1, 0 );
}

void Interface::OnExit( wxCommandEvent& WXUNUSED(event) )
{
    /* TRUE is to force the frame to close. */
    Close(TRUE);
}

void Interface::OnAbout( wxCommandEvent& WXUNUSED(event) )
{
    wxString msg;
    msg.Printf( wxString(wxT("VLC media player " PACKAGE_VERSION)) +
        wxU(_(" (wxWindows interface)\n\n")) +
        wxU(_("(c) 1996-2005 - the VideoLAN Team\n\n")) +
        wxU( INTF_ABOUT_MSG ) + wxT("\n\n") +
        wxU(_("The VideoLAN team <[e-mail]>\n"
              "http://www.videolan.org/\n\n")) );

    wxMessageBox( msg, wxString::Format(wxU(_("About %s")),
                  wxT("VLC media player")), wxOK | wxICON_INFORMATION, this );
}

void Interface::OnShowDialog( wxCommandEvent& event )
{
    if( p_intf->p_sys->pf_show_dialog )
    {
        int i_id;

        switch( event.GetId() )
        {
        case OpenFileSimple_Event:
            i_id = INTF_DIALOG_FILE_SIMPLE;
            break;
        case OpenAdv_Event:
            i_id = INTF_DIALOG_FILE;
        case OpenFile_Event:
            i_id = INTF_DIALOG_FILE;
            break;
        case OpenDir_Event:
            i_id = INTF_DIALOG_DIRECTORY;
            break;
        case OpenDisc_Event:
            i_id = INTF_DIALOG_DISC;
            break;
        case OpenNet_Event:
            i_id = INTF_DIALOG_NET;
            break;
        case OpenCapture_Event:
            i_id = INTF_DIALOG_CAPTURE;
            break;
        case OpenSat_Event:
            i_id = INTF_DIALOG_SAT;
            break;
        case Playlist_Event:
            i_id = INTF_DIALOG_PLAYLIST;
            break;
        case Logs_Event:
            i_id = INTF_DIALOG_MESSAGES;
            break;
        case FileInfo_Event:
            i_id = INTF_DIALOG_FILEINFO;
            break;
        case Prefs_Event:
            i_id = INTF_DIALOG_PREFS;
            break;
        case Wizard_Event:
            i_id = INTF_DIALOG_WIZARD;
            break;
        case Bookmarks_Event:
            i_id = INTF_DIALOG_BOOKMARKS;
            break;
        default:
            i_id = INTF_DIALOG_FILE;
            break;
        }

        p_intf->p_sys->pf_show_dialog( p_intf, i_id, 1, 0 );
    }
}

void Interface::OnExtended(wxCommandEvent& event)
{
    b_extra = (b_extra == VLC_TRUE ? VLC_FALSE : VLC_TRUE );

    if( b_extra == VLC_FALSE )
    {
        extra_frame->Hide();
        frame_sizer->Hide( extra_frame );
    }
    else
    {
        extra_frame->Show();
        frame_sizer->Show( extra_frame );
    }
    frame_sizer->Layout();
    frame_sizer->Fit(this);
}

#if 0
        if( b_undock == VLC_TRUE )
        {
                fprintf(stderr,"Deleting window\n");
            if( extra_window )
            {
                delete extra_window;
                extra_window = NULL;
            }
        }
        else
        {
            extra_frame->Hide();
            frame_sizer->Hide( extra_frame );
            frame_sizer->Layout();
            frame_sizer->Fit(this);
        }
    }
    else
    {
        if( b_undock == VLC_TRUE )
        {
                fprintf(stderr,"Creating window\n");
            extra_frame->Hide();
            frame_sizer->Hide( extra_frame );
#if (wxCHECK_VERSION(2,5,0))
            frame_sizer->Detach( extra_frame );
#else
            frame_sizer->Remove( extra_frame );
#endif
            frame_sizer->Layout();
            frame_sizer->Fit(this);
            extra_window = new ExtraWindow( p_intf, this, extra_frame );
        }
        else
        {
                fprintf(stderr,"Deleting window\n");
            if( extra_window )
            {
                delete extra_window;
            }
            extra_frame->Show();
            frame_sizer->Show( extra_frame );
            frame_sizer->Layout();
            frame_sizer->Fit(this);
        }
    }
}

void Interface::OnUndock(wxCommandEvent& event)
{
    b_undock = (b_undock == VLC_TRUE ? VLC_FALSE : VLC_TRUE );

    if( b_extra == VLC_TRUE )
    {
        if( b_undock == VLC_FALSE )
        {
                fprintf(stderr,"Deleting window\n");
            if( extra_window )
            {
                delete extra_window;
                extra_window = NULL;
            }
            extra_frame->Show();
            frame_sizer->Show( extra_frame );
            frame_sizer->Layout();
            frame_sizer->Fit(this);
        }
        else
        {
                fprintf(stderr,"Creating window\n");
            extra_frame->Hide();
            frame_sizer->Hide( extra_frame );
#if (wxCHECK_VERSION(2,5,0))
            frame_sizer->Detach( extra_frame );
#else
            frame_sizer->Remove( extra_frame );
#endif
            frame_sizer->Layout();
            frame_sizer->Fit(this);
            extra_window = new ExtraWindow( p_intf, this, extra_frame );
        }
    }
}
#endif


void Interface::OnPlayStream( wxCommandEvent& WXUNUSED(event) )
{
    PlayStream();
}

void Interface::PlayStream()
{
    wxCommandEvent dummy;
    playlist_t *p_playlist =
        (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
                                       FIND_ANYWHERE );