Attachment #415430 for bug #564046

View | Details | Raw Unified | Return to bug 564046 | Differences between
Collapse All | Expand All




Based on partial patch by dam.
++ b/src/ListView.h

#include <wx/scrolwin.h>
#include <wx/vlbox.h>
#include <wx/settings.h>
#include <wx/listbase.h>

class guListViewClient;
class guListViewHeader;

    size_t                  GetVisibleEnd( void ) const { return m_ListBox->GetVisibleEnd(); }
    size_t                  GetFirstVisibleLine() const { return m_ListBox->GetFirstVisibleLine(); }
    size_t                  GetLastVisibleLine() const { return m_ListBox->GetLastVisibleLine(); }
    bool                    ScrollLines( int lines ) { return m_ListBox->wxWindow::ScrollLines( lines ); }

    bool                    ScrollToLine( size_t line ) { return m_ListBox->ScrollToLine( line ); }

++ b/src/FileBrowser.cpp

#include <wx/arrimpl.cpp>
#include <wx/artprov.h>
#include <wx/clipbrd.h>
#include <wx/gtk/tglbtn.h>

WX_DEFINE_OBJARRAY(guFileItemArray);



	DirBtnSizer->Add( 0, 0, 1, wxEXPAND, 5 );

	m_ShowLibPathsBtn = new wxBitmapToggleButton( this, wxID_ANY, guImage( guIMAGE_INDEX_tiny_library ), wxDefaultPosition, wxDefaultSize, wxBU_AUTODRAW );
    m_ShowLibPathsBtn->SetToolTip( ShowPaths == guFILEBROWSER_SHOWPATH_SYSTEM ?
                          _( "See used locations" ) :
                          _( "See system files" ) );
++ b/src/FileBrowser.h

#include <wx/sizer.h>
#include <wx/string.h>
#include <wx/tglbtn.h>
#include <wx/gtk/tglbtn.h>


#define     guPANEL_FILEBROWSER_DIRCTRL             ( 1 << 0 )

    guMediaViewer *     m_MediaViewer;
    guGenericDirCtrl *  m_DirCtrl;
    bool                m_AddingFolder;
    wxBitmapToggleButton *  m_ShowLibPathsBtn;

    void                OnShowLibPathsClick( wxCommandEvent& event );

++ b/src/AuiNotebook.cpp

    m_TextFgColor = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
    m_SelTextFgColour = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );

    m_disabledCloseBmp = guImage( guIMAGE_INDEX_tiny_close_normal );
    m_activeCloseBmp = guImage( guIMAGE_INDEX_tiny_close_highlight );
}

// -------------------------------------------------------------------------------- //

wxAuiTabArt * guAuiTabArt::Clone()
{
    guAuiTabArt * art = new guAuiTabArt;
    art->SetNormalFont( m_normalFont );
    art->SetSelectedFont( m_selectedFont );
    art->SetMeasuringFont( m_measuringFont );
//    art->m_BgColor = m_BgColor;
//    art->m_SelBgColor = m_SelBgColor;
//    art->m_TextFgColor = m_TextFgColor;

    // draw background
   //wxColor top_color      = m_base_colour;
   wxColor top_color      = m_BgColor;
   wxColor bottom_color   = wxAuiStepColour( m_baseColour, 120 );
   wxRect r;

   if( m_flags & wxAUI_NB_BOTTOM )

   dc.GradientFillLinear( r, top_color, bottom_color, wxNORTH );

   // draw base lines
   dc.SetPen( m_borderPen );
   int y = rect.GetHeight();
   int w = rect.GetWidth();


    if( caption.empty() )
        caption = wxT("Xj");

    dc.SetFont(m_selectedFont);
    dc.GetTextExtent(caption, &selected_textx, &selected_texty);

    dc.SetFont(m_normalFont);
    dc.GetTextExtent(caption, &normal_textx, &normal_texty);

    // figure out the size of the tab

                                 close_button_state,
                                 x_extent);

    wxCoord tab_height = m_tabCtrlHeight - 1;
    if( !page.active )
        tab_height -= 2;
    wxCoord tab_width = tab_size.x;


    if( page.active )
    {
        dc.SetFont( m_selectedFont );
        texty = selected_texty;
    }
    else
    {
        dc.SetFont(m_normalFont);
        texty = normal_texty;
    }


//    }

    // draw tab outline
    dc.SetPen( m_borderPen );
    dc.SetBrush( * wxTRANSPARENT_BRUSH );
    dc.DrawPolygon( WXSIZEOF( border_points ), border_points );


    if( page.active )
    {
        if( m_flags & wxAUI_NB_BOTTOM )
            dc.SetPen( wxPen( wxColour( wxAuiStepColour( m_baseColour, 170 ) ) ) );
        // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
        // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
        else //for wxAUI_NB_TOP

    int close_button_width = 0;
    if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
    {
        close_button_width = m_activeCloseBmp.GetWidth();
    }



    // draw close button if necessary
    if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
    {
        wxBitmap bmp = m_disabledCloseBmp;

        if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
            close_button_state == wxAUI_BUTTON_STATE_PRESSED)
        {
            bmp = m_activeCloseBmp;
        }

        wxRect rect(tab_x + tab_width - close_button_width - 1,

// UpdateTabCtrlHeight() does the actual tab resizing. It's meant
// to be used interally
// -------------------------------------------------------------------------------- //
bool guAuiNotebook::UpdateTabCtrlHeight()
{
    // get the tab ctrl height we will use
    int height = CalculateTabCtrlHeight();

    wxAuiTabArt* art = m_tabs.GetArtProvider();

    m_tabCtrlHeight = height;

    wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
    size_t i, pane_count = all_panes.GetCount();

            continue;
        wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
        wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
        tab_frame->SetTabCtrlHeight(m_tabCtrlHeight);
        tabctrl->SetArtProvider(art->Clone());
        tab_frame->DoSizing();
    }

    return true;
}

// -------------------------------------------------------------------------------- //

            if( p )
                tabs += wxT( "," );

            if( ( int ) page_idx == m_curPage )
                tabs += wxT( "*" );
            else if( ( int ) p == tabframe->m_tabs->GetActivePage() )
                tabs += wxT( "+" );

        // create a new tab frame
        wxTabFrame * new_tabs = new wxTabFrame;
        new_tabs->m_tabs = new wxAuiTabCtrl( this,
                                    m_tabIdCounter++,
                                    wxDefaultPosition,
                                    wxDefaultSize,
                                    wxNO_BORDER | wxWANTS_CHARS );
        new_tabs->m_tabs->SetArtProvider( m_tabs.GetArtProvider()->Clone() );
        new_tabs->SetTabCtrlHeight( m_tabCtrlHeight );
        new_tabs->m_tabs->SetFlags( m_flags );
        wxAuiTabCtrl * dest_tabs = new_tabs->m_tabs;


    m_mgr.LoadPerspective( frames );

    // Force refresh of selection
    m_curPage = -1;
    SetSelection( sel_page );

    return true;
++ b/src/AuiNotebook.h


    virtual ~guAuiNotebook();

    virtual bool UpdateTabCtrlHeight();

    wxString SavePerspective( void );
 	bool LoadPerspective( const wxString &layout );
++ b/CMakeLists.txt

SET( ADD_WXSQLITE_SUPPORT 0 )
PKG_CHECK_MODULES( LIBWXSQLITE3 wxsqlite3 )
IF( NOT LIBWXSQLITE3_LIBRARIES )
	PKG_CHECK_MODULES( LIBWXSQLITE3 wxsqlite3-3.0 )
	IF( NOT LIBWXSQLITE3_LIBRARIES )
		ADD_DEFINITIONS(-DADD_WXSQLITE_SUPPORT=1)
		SET( ADD_WXSQLITE_SUPPORT 1 )
++ b/src/LastFMPanel.cpp

    if( event.GetKeyCode() == WXK_RETURN )
    {
        wxCommandEvent CmdEvent( wxEVT_COMMAND_TEXT_ENTER );
        m_ArtistTextCtrl->GetEventHandler()->AddPendingEvent( CmdEvent );
        return;
    }
    event.Skip();
++ b/src/MainApp.cpp

        if( LangInfo )
        {
            guLogError( wxT( "Could not initialize the translations engine for ( %s )" ), LangInfo->CanonicalName.c_str() );
            guLogError( wxT( "Locale directory '%s'" ), wxStandardPaths::Get().GetLocalizedResourcesDir( LangInfo->CanonicalName, wxStandardPaths::ResourceCat_Messages).c_str() );
            guLogError( wxT( "Locale directory '%s'" ), StdPaths.GetLocalizedResourcesDir( LangInfo->CanonicalName, wxStandardPaths::ResourceCat_Messages).c_str() );
        }
        else
        {
++ b/src/PLSoListBox.cpp

    if( event.GetKeyCode() == WXK_DELETE )
    {
        wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_TRACKS_DELETE );
        GetParent()->GetEventHandler()->AddPendingEvent( evt );
        return;
    }

++ b/src/StatusBar.cpp

}

// -------------------------------------------------------------------------------- //
void guStatusBar::DrawField( wxDC &dc, int i, int textHeight )
{
    wxRect rect;
    GetFieldRect( i, rect );

        dc.DrawLine( rect.x + rect.width, rect.y + 1, rect.x + rect.width, rect.y + rect.height - 1 );
    }

    DrawFieldText( dc, rect, i, textHeight );
}

// -------------------------------------------------------------------------------- //
++ b/src/TagInfo.cpp

}

// -------------------------------------------------------------------------------- //
bool guTagSetLyrics( const wxString &filename, const wxString &lyrics )
{
    guMainFrame * MainFrame = ( guMainFrame * ) wxTheApp->GetTopWindow();

++ b/src/TagInfo.h

bool        guTagSetPicture( const wxString &filename, wxImage * picture );
bool        guTagSetPicture( const wxString &filename, const wxString &imagefile );
wxString    guTagGetLyrics( const wxString &filename );
bool        guTagSetLyrics( const wxString &filename, const wxString &lyrics );
//void        guUpdateTrack( const guTrack &track, const wxImage * image, const wxString &lyrics, const int &changedflags );
void        guUpdateTracks( const guTrackArray &tracks, const guImagePtrArray &images,
                    const wxArrayString &lyrics, const wxArrayInt &changedflags );
++ b/src/PlayListAppend.cpp

int guPlayListAppend::GetSelectedPlayList( void )
{
    int Selection = m_PlayListComboBox->GetSelection();
    if( Selection == wxNOT_FOUND && m_PlayListComboBox->GetCount() != 0 )
    {
        Selection = FindPlayListItem( m_PlayListItems, m_PlayListComboBox->GetValue().Lower().Trim().Trim( false ) );
    }
++ b/src/AlbumBrowser.cpp

                        // Its a LeftUp event
                        event.SetEventType( wxEVT_LEFT_DOWN );
                        event.m_leftDown = true;
                        m_BigCoverTracksListBox->GetEventHandler()->AddPendingEvent( event );
                    }
                    return;
                }
++ b/src/AuiDockArt.cpp

#include "Images.h"
#include "Utils.h"

wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size)
{
    wxCoord x,y;

    // first check if the text fits with no problems
    dc.GetTextExtent(text, &x, &y);
    if (x <= max_size)
        return text;

    size_t i, len = text.Length();
    size_t last_good_length = 0;
    for (i = 0; i < len; ++i)
    {
        wxString s = text.Left(i);
        s += wxT("...");

        dc.GetTextExtent(s, &x, &y);
        if (x > max_size)
            break;

        last_good_length = i;
    }

    wxString ret = text.Left(last_good_length);
    ret += wxT("...");
    return ret;
}


// -------------------------------------------------------------------------------- //
guAuiDockArt::guAuiDockArt() : wxAuiDefaultDockArt()

// -------------------------------------------------------------------------------- //
void guAuiDockArt::DrawCaptionBackground( wxDC &dc, const wxRect &rect, bool active )
{
    if( m_gradientType == wxAUI_GRADIENT_NONE )
    {
        if( active )
            dc.SetBrush( wxBrush( m_activeCaptionColour ) );
        else
            dc.SetBrush( wxBrush( m_inactiveCaptionColour ) );

        dc.DrawRectangle( rect.x, rect.y, rect.width, rect.height );
    }

            // on mac the gradients are expected to become darker from the top
#ifdef __WXMAC__
            DrawGradientRectangle( dc, rect,
                                 m_activeCaptionColour,
                                 m_activeCaptionGradientColour,
                                 m_gradientType );
#else
            // on other platforms, active gradients become lighter at the top
            DrawGradientRectangle( dc, rect,
                                 m_activeCaptionColour,
                                 m_activeCaptionGradientColour,
                                 m_gradientType );
#endif
        }
        else

#ifdef __WXMAC__
            // on mac the gradients are expected to become darker from the top
            DrawGradientRectangle( dc, rect,
                                 m_inactiveCaptionColour,
                                 m_inactiveCaptionGradientColour,
                                 m_gradientType );
#else
            // on other platforms, inactive gradients become lighter at the bottom
            DrawGradientRectangle( dc, rect,
                                 m_inactiveCaptionColour,
                                 m_inactiveCaptionGradientColour,
                                 m_gradientType );
#endif
        }
    }

    dc.SetPen( m_borderPen );
    int y = rect.y + rect.height - 1;
    dc.DrawLine( rect.x, y, rect.x + rect.width, y );
}

void guAuiDockArt::DrawCaption( wxDC &dc, wxWindow * window, const wxString &text, const wxRect &rect, wxAuiPaneInfo &pane )
{
    dc.SetPen( * wxTRANSPARENT_PEN );
    dc.SetFont( m_captionFont );

    DrawCaptionBackground( dc, rect, bool( pane.state & wxAuiPaneInfo::optionActive ) );

    dc.SetTextForeground( pane.state & wxAuiPaneInfo::optionActive ? m_activeCaptionTextColour : m_inactiveCaptionTextColour );

    wxCoord w, h;
    dc.GetTextExtent( wxT( "ABCDEFHXfgkj" ), &w, &h );

    clip_rect.width -= 3; // text offset
    clip_rect.width -= 2; // button padding
    if( pane.HasCloseButton() )
        clip_rect.width -= m_buttonSize;
    if( pane.HasPinButton() )
        clip_rect.width -= m_buttonSize;
    if( pane.HasMaximizeButton() )
        clip_rect.width -= m_buttonSize;

    wxString draw_text = wxAuiChopText( dc, text, clip_rect.width );

++ b/src/SmartMode.cpp

int guGenSmartPlaylist::GetPlayListId( void )
{
    int Selection = m_SaveToComboBox->GetSelection();
    if( Selection == wxNOT_FOUND && m_SaveToComboBox->GetCount() != 0 )
    {
        Selection = FindPlayListItem( &m_Playlists, m_SaveToComboBox->GetValue().Lower().Trim().Trim( false ) );
    }
++ b/src/StaticBitmap.cpp

    {
        wxCommandEvent event( guStaticBitmapMouseOverEvent, guEVT_STATICBITMAP_MOUSE_OVER );
        event.SetEventObject( this );
        m_Bitmap->GetEventHandler()->AddPendingEvent( event );
    }
}

++ b/src/Equalizer.cpp

{
    int Sel = m_PresetComboBox->GetSelection();

    m_SaveButton->Enable( m_PresetComboBox->GetCount() != 0 &&
                          ( m_BandChanged || !FindPresetName( m_PresetComboBox->GetValue(), m_EQPresets ) ) );

    m_DelButton->Enable( Sel != wxNOT_FOUND );
++ b/src/LocationPanel.cpp

    return 1;
}

unsigned char wxAuiBlendColour(unsigned char fg, unsigned char bg, double alpha)
{
    double result = bg + (alpha * (fg - bg));
    if (result < 0.0)
        result = 0.0;
    if (result > 255)
        result = 255;
    return (unsigned char)result;
}

wxColor wxAuiStepColour(const wxColor& c, int ialpha)
{
    if (ialpha == 100)
        return c;

    unsigned char r = c.Red(),
                  g = c.Green(),
                  b = c.Blue();
    unsigned char bg;

    // ialpha is 0..200 where 0 is completely black
    // and 200 is completely white and 100 is the same
    // convert that to normal alpha 0.0 - 1.0
    ialpha = wxMin(ialpha, 200);
    ialpha = wxMax(ialpha, 0);
    double alpha = ((double)(ialpha - 100.0))/100.0;

    if (ialpha > 100)
    {
        // blend with white
        bg = 255;
        alpha = 1.0 - alpha;  // 0 = transparent fg; 1 = opaque fg
    }
    else
    {
        // blend with black
        bg = 0;
        alpha += 1.0;         // 0 = transparent fg; 1 = opaque fg
    }

    r = wxAuiBlendColour(r, bg, alpha);
    g = wxAuiBlendColour(g, bg, alpha);
    b = wxAuiBlendColour(b, bg, alpha);

    return wxColour(r, g, b);
}

// -------------------------------------------------------------------------------- //
void guLocationTreeCtrl::ReloadItems( const bool loadstate )
++ b/src/StatusBar.h

  public :
    guGauge() : wxControl() { m_LastValue = wxNOT_FOUND; m_PaintWidth = 0; };
    guGauge( wxWindow * parent, const wxString &label = wxEmptyString, bool showporcent = true, wxWindowID id = wxID_ANY, unsigned int max = 100,
               const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize, long style = wxGA_HORIZONTAL | wxBORDER_NONE );
    ~guGauge( void );

    void    SetRange( int range );

    void                SetPlayMode( const bool forcegapless );
    void                SetAudioScrobble( const bool audioscrobble );

    virtual void        DrawField( wxDC &dc, int i, int textHeight );

};

++ b/src/Utils.cpp

    static const wxChar marks[] = wxT( "-_.\"!~*()'" );

	wxString RetVal;
	wxChar CurChar;

	wxCharBuffer CharBuffer = url.ToUTF8();
	int Index;


  for( index = 0; index < StrLen; index++ )
  {
    wxChar C = CharBuffer[ index ];
    {
      static const wxChar marks[] = wxT( " -_.\"/+!~*()'[]%" ); //~!@#$&*()=:/,;?+'

++ b/src/ListView.cpp

    // iterate over all visible lines
    for( ; line < lineMax; line++ )
    {
        const wxCoord hLine = OnGetRowHeight( line );

        rectLine.height = hLine;

++ b/src/TimeLine.h


    virtual void    TimerEvent( void );
    virtual int     TimerCreate( void );
    virtual void    TimerDestroy( void ) { int id = m_TimerId; m_TimerId = 0; if (id) g_source_remove( id ); }

};

++ b/src/SplashWin.cpp


    Show( true );
    SetThemeEnabled( false );
    SetBackgroundStyle( wxBG_STYLE_ERASE );

    m_Timer.SetOwner( this );
    m_Timer.Start( timeout, wxTIMER_ONE_SHOT );
++ b/src/RoundButton.cpp


// -------------------------------------------------------------------------------- //
guRoundButton::guRoundButton( wxWindow * parent, const wxImage &image, const wxImage &selimage, const int flags ) :
    wxControl( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE )
{
    m_Bitmap = wxBitmap( image );
    m_HoverBitmap = wxBitmap( selimage );
++ b/src/RatingCtrl.cpp

END_EVENT_TABLE()

// -------------------------------------------------------------------------------- //
guRating::guRating( wxWindow * parent, const int style ) :
    wxControl( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE )
{
    m_Rating = wxNOT_FOUND;
    m_Style = style;
++ b/src/ToggleRoundButton.cpp

// -------------------------------------------------------------------------------- //
guToggleRoundButton::guToggleRoundButton( wxWindow * parent, const wxImage &image,
        const wxImage &selimage, const wxImage &hoverimage ) :
    wxControl( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE )
{
    m_Bitmap = wxBitmap( selimage );
    m_DisBitmap = wxBitmap( image );

Return to bug 564046