开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
playlist.cpp
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：33k
源码类别：

midi

开发平台：

Unix_Linux

playlist.cpp：源码内容
  1. /*****************************************************************************
  2.  * playlist.cpp : WinCE gui plugin for VLC
  3.  *****************************************************************************
  4.  * Copyright (C) 2000-2004 the VideoLAN team
  5.  * $Id: fd695a4b8ff09051db0517036acb26104f9bdf79 $
  6.  *
  7.  * Authors: Marodon Cedric <cedric_marodon@yahoo.fr>
  8.  *          Gildas Bazin <gbazin@videolan.org>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  28. #ifdef HAVE_CONFIG_H
  29. # include "config.h"
  30. #endif
  32. #include <vlc_common.h>
  33. #include <vlc_interface.h>
  34. #include <vlc_playlist.h>
  36. #include "wince.h"
  38. #include <commctrl.h>
  39. #include <commdlg.h>
  41. #ifndef TEXTMAXBUF
  42. #define TEXTMAXBUF 512 // at least 500
  43. #endif
  45. #define LONG2POINT(l, pt)  ((pt).x = (SHORT)LOWORD(l), (pt).y = (SHORT)HIWORD(l))
  47. #define NUMIMAGES     11   // Number of buttons in the toolbar
  48. #define IMAGEWIDTH    16   // Width of the buttons in the toolbar
  49. #define IMAGEHEIGHT   16   // Height of the buttons in the toolbar
  50. #define BUTTONWIDTH   0    // Width of the button images in the toolbar
  51. #define BUTTONHEIGHT  0    // Height of the button images in the toolbar
  52. #define ID_TOOLBAR    2000 // Identifier of the main tool bar
  54. enum
  55. {
  56.   Infos_Event = 1000,
  57.   Up_Event,
  58.   Down_Event,
  59.   Random_Event,
  60.   Loop_Event,
  61.   Repeat_Event,
  62.   PopupPlay_Event,
  63.   PopupDel_Event,
  64.   PopupEna_Event,
  65.   PopupInfo_Event
  66. };
  68. // Help strings
  69. #define HELP_OPENPL _T("Open playlist")
  70. #define HELP_SAVEPL _T("Save playlist")
  71. #define HELP_ADDFILE _T("Add File")
  72. #define HELP_ADDMRL _T("Add MRL")
  73. #define HELP_DELETE _T("Delete selection")
  74. #define HELP_INFOS _T("Item info")
  75. #define HELP_UP _T("Up")
  76. #define HELP_DOWN _T("Down")
  77. #define HELP_RANDOM _T("Random")
  78. #define HELP_LOOP _T("Repeat all")
  79. #define HELP_REPEAT _T("Repeat one")
  81. // The TBBUTTON structure contains information the toolbar buttons.
  82. static TBBUTTON tbButton2[] =
  83. {
  84.   {0,  ID_MANAGE_OPENPL,        TBSTATE_ENABLED, TBSTYLE_BUTTON },
  85.   {1,  ID_MANAGE_SAVEPL,        TBSTATE_ENABLED, TBSTYLE_BUTTON },
  86.   {0,  0,                       TBSTATE_ENABLED, TBSTYLE_SEP    },
  87.   {2,  ID_MANAGE_ADDFILE,       TBSTATE_ENABLED, TBSTYLE_BUTTON },
  88.   {3,  ID_MANAGE_ADDMRL,        TBSTATE_ENABLED, TBSTYLE_BUTTON },
  89.   {4,  ID_SEL_DELETE,           TBSTATE_ENABLED, TBSTYLE_BUTTON },
  90.   {0,  0,                       TBSTATE_ENABLED, TBSTYLE_SEP    },
  91.   {5,  Infos_Event,             TBSTATE_ENABLED, TBSTYLE_BUTTON },
  92.   {0,  0,                       TBSTATE_ENABLED, TBSTYLE_SEP    },
  93.   {6,  Up_Event,                TBSTATE_ENABLED, TBSTYLE_BUTTON },
  94.   {7,  Down_Event,              TBSTATE_ENABLED, TBSTYLE_BUTTON },
  95.   {0,  0,                       TBSTATE_ENABLED, TBSTYLE_SEP    },
  96.   {8,  Random_Event,            TBSTATE_ENABLED, TBSTYLE_CHECK  },
  97.   {9,  Loop_Event,              TBSTATE_ENABLED, TBSTYLE_CHECK  },
  98.   {10, Repeat_Event,            TBSTATE_ENABLED, TBSTYLE_CHECK  }
  99. };
  101. // Toolbar ToolTips
  102. TCHAR * szToolTips2[] =
  103. {
  104.     HELP_OPENPL,
  105.     HELP_SAVEPL,
  106.     HELP_ADDFILE,
  107.     HELP_ADDMRL,
  108.     HELP_DELETE,
  109.     HELP_INFOS,
  110.     HELP_UP,
  111.     HELP_DOWN,
  112.     HELP_RANDOM,
  113.     HELP_LOOP,
  114.     HELP_REPEAT
  115. };
  117. /*****************************************************************************
  118.  * Event Table.
  119.  *****************************************************************************/
  121. /*****************************************************************************
  122.  * Constructor.
  123.  *****************************************************************************/
  124. Playlist::Playlist( intf_thread_t *p_intf, CBaseWindow *p_parent,
  125.                     HINSTANCE h_inst )
  126.   :  CBaseWindow( p_intf, p_parent, h_inst )
  127. {
  128.     /* Initializations */
  129.     hListView = NULL;
  130.     i_title_sorted = 1;
  131.     i_author_sorted = 1;
  133.     b_need_update = true;
  134. }
  136. /***********************************************************************
  137. FUNCTION:
  138.   CreateMenuBar
  140. PURPOSE:
  141.   Creates a menu bar.
  142. ***********************************************************************/
  143. static HWND CreateMenuBar( HWND hwnd, HINSTANCE hInst )
  144. {
  145. #ifdef UNDER_CE
  146.     SHMENUBARINFO mbi;
  147.     memset( &mbi, 0, sizeof(SHMENUBARINFO) );
  148.     mbi.cbSize     = sizeof(SHMENUBARINFO);
  149.     mbi.hwndParent = hwnd;
  150.     mbi.hInstRes   = hInst;
  151.     mbi.nToolBarId = IDR_MENUBAR2;
  153.     if( !SHCreateMenuBar( &mbi ) )
  154.     {
  155.         MessageBox(hwnd, _T("SHCreateMenuBar Failed"), _T("Error"), MB_OK);
  156.         return 0;
  157.     }
  159.     TBBUTTONINFO tbbi;
  160.     tbbi.cbSize = sizeof(tbbi);
  161.     tbbi.dwMask = TBIF_LPARAM;
  163.     SendMessage( mbi.hwndMB, TB_GETBUTTONINFO, IDM_MANAGE, (LPARAM)&tbbi );
  164.     HMENU hmenu_file = (HMENU)tbbi.lParam;
  165.     RemoveMenu( hmenu_file, 0, MF_BYPOSITION );
  166.     SendMessage( mbi.hwndMB, TB_GETBUTTONINFO, IDM_SORT, (LPARAM)&tbbi );
  167.     HMENU hmenu_sort = (HMENU)tbbi.lParam;
  168.     RemoveMenu( hmenu_sort, 0, MF_BYPOSITION );
  169.     SendMessage( mbi.hwndMB, TB_GETBUTTONINFO, IDM_SEL, (LPARAM)&tbbi );
  170.     HMENU hmenu_sel = (HMENU)tbbi.lParam;
  171.     RemoveMenu( hmenu_sel, 0, MF_BYPOSITION );
  173. #else
  174.     HMENU hmenu_file = CreatePopupMenu();
  175.     HMENU hmenu_sort = CreatePopupMenu();
  176.     HMENU hmenu_sel = CreatePopupMenu();
  177. #endif
  179.     AppendMenu( hmenu_file, MF_STRING, ID_MANAGE_ADDFILE,
  180.                 _T("&Add File...") );
  181.     AppendMenu( hmenu_file, MF_STRING, ID_MANAGE_ADDDIRECTORY,
  182.                 _T("Add Directory...") );
  183.     AppendMenu( hmenu_file, MF_STRING, ID_MANAGE_ADDMRL,
  184.                 _T("Add MRL...") );
  185.     AppendMenu( hmenu_file, MF_SEPARATOR, 0, 0 );
  186.     AppendMenu( hmenu_file, MF_STRING, ID_MANAGE_OPENPL,
  187.                 _T("Open &Playlist") );
  188.     AppendMenu( hmenu_file, MF_STRING, ID_MANAGE_SAVEPL,
  189.                 _T("Save Playlist") );
  191.     AppendMenu( hmenu_sort, MF_STRING, ID_SORT_TITLE,
  192.                 _T("Sort by &title") );
  193.     AppendMenu( hmenu_sort, MF_STRING, ID_SORT_RTITLE,
  194.                 _T("&Reverse sort by title") );
  195.     AppendMenu( hmenu_sort, MF_SEPARATOR, 0, 0 );
  196.     AppendMenu( hmenu_sort, MF_STRING, ID_SORT_AUTHOR,
  197.                 _T("Sort by &author") );
  198.     AppendMenu( hmenu_sort, MF_STRING, ID_SORT_RAUTHOR,
  199.                 _T("Reverse sort by &author") );
  200.     AppendMenu( hmenu_sort, MF_SEPARATOR, 0, 0 );
  201.     AppendMenu( hmenu_sort, MF_STRING, ID_SORT_SHUFFLE,
  202.                 _T("&Shuffle Playlist") );
  204.     AppendMenu( hmenu_sel, MF_STRING, ID_SEL_ENABLE,
  205.                 _T("&Enable") );
  206.     AppendMenu( hmenu_sel, MF_STRING, ID_SEL_DISABLE,
  207.                 _T("&Disable") );
  208.     AppendMenu( hmenu_sel, MF_SEPARATOR, 0, 0 );
  209.     AppendMenu( hmenu_sel, MF_STRING, ID_SEL_INVERT,
  210.                 _T("&Invert") );
  211.     AppendMenu( hmenu_sel, MF_STRING, ID_SEL_DELETE,
  212.                 _T("D&elete") );
  213.     AppendMenu( hmenu_sel, MF_SEPARATOR, 0, 0 );
  214.     AppendMenu( hmenu_sel, MF_STRING, ID_SEL_SELECTALL,
  215.                 _T("&Select All") );
  218. #ifdef UNDER_CE
  219.     return mbi.hwndMB;
  221. #else
  222.     HMENU hmenu = CreateMenu();
  224.     AppendMenu( hmenu, MF_POPUP|MF_STRING, (UINT)hmenu_file, _T("Manage") );
  225.     AppendMenu( hmenu, MF_POPUP|MF_STRING, (UINT)hmenu_sort, _T("Sort") );
  226.     AppendMenu( hmenu, MF_POPUP|MF_STRING, (UINT)hmenu_sel, _T("Selection") );
  228.     SetMenu( hwnd, hmenu );
  229.     return hwnd;
  231. #endif
  232. }
  234. /***********************************************************************
  235. FUNCTION:
  236.   WndProc
  238. PURPOSE:
  239.   Processes messages sent to the main window.
  240. ***********************************************************************/
  241. LRESULT Playlist::WndProc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
  242. {
  243.     SHINITDLGINFO shidi;
  244.     SHMENUBARINFO mbi;
  245.     INITCOMMONCONTROLSEX iccex;
  246.     RECT rect, rectTB;
  247.     DWORD dwStyle;
  249.     int bState;
  250.     playlist_t *p_playlist;
  252.     switch( msg )
  253.     {
  254.     case WM_INITDIALOG:
  255.         shidi.dwMask = SHIDIM_FLAGS;
  256.         shidi.dwFlags = SHIDIF_DONEBUTTON | SHIDIF_SIPDOWN |
  257.             SHIDIF_FULLSCREENNOMENUBAR;//SHIDIF_SIZEDLGFULLSCREEN;
  258.         shidi.hDlg = hwnd;
  259.         SHInitDialog( &shidi );
  261.         hwndCB = CreateMenuBar( hwnd, hInst );
  263.         iccex.dwSize = sizeof (INITCOMMONCONTROLSEX);
  264.         iccex.dwICC = ICC_BAR_CLASSES;
  266.         // Registers TOOLBAR control classes from the common control dll
  267.         InitCommonControlsEx (&iccex);
  269.         //  Create the toolbar control.
  270.         dwStyle = WS_VISIBLE | WS_CHILD | TBSTYLE_TOOLTIPS |
  271.             WS_EX_OVERLAPPEDWINDOW | CCS_NOPARENTALIGN;
  273.         hwndTB = CreateToolbarEx( hwnd, dwStyle, 0, NUMIMAGES,
  274.                                   hInst, IDB_BITMAP3, tbButton2,
  275.                                   sizeof (tbButton2) / sizeof (TBBUTTON),
  276.                                   BUTTONWIDTH, BUTTONHEIGHT,
  277.                                   IMAGEWIDTH, IMAGEHEIGHT, sizeof(TBBUTTON) );
  278.         if( !hwndTB ) break;
  279.  
  280.         // Add ToolTips to the toolbar.
  281.         SendMessage( hwndTB, TB_SETTOOLTIPS, (WPARAM) NUMIMAGES,
  282.                      (LPARAM)szToolTips2 );
  284.         // Reposition the toolbar.
  285.         GetClientRect( hwnd, &rect );
  286.         GetWindowRect( hwndTB, &rectTB );
  287.         MoveWindow( hwndTB, rect.left, rect.top - 2, rect.right - rect.left,
  288.                     MENU_HEIGHT /*rectTB.bottom - rectTB.top */, TRUE);
  290.         // random, loop, repeat buttons states
  291.         vlc_value_t val;
  292.         p_playlist = pl_Hold( p_intf );
  293.         if( !p_playlist ) break;
  295.         var_Get( p_playlist , "random", &val );
  296.         bState = val.b_bool ? TBSTATE_CHECKED : 0;
  297.         SendMessage( hwndTB, TB_SETSTATE, Random_Event,
  298.                      MAKELONG(bState | TBSTATE_ENABLED, 0) );
  299.         var_Get( p_playlist , "loop", &val );
  300.         bState = val.b_bool ? TBSTATE_CHECKED : 0;
  301.         SendMessage( hwndTB, TB_SETSTATE, Loop_Event,
  302.                      MAKELONG(bState | TBSTATE_ENABLED, 0) );
  303.         var_Get( p_playlist , "repeat", &val );
  304.         bState = val.b_bool ? TBSTATE_CHECKED : 0;
  305.         SendMessage( hwndTB, TB_SETSTATE, Repeat_Event,
  306.                      MAKELONG(bState | TBSTATE_ENABLED, 0) );
  307.         pl_Release( p_intf );
  309.         GetClientRect( hwnd, &rect );
  310.         hListView = CreateWindow( WC_LISTVIEW, NULL, WS_VISIBLE | WS_CHILD |
  311.             LVS_REPORT | LVS_SHOWSELALWAYS | WS_VSCROLL | WS_HSCROLL,
  312.             rect.left, rect.top + 2*(MENU_HEIGHT+1), rect.right - rect.left,
  313.             rect.bottom - ( rect.top + 2*MENU_HEIGHT) - MENU_HEIGHT,
  314.             hwnd, NULL, hInst, NULL );
  315.         ListView_SetExtendedListViewStyle( hListView, LVS_EX_FULLROWSELECT );
  317.         LVCOLUMN lv;
  318.         lv.mask = LVCF_WIDTH | LVCF_FMT | LVCF_TEXT;
  319.         lv.fmt = LVCFMT_LEFT ;
  320.         GetClientRect( hwnd, &rect );
  321.         lv.cx = 120;
  322.         lv.pszText = _T("Name");
  323.         lv.cchTextMax = 9;
  324.         ListView_InsertColumn( hListView, 0, &lv);
  325.         lv.cx = 55;
  326.         lv.pszText = _T("Author");
  327.         lv.cchTextMax = 9;
  328.         ListView_InsertColumn( hListView, 1, &lv);
  329.         lv.cx = rect.right - rect.left - 180;
  330.         lv.pszText = _T("Duration");
  331.         lv.cchTextMax = 9;
  332.         ListView_InsertColumn( hListView, 2, &lv);
  334.         SetTimer( hwnd, 1, 500 /*milliseconds*/, NULL );
  335.         break;
  337.     case WM_TIMER:
  338.         UpdatePlaylist();
  339.         break;
  341.     case WM_CLOSE:
  342.         EndDialog( hwnd, LOWORD( wp ) );
  343.         break;
  345.     case WM_SETFOCUS:
  346.         SHSipPreference( hwnd, SIP_DOWN );
  347.         SHFullScreen( hwnd, SHFS_HIDESIPBUTTON );
  348.         break;
  350.     case WM_COMMAND:
  351.         switch( LOWORD(wp) )
  352.         {
  353.         case IDOK:
  354.             EndDialog( hwnd, LOWORD( wp ) );
  355.             break;
  357.         case ID_MANAGE_OPENPL:
  358.             OnOpen();
  359.             b_need_update = true;
  360.             break;
  362.         case ID_MANAGE_SAVEPL:
  363.             OnSave();
  364.             break;
  366.         case ID_MANAGE_ADDFILE:
  367.             p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE_SIMPLE,
  368.                                            0, 0 );
  369.             b_need_update = true;
  370.             break;
  372.         case ID_MANAGE_ADDDIRECTORY:
  373.             p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_DIRECTORY,
  374.                                            0, 0 );
  375.             b_need_update = true;
  376.             break;
  378.         case ID_MANAGE_ADDMRL:
  379.             p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE, 0, 0 );
  380.             b_need_update = true;
  381.             break;
  383.         case ID_SEL_DELETE:
  384.             OnDeleteSelection();
  385.             b_need_update = true;
  386.             break;
  388.         case Infos_Event:
  389.             OnPopupInfo( hwnd );
  390.             b_need_update = true;
  391.             break;
  393.         case Up_Event:
  394.             OnUp();
  395.             b_need_update = true;
  396.             break;
  398.         case Down_Event:
  399.             OnDown();
  400.             b_need_update = true;
  401.             break;
  403.         case Random_Event:
  404.             OnRandom();
  405.             break;
  407.         case Loop_Event:
  408.             OnLoop();
  409.             break;
  411.         case Repeat_Event:
  412.             OnRepeat();
  413.             break;
  415.         case ID_SORT_TITLE:
  416.             OnSort( ID_SORT_TITLE );
  417.             break;
  419.         case ID_SORT_RTITLE:
  420.             OnSort( ID_SORT_RTITLE );
  421.             break;
  423.         case ID_SORT_AUTHOR:
  424.             OnSort( ID_SORT_AUTHOR );
  425.             break;
  427.         case ID_SORT_RAUTHOR:
  428.             OnSort( ID_SORT_RAUTHOR );
  429.             break;
  431.         case ID_SORT_SHUFFLE:
  432.             OnSort( ID_SORT_SHUFFLE );
  433.             break;
  435.         case ID_SEL_ENABLE:
  436.             OnEnableSelection();
  437.             break;
  439.         case ID_SEL_DISABLE:
  440.             OnDisableSelection();
  441.             break;
  443.         case ID_SEL_INVERT:
  444.             OnInvertSelection();
  445.             break;
  447.         case ID_SEL_SELECTALL:
  448.             OnSelectAll();
  449.             break;
  451.         case PopupPlay_Event:
  452.             OnPopupPlay();
  453.             b_need_update = true;
  454.             break;
  456.         case PopupDel_Event:
  457.             OnPopupDel();
  458.             b_need_update = true;
  459.             break;
  461.         case PopupEna_Event:
  462.             OnPopupEna();
  463.             b_need_update = true;
  464.             break;
  466.         case PopupInfo_Event:
  467.             OnPopupInfo( hwnd );
  468.             b_need_update = true;
  469.             break;
  471.         default:
  472.             break;
  473.         }
  474.         break;
  476.     case WM_NOTIFY:
  477.         if( ( ((LPNMHDR)lp)->hwndFrom == hListView ) &&
  478.             ( ((LPNMHDR)lp)->code == NM_CUSTOMDRAW ) )
  479.         {
  480.             SetWindowLong( hwnd, DWL_MSGRESULT,
  481.                            (LONG)ProcessCustomDraw(lp) );
  482.         }
  483.         else if( ( ((LPNMHDR)lp)->hwndFrom == hListView ) &&
  484.                  ( ((LPNMHDR)lp)->code == GN_CONTEXTMENU  ) )
  485.         {
  486.             HandlePopupMenu( hwnd, ((PNMRGINFO)lp)->ptAction );
  487.         }
  488.         else if( ( ((LPNMHDR)lp)->hwndFrom == hListView ) &&
  489.                  ( ((LPNMHDR)lp)->code == LVN_COLUMNCLICK  ) )
  490.         {
  491.             OnColSelect( ((LPNMLISTVIEW)lp)->iSubItem );
  492.         }
  493.         else if( ( ((LPNMHDR)lp)->hwndFrom == hListView ) &&
  494.                  ( ((LPNMHDR)lp)->code == LVN_ITEMACTIVATE  ) )
  495.         {
  496.             OnActivateItem( ((LPNMLISTVIEW)lp)->iSubItem );
  497.         }
  498.         break;
  500.     default:
  501.          // the message was not processed
  502.          // indicate if the base class handled it
  503.         break;
  504.     }
  506.     return FALSE;
  507. }
  509. LRESULT Playlist::ProcessCustomDraw( LPARAM lParam )
  510. {
  511.     LPNMLVCUSTOMDRAW lplvcd = (LPNMLVCUSTOMDRAW)lParam;
  513.     switch( lplvcd->nmcd.dwDrawStage )
  514.     {
  515.     case CDDS_PREPAINT : //Before the paint cycle begins
  516.         //request notifications for individual listview items
  517.         return CDRF_NOTIFYITEMDRAW;
  519.     case CDDS_ITEMPREPAINT: //Before an item is drawn
  520.         playlist_t *p_playlist = pl_Hold( p_intf );
  521.         if( p_playlist == NULL ) return CDRF_DODEFAULT;
  522.         if( (int)lplvcd->nmcd.dwItemSpec == p_playlist->i_current_index )
  523.         {
  524.             lplvcd->clrText = RGB(255,0,0);
  525.             pl_Release( p_intf );
  526.             return CDRF_NEWFONT;
  527.         }
  529.         PL_LOCK;
  530.         playlist_item_t *p_item = playlist_ItemGetById( p_playlist,
  531.                                         (int)lplvcd->nmcd.dwItemSpec );
  532.         if( !p_item )
  533.         {
  534.             PL_UNLOCK;
  535.             pl_Release( p_intf );
  536.             return CDRF_DODEFAULT;
  537.         }
  538.         if( p_item->i_flags & PLAYLIST_DBL_FLAG )
  539.         {
  540.             lplvcd->clrText = RGB(192,192,192);
  541.             PL_UNLOCK;
  542.             pl_Release( p_intf );
  543.             return CDRF_NEWFONT;
  544.         }
  545.         PL_UNLOCK;
  546.         pl_Release( p_intf );
  547.     }
  549.     return CDRF_DODEFAULT;
  550. }
  552. /**********************************************************************
  553.  * Handles the display of the "floating" popup
  554.  **********************************************************************/
  555. void Playlist::HandlePopupMenu( HWND hwnd, POINT point )
  556. {
  557.     HMENU hMenuTrackPopup;
  559.     // Create the popup menu.
  560.     hMenuTrackPopup = CreatePopupMenu();
  562.     // Append some items.
  563.     AppendMenu( hMenuTrackPopup, MF_STRING, PopupPlay_Event, _T("Play") );
  564.     AppendMenu( hMenuTrackPopup, MF_STRING, PopupDel_Event, _T("Delete") );
  565.     AppendMenu( hMenuTrackPopup, MF_STRING, PopupEna_Event,
  566.                 _T("Toggle enabled") );
  567.     AppendMenu( hMenuTrackPopup, MF_STRING, PopupInfo_Event, _T("Info") );
  569.     /* Draw and track the "floating" popup */
  570.     TrackPopupMenu( hMenuTrackPopup, 0, point.x, point.y, 0, hwnd, NULL );
  572.     /* Destroy the menu since were are done with it. */
  573.     DestroyMenu( hMenuTrackPopup );
  574. }
  576. /**********************************************************************
  577.  * Show the playlist
  578.  **********************************************************************/
  579. void Playlist::ShowPlaylist( bool b_show )
  580. {
  581.     if( b_show ) Rebuild();
  582.     Show( b_show );
  583. }
  585. /**********************************************************************
  586.  * Update the playlist
  587.  **********************************************************************/
  588. void Playlist::UpdatePlaylist()
  589. {
  590.     if( b_need_update )
  591.     {
  592.         Rebuild();
  593.         b_need_update = false;
  594.     }
  595.  
  596.     playlist_t *p_playlist = pl_Hold( p_intf );
  597.     if( p_playlist == NULL ) return;
  598.  
  599.     /* Update the colour of items */
  601.     PL_LOCK;
  602.     if( p_intf->p_sys->i_playing != playlist_CurrentSize( p_playlist ) )
  603.     {
  604.         // p_playlist->i_index in RED
  605.         Rebuild();
  607.         // if exists, p_intf->p_sys->i_playing in BLACK
  608.         p_intf->p_sys->i_playing = p_playlist->i_current_index;
  609.     }
  610.     PL_UNLOCK;
  612.     pl_Release( p_intf );
  613. }
  615. /**********************************************************************
  616.  * Rebuild the playlist
  617.  **********************************************************************/
  618. void Playlist::Rebuild()
  619. {
  620.     playlist_t *p_playlist = pl_Hold( p_intf );
  621.     if( p_playlist == NULL ) return;
  623.     int i_focused =
  624.         ListView_GetNextItem( hListView, -1, LVIS_SELECTED | LVNI_ALL );
  626.     /* Clear the list... */
  627.     ListView_DeleteAllItems( hListView );
  629.     /* ...and rebuild it */
  630.     PL_LOCK;
  631.     playlist_item_t * p_root = p_playlist->p_local_onelevel;
  632.     playlist_item_t * p_child = NULL;
  634.     int iItem = 0;
  636.     while( ( p_child = playlist_GetNextLeaf( p_playlist, p_root, p_child, FALSE, FALSE ) ) )
  637.     {
  638.         LVITEM lv;
  639.         lv.mask = LVIF_TEXT;
  640.         lv.pszText = _T("");
  641.         lv.cchTextMax = 1;
  642.         lv.iSubItem = 0;
  643.         lv.iItem = iItem;
  644.         ListView_InsertItem( hListView, &lv );
  645.         ListView_SetItemText( hListView, lv.iItem, 0,
  646.             _FROMMB(p_child->p_input->psz_name) );
  648.         UpdateItem( p_child->i_id );
  649.         iItem++;
  650.     }
  651.     PL_UNLOCK;
  653.     if ( i_focused )
  654.         ListView_SetItemState( hListView, i_focused, LVIS_FOCUSED |
  655.                                LVIS_SELECTED, LVIS_STATEIMAGEMASK )
  656.     else
  657.         ListView_SetItemState( hListView, i_focused, LVIS_FOCUSED,
  658.                                LVIS_STATEIMAGEMASK );
  660.     pl_Release( p_intf );
  661. }
  663. /**********************************************************************
  664.  * Update one playlist item
  665.  **********************************************************************/
  666. void Playlist::UpdateItem( int i )
  667. {
  668.     playlist_t *p_playlist = pl_Hold( p_intf );
  670.     if( p_playlist == NULL ) return;
  672.     PL_LOCK;
  673.     playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i );
  675.     if( !p_item )
  676.     {
  677.         PL_UNLOCK;
  678.         pl_Release( p_intf );
  679.         return;
  680.     }
  682.     ListView_SetItemText( hListView, i, 0, _FROMMB(p_item->p_input->psz_name) );
  684.     ListView_SetItemText( hListView, i, 1,
  685.                           _FROMMB( input_item_GetInfo( p_item->p_input,
  686.                                    _("General") , _("Author") ) ) );
  688.     char psz_duration[MSTRTIME_MAX_SIZE];
  689.     mtime_t dur = input_item_GetDuration( p_item->p_input );
  690.     PL_UNLOCK;
  692.     if( dur != -1 ) secstotimestr( psz_duration, dur/1000000 );
  693.     else memcpy( psz_duration , "-:--:--", sizeof("-:--:--") );
  695.     ListView_SetItemText( hListView, i, 2, _FROMMB(psz_duration) );
  697.     pl_Release( p_intf );
  698. }
  700. /**********************************************************************
  701.  * Private functions
  702.  **********************************************************************/
  703. void Playlist::DeleteItem( int item )
  704. {
  705.     playlist_t *p_playlist = pl_Hold( p_intf );
  706.     if( p_playlist == NULL ) return;
  708.     playlist_DeleteFromInput( p_playlist, item, FALSE );
  709.     ListView_DeleteItem( hListView, item );
  711.     pl_Release( p_intf );
  712. }
  714. /**********************************************************************
  715.  * I/O functions
  716.  **********************************************************************/
  717. static void OnOpenCB( intf_dialog_args_t *p_arg )
  718. {
  719.     intf_thread_t *p_intf = (intf_thread_t *)p_arg->p_arg;
  721.     if( p_arg->i_results && p_arg->psz_results[0] )
  722.     {
  723.         playlist_t * p_playlist = pl_Hold( p_intf );
  725.         if( p_playlist )
  726.         {
  727.             playlist_Import( p_playlist, p_arg->psz_results[0] );
  728.             pl_Release( p_intf );
  729.         }
  730.     }
  731. }
  733. void Playlist::OnOpen()
  734. {
  735.     char *psz_filters ="All playlists|*.pls;*.m3u;*.asx;*.b4s|M3U files|*.m3u";
  737.     intf_dialog_args_t *p_arg =
  738.         (intf_dialog_args_t *)malloc( sizeof(intf_dialog_args_t) );
  739.     memset( p_arg, 0, sizeof(intf_dialog_args_t) );
  741.     p_arg->psz_title = strdup( "Open playlist" );
  742.     p_arg->psz_extensions = strdup( psz_filters );
  743.     p_arg->p_arg = p_intf;
  744.     p_arg->pf_callback = OnOpenCB;
  746.     p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE_GENERIC, 0, p_arg);
  747. }
  749. static void OnSaveCB( intf_dialog_args_t *p_arg )
  750. {
  751.     intf_thread_t *p_intf = (intf_thread_t *)p_arg->p_arg;
  753.     if( p_arg->i_results && p_arg->psz_results[0] )
  754.     {
  755.         playlist_t * p_playlist = pl_Hold( p_intf );
  757.         if( p_playlist )
  758.         {
  759.             char *psz_export;
  760.             char *psz_ext = strrchr( p_arg->psz_results[0], '.' );
  762.             if( psz_ext && !strcmp( psz_ext, ".pls") )
  763.                 psz_export = "export-pls";
  764.             else psz_export = "export-m3u";
  766.             playlist_Export( p_playlist, p_arg->psz_results[0], p_playlist->p_local_onelevel, psz_export );
  767.             pl_Release( p_intf );
  768.         }
  769.     }
  770. }
  772. void Playlist::OnSave()
  773. {
  774.     char *psz_filters ="M3U file|*.m3u|PLS file|*.pls";
  776.     intf_dialog_args_t *p_arg =
  777.         (intf_dialog_args_t *)malloc( sizeof(intf_dialog_args_t) );
  778.     memset( p_arg, 0, sizeof(intf_dialog_args_t) );
  780.     p_arg->psz_title = strdup( "Save playlist" );
  781.     p_arg->psz_extensions = strdup( psz_filters );
  782.     p_arg->b_save = true;
  783.     p_arg->p_arg = p_intf;
  784.     p_arg->pf_callback = OnSaveCB;
  786.     p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE_GENERIC,
  787.                                    0, p_arg );
  788. }
  790. /**********************************************************************
  791.  * Selection functions
  792.  **********************************************************************/
  793. void Playlist::OnDeleteSelection()
  794. {
  795.     /* Delete from the end to the beginning, to avoid a shift of indices */
  796.     for( long item = ((int) ListView_GetItemCount( hListView ) - 1);
  797.          item >= 0; item-- )
  798.     {
  799.         if( ListView_GetItemState( hListView, item, LVIS_SELECTED ) )
  800.         {
  801.             DeleteItem( item );
  802.         }
  803.     }
  804. }
  806. void Playlist::OnInvertSelection()
  807. {
  808.     UINT iState;
  810.     for( long item = 0; item < ListView_GetItemCount( hListView ); item++ )
  811.     {
  812.         iState = ListView_GetItemState( hListView, item, LVIS_STATEIMAGEMASK );
  813.         ListView_SetItemState( hListView, item, iState ^ LVIS_SELECTED,
  814.                                LVIS_STATEIMAGEMASK );
  815.     }
  816. }
  818. void Playlist::OnEnableSelection()
  819. {
  820.     playlist_t *p_playlist = pl_Hold( p_intf );
  821.     if( p_playlist == NULL ) return;
  823.     for( long item = ListView_GetItemCount( hListView ) - 1;
  824.          item >= 0; item-- )
  825.     {
  826.         if( ListView_GetItemState( hListView, item, LVIS_SELECTED ) )
  827.         {
  828.             PL_LOCK;
  829.             playlist_item_t *p_item = playlist_ItemGetById( p_playlist, item );
  830.             p_item->i_flags ^= PLAYLIST_DBL_FLAG;
  831.             PL_UNLOCK;
  832.             UpdateItem( item );
  833.         }
  834.     }
  835.     pl_Release( p_intf );
  836. }
  838. void Playlist::OnDisableSelection()
  839. {
  840.     playlist_t *p_playlist = pl_Hold( p_intf );
  841.     if( p_playlist == NULL ) return;
  843.     for( long item = ListView_GetItemCount( hListView ) - 1;
  844.          item >= 0; item-- )
  845.     {
  846.         if( ListView_GetItemState( hListView, item, LVIS_SELECTED ) )
  847.         {
  848.             PL_LOCK;
  849.             playlist_item_t *p_item = playlist_ItemGetById( p_playlist, item );
  850.             p_item->i_flags |= PLAYLIST_DBL_FLAG;
  851.             PL_UNLOCK;
  852.             UpdateItem( item );
  853.         }
  854.     }
  855.     pl_Release( p_intf );
  856. }
  858. void Playlist::OnSelectAll()
  859. {
  860.     for( long item = 0; item < ListView_GetItemCount( hListView ); item++ )
  861.     {
  862.         ListView_SetItemState( hListView, item, LVIS_FOCUSED | LVIS_SELECTED,
  863.                                LVIS_STATEIMAGEMASK );
  864.     }
  865. }
  867. void Playlist::OnActivateItem( int i_item )
  868. {
  869.     playlist_t *p_playlist = pl_Hold( p_intf );
  870.     if( p_playlist == NULL ) return;
  872.     playlist_Skip( p_playlist, i_item - p_playlist->i_current_index );
  874.     pl_Release( p_intf );
  875. }
  877. void Playlist::ShowInfos( HWND hwnd, int i_item )
  878. {
  879.     playlist_t *p_playlist = pl_Hold( p_intf );
  880.     if( p_playlist == NULL ) return;
  882.     PL_LOCK;
  883.     playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_item );
  884.     if( p_item )
  885.     {
  886.         ItemInfoDialog *iteminfo_dialog =
  887.             new ItemInfoDialog( p_intf, this, hInst, p_item );
  888.         PL_UNLOCK;
  889.         CreateDialogBox( hwnd, iteminfo_dialog );
  890.         UpdateItem( i_item );
  891.         delete iteminfo_dialog;
  892.     }
  894.     pl_Release( p_intf );
  895. }
  897. /********************************************************************
  898.  * Move functions
  899.  ********************************************************************/
  900. void Playlist::OnUp()
  901. {
  902.     playlist_t *p_playlist = pl_Hold( p_intf );
  903.     if( p_playlist == NULL ) return;
  905.     /* We use the first selected item, so find it */
  906.     long i_item =
  907.         ListView_GetNextItem( hListView, -1, LVIS_SELECTED | LVNI_ALL );
  909.     if( i_item > 0 && i_item < playlist_CurrentSize( p_playlist ) )
  910.     {
  911.         playlist_Prev( p_playlist );
  912.         if( i_item > 1 )
  913.         {
  914.             ListView_SetItemState( hListView, i_item - 1, LVIS_FOCUSED,
  915.                                    LVIS_STATEIMAGEMASK );
  916.         }
  917.         else
  918.         {
  919.             ListView_SetItemState( hListView, 0, LVIS_FOCUSED,
  920.                                    LVIS_STATEIMAGEMASK );
  921.         }
  922.     }
  923.     pl_Release( p_intf );
  925.     return;
  926. }
  928. void Playlist::OnDown()
  929. {
  930.     playlist_t *p_playlist = pl_Hold( p_intf );
  931.     if( p_playlist == NULL ) return;
  933.     /* We use the first selected item, so find it */
  934.     long i_item =
  935.         ListView_GetNextItem( hListView, -1, LVIS_SELECTED | LVNI_ALL );
  937.     if( i_item >= 0 && i_item < playlist_CurrentSize( p_playlist ) - 1 )
  938.     {
  939.         playlist_Next( p_playlist );
  940.         ListView_SetItemState( hListView, i_item + 1, LVIS_FOCUSED,
  941.                                LVIS_STATEIMAGEMASK );
  942.     }
  943.     pl_Release( p_intf );
  945.     return;
  946. }
  948. /**********************************************************************
  949.  * Playlist mode functions
  950.  **********************************************************************/
  951. void Playlist::OnRandom()
  952. {
  953.     vlc_value_t val;
  954.     int bState = SendMessage( hwndTB, TB_GETSTATE, Random_Event, 0 );
  955.     val.b_bool = (bState & TBSTATE_CHECKED) ? true : false;
  957.     playlist_t *p_playlist = pl_Hold( p_intf );
  958.     if( p_playlist == NULL ) return;
  960.     var_Set( p_playlist , "random", val );
  961.     pl_Release( p_intf );
  962. }
  964. void Playlist::OnLoop ()
  965. {
  966.     vlc_value_t val;
  967.     int bState = SendMessage( hwndTB, TB_GETSTATE, Loop_Event, 0 );
  968.     val.b_bool = (bState & TBSTATE_CHECKED) ? true : false;
  970.     playlist_t *p_playlist = pl_Hold( p_intf );
  971.     if( p_playlist == NULL ) return;
  973.     var_Set( p_playlist , "loop", val );
  974.     pl_Release( p_intf );
  975. }
  977. void Playlist::OnRepeat ()
  978. {
  979.     vlc_value_t val;
  980.     int bState = SendMessage( hwndTB, TB_GETSTATE, Repeat_Event, 0 );
  981.     val.b_bool = (bState & TBSTATE_CHECKED) ? true : false;
  983.     playlist_t *p_playlist = pl_Hold( p_intf );
  984.     if( p_playlist == NULL ) return;
  986.     var_Set( p_playlist , "repeat", val );
  987.     pl_Release( p_intf );
  988. }
  990. /********************************************************************
  991.  * Sorting functions
  992.  ********************************************************************/
  993. void Playlist::OnSort( UINT event )
  994. {
  995.     playlist_t *p_playlist = pl_Hold( p_intf );
  996.     if( p_playlist == NULL ) return;
  998.     switch( event )
  999.     {
  1000.     case ID_SORT_TITLE:
  1001.         playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1002.                                     SORT_TITLE, ORDER_NORMAL);
  1003.         break;
  1004.     case ID_SORT_RTITLE:
  1005.         playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1006.                                     SORT_TITLE, ORDER_REVERSE );
  1007.         break;
  1008.     case ID_SORT_AUTHOR:
  1009.         playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1010.                                     SORT_ARTIST, ORDER_NORMAL);
  1011.         break;
  1012.     case ID_SORT_RAUTHOR:
  1013.         playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1014.                                     SORT_ARTIST, ORDER_REVERSE);
  1015.         break;
  1016.     case ID_SORT_SHUFFLE:
  1017.         playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1018.                                     SORT_RANDOM, ORDER_NORMAL);
  1019.         break;
  1020.     }
  1022.     pl_Release( p_intf );
  1024.     b_need_update = true;
  1026.     return;
  1027. }
  1029. void Playlist::OnColSelect( int iSubItem )
  1030. {
  1031.     playlist_t *p_playlist = pl_Hold( p_intf );
  1032.     if( p_playlist == NULL ) return;
  1034.     switch( iSubItem )
  1035.     {
  1036.     case 0:
  1037.         if( i_title_sorted != 1 )
  1038.         {
  1039.             playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1040.                                     SORT_TITLE, ORDER_NORMAL);
  1041.             i_title_sorted = 1;
  1042.         }
  1043.         else
  1044.         {
  1045.             playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1046.                                     SORT_TITLE, ORDER_REVERSE );
  1047.             i_title_sorted = -1;
  1048.         }
  1049.         break;
  1050.     case 1:
  1051.         if( i_author_sorted != 1 )
  1052.         {
  1053.             playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1054.                                     SORT_ARTIST, ORDER_NORMAL);
  1055.             i_author_sorted = 1;
  1056.         }
  1057.         else
  1058.         {
  1059.             playlist_RecursiveNodeSort(p_playlist , p_playlist->p_root_onelevel,
  1060.                                     SORT_ARTIST, ORDER_REVERSE);
  1061.             i_author_sorted = -1;
  1062.         }
  1063.         break;
  1064.     default:
  1065.         break;
  1066.     }
  1068.     pl_Release( p_intf );
  1070.     b_need_update = true;
  1072.     return;
  1073. }
  1075. /*****************************************************************************
  1076.  * Popup management functions
  1077.  *****************************************************************************/
  1078. void Playlist::OnPopupPlay()
  1079. {
  1080.     int i_popup_item =
  1081.         ListView_GetNextItem( hListView, -1, LVIS_SELECTED | LVNI_ALL );
  1083.     playlist_t *p_playlist = pl_Hold( p_intf );
  1084.     if( p_playlist == NULL ) return;
  1086.     if( i_popup_item != -1 )
  1087.     {
  1088.         playlist_Skip( p_playlist, i_popup_item - p_playlist->i_current_index );
  1089.     }
  1091.     pl_Release( p_intf );
  1092. }
  1094. void Playlist::OnPopupDel()
  1095. {
  1096.     int i_popup_item =
  1097.         ListView_GetNextItem( hListView, -1, LVIS_SELECTED | LVNI_ALL );
  1099.     DeleteItem( i_popup_item );
  1100. }
  1102. void Playlist::OnPopupEna()
  1103. {
  1104.     int i_popup_item =
  1105.         ListView_GetNextItem( hListView, -1, LVIS_SELECTED | LVNI_ALL );
  1107.     playlist_t *p_playlist = pl_Hold( p_intf );
  1108.     if( p_playlist == NULL ) return;
  1110.     PL_LOCK;
  1111.     playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_popup_item );
  1113.     if( !(p_playlist->items.p_elems[i_popup_item]->i_flags & PLAYLIST_DBL_FLAG) )
  1114.         //playlist_IsEnabled( p_playlist, i_popup_item ) )
  1115.     {
  1116.         p_item->i_flags |= PLAYLIST_DBL_FLAG;
  1117.     }
  1118.     else
  1119.     {
  1120.         p_item->i_flags ^= PLAYLIST_DBL_FLAG;
  1121.     }
  1123.     PL_UNLOCK;
  1124.     pl_Release( p_intf );
  1125.     UpdateItem( i_popup_item );
  1126. }
  1128. void Playlist::OnPopupInfo( HWND hwnd )
  1129. {
  1130.     int i_popup_item =
  1131.         ListView_GetNextItem( hListView, -1, LVIS_SELECTED | LVNI_ALL );
  1133.     ShowInfos( hwnd, i_popup_item );
  1134. }