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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
CPI_PlaylistWindow.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：50k
源码类别：

多媒体编程

开发平台：

Visual C++

CPI_PlaylistWindow.c：源码内容
  1. /*
  2.  * CoolPlayer - Blazing fast audio player.
  3.  * Copyright (C) 2000-2001 Niek Albers
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  */
  19. ////////////////////////////////////////////////////////////////////////////////
  23. #include "stdafx.h"
  24. #include "globals.h"
  25. #include "WindowsOS.h"
  26. #include "CPI_Player.h"
  27. #include "CPI_ID3.h"
  28. #include "CPI_Playlist.h"
  29. #include "CPI_PlaylistItem.h"
  30. #include "CPI_PlaylistWindow.h"
  31. #include "CPI_Indicators.h"
  34. ////////////////////////////////////////////////////////////////////////////////
  35. //
  36. typedef enum _CIe_PlaylistWindowMode
  37. {
  38.     wmQuiescent,
  39.     wmListItem_Drag,
  40.     wmCommandTarget_Click
  42. } CIe_PlaylistWindowMode;
  43. //
  44. //
  45. //
  46. struct _CPs_PlaylistWindowState
  47. {
  48.     CIe_PlaylistWindowMode m_enWindowMode;
  49.     CPs_CommandTarget* m_pActiveCommandTarget;
  50.     CPs_CommandTarget* m_pFloatActiveCommandTarget;
  51.     BOOL m_bMouseEventSet;
  53. } glb_PLW_State;
  54. //
  55. ////////////////////////////////////////////////////////////////////////////////
  61. #define IDC_PL_LISTVIEW 0x0100
  62. #define IDC_PL_FLOATINGEDIT 0x0101
  63. #define IDC_PL_FLOATINGCOMBO 0x0102
  64. #define CPPLM_CREATEINPLACE (WM_APP+0x001)
  65. #define CPPLM_DESTROYINPLACE (WM_APP+0x002)
  66. #define CPC_SIZEBORDER 0x4
  67. //
  68. #define IDC_CMDTS_CLEARSTACK 0x1
  69. #define IDC_CMDTS_RESTACKALL 0x2
  70. #define IDC_CMDTS_PLAYFROMHERE 0x3
  71. #define IDC_CMDTS_UNSTACK 0x4
  72. #define IDC_CMDTS_PLAYNOW 0x5
  73. #define IDC_CMDTS_STOPAFTER 0x6
  74. #define IDC_CMDTS_STOPAFTER_NOREP 0x7
  75. #define IDC_CMDTS_PLAYNEXT 0x8
  76. #define IDC_CMDTS_QUEUE 0x9
  77. //
  78. void LVCB_DrawBackgroundRect(CPs_DrawContext* pDC);
  79. void LVCB_HeaderChanged(CP_HLISTVIEW _hListData);
  80. void LVCB_ItemSelected(CP_HLISTVIEW _hListData, const int iItemIDX, const CP_HPLAYLISTITEM hItem);
  81. void LVCB_ItemAction(CP_HLISTVIEW _hListData, const int iItemIDX, const CP_HPLAYLISTITEM hItem);
  82. void LVCB_ItemDrag(CP_HLISTVIEW _hListData, const int iItemIDX, const CP_HPLAYLISTITEM hItem);
  83. void LVCB_ItemRightClick(CP_HLISTVIEW _hListData, const int iItemIDX, const int iColumnIDX, const CP_HPLAYLISTITEM hItem);
  84. void LVCB_ColHeaderClick(CP_HLISTVIEW _hListData, const int iColIDX);
  85. void LVCB_UnhandledKeyPress(CP_HLISTVIEW _hListData, const int iVKey, const BOOL bAlt, const BOOL bCtrl, const BOOL bShift);
  86. CPe_CustomDrawColour LVCB_GetTrackStackItemColour(const void* pvItemData);
  87. CPe_CustomDrawColour LVCB_GetItemColour(const void* pvItemData);
  89. void CPlaylistWindow_CB_onCreate(CP_HINTERFACE hInterface, const RECT* pInitialPosition);
  90. void CPlaylistWindow_CB_onDraw(CP_HINTERFACE hInterface, CPs_DrawContext* pContext);
  91. void CPlaylistWindow_CB_onKeyDown(CP_HINTERFACE hInterface, const unsigned int iVKeyCode, const BOOL bAlt, const BOOL bCtrl, const BOOL bShift);
  92. void CPlaylistWindow_CB_onDropFiles(CP_HINTERFACE hInterface, HDROP hDrop);
  93. void CPlaylistWindow_CB_onPosChange(CP_HINTERFACE hInterface, const RECT* pNewPosition, const BOOL bSizeChanged);
  94. void CPlaylistWindow_CB_onFocus(CP_HINTERFACE hInterface, const BOOL bHasFocus);
  95. void CPlaylistWindow_CB_onCommandMessage(CP_HINTERFACE hInterface, const WPARAM wParam, const LPARAM lParam);
  97. void CPlaylistWindow_CB_onMouseMove(CP_HINTERFACE hInterface, const POINTS ptMouse, const unsigned short iFlags);
  98. void CPlaylistWindow_CB_onMouseButton_LUp(CP_HINTERFACE hInterface, const POINTS ptMouse, const unsigned short iFlags);
  99. LRESULT CPlaylistWindow_CB_onAppMessage(CP_HINTERFACE hInterface, const UINT uiMessage, const WPARAM wParam, const LPARAM lParam);
  100. void CPlaylistWindow_CB_onClose(CP_HINTERFACE hInterface);
  101. //
  102. void CPlaylistWindow_CreateSubparts();
  103. ////////////////////////////////////////////////////////////////////////////////
  104. //
  105. //
  106. //
  107. void CPlaylistWindow_Create()
  108. {
  109.     // Init playlist window state
  110.     glb_PLW_State.m_enWindowMode = wmQuiescent;
  111.     glb_PLW_State.m_pActiveCommandTarget = NULL;
  112.     glb_PLW_State.m_pFloatActiveCommandTarget = NULL;
  113.     glb_PLW_State.m_bMouseEventSet = FALSE;
  115.     // Create user interface window
  116.     windows.m_hifPlaylist = IF_Create();
  117.     IF_sethandler_onCreate(windows.m_hifPlaylist, CPlaylistWindow_CB_onCreate);
  118.     IF_sethandler_onDraw(windows.m_hifPlaylist, CPlaylistWindow_CB_onDraw);
  119.     IF_sethandler_onKeyDown(windows.m_hifPlaylist, CPlaylistWindow_CB_onKeyDown);
  120.     IF_sethandler_onDropFiles(windows.m_hifPlaylist, CPlaylistWindow_CB_onDropFiles);
  121.     IF_sethandler_onPosChange(windows.m_hifPlaylist, CPlaylistWindow_CB_onPosChange);
  122.     IF_sethandler_onFocus(windows.m_hifPlaylist, CPlaylistWindow_CB_onFocus);
  123.     IF_sethandler_onCommandMessage(windows.m_hifPlaylist, CPlaylistWindow_CB_onCommandMessage);
  124.     IF_sethandler_onAppMessage(windows.m_hifPlaylist, CPlaylistWindow_CB_onAppMessage);
  125.     IF_sethandler_onClose(windows.m_hifPlaylist, CPlaylistWindow_CB_onClose);
  127.     // Add interface subparts
  128.     CPlaylistWindow_CreateSubparts();
  130.     IF_SetMinSize(windows.m_hifPlaylist, &glb_pSkin->mpl_szMinWindow);
  131.     IF_OpenWindow(windows.m_hifPlaylist, "CoolPlayer Playlist", &options.playlist_window_pos, CPC_INTERFACE_STYLE_RESIZING);
  132.     IF_SetVisible(windows.m_hifPlaylist, options.show_playlist);
  133. }
  134. //
  135. //
  136. //
  137. void CPlaylistWindow_Destroy()
  138. {
  139.     // Cleanup windows
  140.     IF_CloseWindow(windows.m_hifPlaylist);
  141.     globals.m_hPlaylistViewControl = NULL;
  142. }
  143. //
  144. //
  145. //
  146. void CPlaylistWindow_CreateSubparts()
  147. {
  149.     IF_RemoveAllSubparts(windows.m_hifPlaylist);
  151.     {
  152.         CPs_CommandTarget* pCT_Cursor;
  153.         for(pCT_Cursor = glb_pSkin->mpl_pCommandTargets; pCT_Cursor; pCT_Cursor = (CPs_CommandTarget*)pCT_Cursor->m_pNext)
  154.         {
  155.             IF_AddSubPart_CommandButton(windows.m_hifPlaylist,
  156.                                         pCT_Cursor->m_dwAlign,
  157.                                         &pCT_Cursor->m_ptOffset,
  158.                                         pCT_Cursor->m_pStateImage,
  159.                                         pCT_Cursor->m_pfnVerb);
  160.         }
  161.     }
  163.     {
  164.         CPs_Indicator* pI_Cursor;
  165.         for(pI_Cursor = glb_pSkin->mpl_pIndicators; pI_Cursor; pI_Cursor = (CPs_Indicator*)pI_Cursor->m_pNext)
  166.         {
  167.             IF_AddSubPart_Indicator(windows.m_hifPlaylist,
  168.                                     pI_Cursor->m_pcName,
  169.                                     pI_Cursor->m_dwAlign,
  170.                                     &pI_Cursor->m_rAlign);
  171.         }
  172.     }
  173. }
  174. //
  175. //
  176. //
  177. void CPlaylistWindow_SetVisible(const BOOL bNewVisibleState)
  178. {
  179.     CheckMenuItem(globals.main_menu_popup, MENU_PLAYLIST, MF_BYCOMMAND | (bNewVisibleState ? MF_CHECKED : 0));
  180.     IF_SetVisible(windows.m_hifPlaylist, bNewVisibleState);
  181. }
  182. //
  183. //
  184. //
  185. void CPlaylistWindow_CreateListView()
  186. {
  187.     RECT rClient;
  188.     int iColumnIDX;
  190.     // Create listview control
  191.     GetClientRect(IF_GetHWnd(windows.m_hifPlaylist), &rClient);
  192.     globals.m_hPlaylistViewControl = CLV_Create(IF_GetHWnd(windows.m_hifPlaylist),
  193.                                      glb_pSkin->mpl_rList_Border.left, glb_pSkin->mpl_rList_Border.top,
  194.                                      (rClient.right - glb_pSkin->mpl_rList_Border.right) - glb_pSkin->mpl_rList_Border.left,
  195.                                      (rClient.bottom - glb_pSkin->mpl_rList_Border.bottom) - glb_pSkin->mpl_rList_Border.top);
  197.     // Setup callbacks
  198.     CLV_sethandler_DrawBackgroundRect(globals.m_hPlaylistViewControl, LVCB_DrawBackgroundRect);
  199.     CLV_sethandler_HeaderChanged(globals.m_hPlaylistViewControl, LVCB_HeaderChanged);
  200.     CLV_sethandler_ItemSelected(globals.m_hPlaylistViewControl, (wp_ItemCallback)LVCB_ItemSelected);
  201.     CLV_sethandler_ItemAction(globals.m_hPlaylistViewControl, (wp_ItemCallback)LVCB_ItemAction);
  202.     CLV_sethandler_ItemDrag(globals.m_hPlaylistViewControl, (wp_ItemCallback)LVCB_ItemDrag);
  203.     CLV_sethandler_ItemRightClick(globals.m_hPlaylistViewControl, (wp_ItemSubCallback)LVCB_ItemRightClick);
  204.     CLV_sethandler_ColHeaderClick(globals.m_hPlaylistViewControl, LVCB_ColHeaderClick);
  205.     CLV_sethandler_UnhandledKeyPress(globals.m_hPlaylistViewControl, LVCB_UnhandledKeyPress);
  207.     // Setup columns
  208.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  209.                   "Stack",
  210.                   options.playlist_column_widths[0],
  211.                   (wp_GetItemText)CPLI_GetTrackStackPos_AsText,
  212.                   CPLV_COLFLAG_NOHIDE);
  213.     CLV_SetColumnCustomDrawColour(globals.m_hPlaylistViewControl, PLAYLIST_TRACKSTACK, LVCB_GetTrackStackItemColour);
  214.     CLV_SetColumnAlign(globals.m_hPlaylistViewControl, PLAYLIST_TRACKSTACK, lcaRight);
  215.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  216.                   "Title",
  217.                   options.playlist_column_widths[1],
  218.                   (wp_GetItemText)CPLI_GetTrackName,
  219.                   options.playlist_column_visible[1] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  220.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  221.                   "Artist",
  222.                   options.playlist_column_widths[2],
  223.                   (wp_GetItemText)CPLI_GetArtist,
  224.                   options.playlist_column_visible[2] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  225.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  226.                   "Album",
  227.                   options.playlist_column_widths[3],
  228.                   (wp_GetItemText)CPLI_GetAlbum,
  229.                   options.playlist_column_visible[3] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  230.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  231.                   "Year",
  232.                   options.playlist_column_widths[4],
  233.                   (wp_GetItemText)CPLI_GetYear,
  234.                   options.playlist_column_visible[4] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  235.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  236.                   "TrackNum",
  237.                   options.playlist_column_widths[5],
  238.                   (wp_GetItemText)CPLI_GetTrackNum_AsText,
  239.                   options.playlist_column_visible[5] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  240.     CLV_SetColumnAlign(globals.m_hPlaylistViewControl, PLAYLIST_TRACKNUM, lcaRight);
  241.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  242.                   "Comment",
  243.                   options.playlist_column_widths[6],
  244.                   (wp_GetItemText)CPLI_GetComment,
  245.                   options.playlist_column_visible[6] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  246.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  247.                   "Genre",
  248.                   options.playlist_column_widths[7],
  249.                   (wp_GetItemText)CPLI_GetGenre,
  250.                   options.playlist_column_visible[7] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  251.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  252.                   "Path",
  253.                   options.playlist_column_widths[8],
  254.                   (wp_GetItemText)CPLI_GetPath,
  255.                   options.playlist_column_visible[8] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  256.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  257.                   "Filename",
  258.                   options.playlist_column_widths[9],
  259.                   (wp_GetItemText)CPLI_GetFilename,
  260.                   options.playlist_column_visible[9] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  261.     CLV_AddColumn(globals.m_hPlaylistViewControl,
  262.                   "Length",
  263.                   options.playlist_column_widths[10],
  264.                   (wp_GetItemText)CPLI_GetTrackLength_AsText,
  265.                   options.playlist_column_visible[10] ? CPLV_COLFLAG_NONE : CPLV_COLFLAG_HIDDEN);
  266.     CLV_SetColumnAlign(globals.m_hPlaylistViewControl, PLAYLIST_LENGTH, lcaRight);
  268.     for(iColumnIDX = 1; iColumnIDX <= PLAYLIST_last; iColumnIDX++)
  269.         CLV_SetColumnCustomDrawColour(globals.m_hPlaylistViewControl, iColumnIDX, LVCB_GetItemColour);
  271.     CLV_SetColumnOrder(globals.m_hPlaylistViewControl, options.playlist_column_seq, PLAYLIST_last+1);
  272.     CPL_cb_SetWindowToReflectList();
  273. }
  274. //
  275. //
  276. //
  277. int __cdecl exp_CompareStrings(const void *elem1, const void *elem2)
  278. {
  279.     const char* pcElem1 = *(const char**)elem1;
  280.     const char* pcElem2 = *(const char**)elem2;
  281.     return stricmp(pcElem1, pcElem2);
  282. }
  283. //
  284. //
  285. //
  286. void CPlaylistWindow_DestroyIPEdit()
  287. {
  288.     HWND hWnd_IPEdit;
  289.     if(!windows.wnd_playlist_IPEdit)
  290.         return;
  292.     hWnd_IPEdit = windows.wnd_playlist_IPEdit;
  293.     UnhookWindowsHookEx(globals.m_hhkListView_Posted);
  294.     globals.m_hhkListView_Posted = NULL;
  295.     windows.wnd_playlist_IPEdit = NULL;
  297.     DestroyWindow(hWnd_IPEdit);
  299.     // Write any dirty playlist items - Check all items because the selection could have
  300.     // changed by now
  301.    {
  302.         char cStatusMessage[1024];
  303.         CP_HPLAYLISTITEM hCursor;
  305.         SetCursor(LoadCursor(NULL, IDC_WAIT));
  306.         for(hCursor = CPL_GetFirstItem(globals.m_hPlaylist); hCursor; hCursor = CPLI_Next(hCursor))
  307.         {
  308.             if(CPLI_IsTagDirty(hCursor) == FALSE)
  309.                 continue;
  311.             sprintf(cStatusMessage, "Tagging "%s"", CPLI_GetFilename(hCursor));
  312.             CPIC_SetIndicatorValue("status", cStatusMessage);
  313.             UpdateWindow(IF_GetHWnd(windows.m_hifPlaylist));
  315.             CPLI_WriteTag(hCursor);
  316.         }
  317.         SetCursor(LoadCursor(NULL, IDC_ARROW));
  318.         CPIC_SetIndicatorValue("status", NULL);
  319.     } 
  320. }
  321. //
  322. //
  323. //
  324. LRESULT CALLBACK exp_ListViewHookProc_Posted(int iCode, WPARAM wParam, LPARAM lParam)
  325. {
  326.     if(iCode == HC_ACTION && windows.wnd_playlist_IPEdit)
  327.     {
  328.         MSG* pMSG = (MSG*)lParam;
  330.         // If any window (apart from the IP window) has a mouse click - close the IP window
  331.         if( (pMSG->message == WM_LBUTTONDOWN
  332.                 || pMSG->message == WM_MBUTTONDOWN
  333.                 || pMSG->message == WM_RBUTTONDOWN
  334.                 || pMSG->message == WM_NCLBUTTONDOWN
  335.                 || pMSG->message == WM_NCMBUTTONDOWN
  336.                 || pMSG->message == WM_NCRBUTTONDOWN)
  337.                 && pMSG->hwnd != windows.wnd_playlist_IPEdit)
  338.         {
  339.             // Get the classname to ensure that it's not our combo popup that's got the message
  340.             char cClassname[64];
  341.             GetClassName(pMSG->hwnd, cClassname, 64);
  342.             if(strcmp("ComboLBox", cClassname))
  343.                 CPlaylistWindow_DestroyIPEdit();
  344.         }
  345.     }
  347.     if(globals.m_hhkListView_Posted)
  348.         return CallNextHookEx(globals.m_hhkListView_Posted, iCode, wParam, lParam);
  349.     else
  350.         return 0;
  351. }
  352. //
  353. //
  354. //
  355. void CPlaylistWindow_TrackStackMenu(iItem)
  356. {
  357.     HWND hWndList;
  358.     POINT ptItem;
  359.     RECT rSubItem;
  360.     HMENU hmMenu;
  361.     UINT uiMenuCommand;
  362.     int iSearchItemIDX;
  363.     CP_HPLAYLISTITEM hClickedItem;
  364.     CPe_ItemStackState enClickedItemState;
  365.     BOOL bMultipleSelection;
  367.     // We want to get the subitem's rect in the co-ordinate space of the dialog
  368.     hWndList = CLV_GetHWND(globals.m_hPlaylistViewControl);
  369.     CLV_GetItemSubRect(globals.m_hPlaylistViewControl, &rSubItem, iItem, 0);
  371.     // Are there multiple items selected?
  372.     iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  373.     if(iSearchItemIDX != CPC_INVALIDITEM)
  374.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX);
  375.     if(iSearchItemIDX != CPC_INVALIDITEM)
  376.         bMultipleSelection = TRUE;
  377.     else
  378.         bMultipleSelection = FALSE;
  380.     ptItem.x = rSubItem.left;
  381.     ptItem.y = rSubItem.bottom;
  382.     ClientToScreen(hWndList, &ptItem);
  384.     // Create menu
  385.     hmMenu = CreatePopupMenu();
  387.     hClickedItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iItem);
  388.     enClickedItemState = CPL_Stack_GetItemState(globals.m_hPlaylist, hClickedItem);
  389.     if(enClickedItemState != issUnstacked)
  390.     {
  391.         AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_PLAYFROMHERE, "Play from here");
  392.         SetMenuDefaultItem(hmMenu, IDC_CMDTS_PLAYFROMHERE, FALSE);
  394.         if(enClickedItemState != issStacked_Top)
  395.         {
  396.             AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_PLAYNEXT, "Play next");
  397.             AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_UNSTACK, "Unstack");
  398.         }
  400.         // Not played yet?
  401.         if(enClickedItemState == issStacked || enClickedItemState == issStacked_Top)
  402.         {
  403.             if(options.repeat_playlist == TRUE)
  404.             {
  405.                 AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_STOPAFTER, "Repeat after this");
  406.                 AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_STOPAFTER_NOREP, "Stop after this (repeat->off)");
  407.             }
  408.             else
  409.             {
  410.                 AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_STOPAFTER, "Stop after this");
  411.             }
  412.         }
  414.         if(enClickedItemState != issStacked_Top)
  415.             AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_QUEUE, "Queue at end");
  416.     }
  417.     else
  418.     {
  419.         AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_PLAYNOW, "Play now");
  420.         SetMenuDefaultItem(hmMenu, IDC_CMDTS_PLAYNOW, FALSE);
  422.         AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_PLAYNEXT, "Play next");
  423.         AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_QUEUE, "Queue at end");
  424.     }
  426.     AppendMenu(hmMenu, MF_SEPARATOR, 0, NULL);
  427.     AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_CLEARSTACK, "Clear stack");
  428.     AppendMenu(hmMenu, MF_STRING, IDC_CMDTS_RESTACKALL, "Restack all");
  430.     uiMenuCommand = TrackPopupMenuEx( hmMenu,
  431.                                       TPM_NONOTIFY
  432.                                       | TPM_RETURNCMD
  433.                                       | TPM_RIGHTBUTTON,
  434.                                       ptItem.x, ptItem.y,
  435.                                       IF_GetHWnd(windows.m_hifPlaylist),
  436.                                       NULL);
  437.     DestroyMenu(hmMenu);
  439.     if(uiMenuCommand == IDC_CMDTS_CLEARSTACK)
  440.     {
  441.         CPL_Stack_Clear(globals.m_hPlaylist);
  442.     }
  443.     else if(uiMenuCommand == IDC_CMDTS_RESTACKALL)
  444.     {
  445.         CPL_Stack_RestackAll(globals.m_hPlaylist);
  446.     }
  447.     else if(uiMenuCommand == IDC_CMDTS_PLAYFROMHERE)
  448.     {
  449.         CPL_Stack_SetCursor(globals.m_hPlaylist, hClickedItem);
  450.         CPL_PlayItem(globals.m_hPlaylist, TRUE, pmCurrentItem);
  451.     }
  452.     else if(uiMenuCommand == IDC_CMDTS_UNSTACK)
  453.     {
  454.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  455.         while(iSearchItemIDX != CPC_INVALIDITEM)
  456.         {
  457.             CPL_Stack_Remove(globals.m_hPlaylist, (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX) );
  458.             iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX);
  459.         }
  460.     }
  461.     else if(uiMenuCommand == IDC_CMDTS_PLAYNOW)
  462.     {
  463.         CP_HPLAYLISTITEM hFirstItem;
  465.         CPL_Stack_ClipFromCurrent(globals.m_hPlaylist);
  466.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  467.         hFirstItem = NULL;
  468.         while(iSearchItemIDX != CPC_INVALIDITEM)
  469.         {
  470.             CP_HPLAYLISTITEM hItem;
  472.             hItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX);
  473.             if(!hFirstItem)
  474.                 hFirstItem = hItem;
  475.             CPL_Stack_Append(globals.m_hPlaylist, hItem);
  476.             iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX);
  477.         }
  478.         CPL_Stack_SetCursor(globals.m_hPlaylist, hFirstItem);
  479.         CPL_PlayItem(globals.m_hPlaylist, TRUE, pmCurrentItem);
  480.     }
  481.     else if(uiMenuCommand == IDC_CMDTS_STOPAFTER)
  482.     {
  483.         CPL_Stack_ClipFromItem(globals.m_hPlaylist, hClickedItem);
  484.     }
  485.     else if(uiMenuCommand == IDC_CMDTS_STOPAFTER_NOREP)
  486.     {
  487.         options.repeat_playlist = FALSE;
  488.         InvalidateRect(windows.wnd_main, NULL, FALSE);
  489.         CPL_Stack_ClipFromItem(globals.m_hPlaylist, hClickedItem);
  490.     }
  491.     else if(uiMenuCommand == IDC_CMDTS_PLAYNEXT)
  492.     {
  493.         iSearchItemIDX = CLV_GetPrevSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  494.         while(iSearchItemIDX != CPC_INVALIDITEM)
  495.         {
  496.             CPL_Stack_PlayNext(globals.m_hPlaylist, (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX) );
  497.             iSearchItemIDX = CLV_GetPrevSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX);
  498.         }
  499.     }
  500.     else if(uiMenuCommand == IDC_CMDTS_QUEUE)
  501.     {
  502.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  503.         while(iSearchItemIDX != CPC_INVALIDITEM)
  504.         {
  505.             CP_HPLAYLISTITEM hItem;
  507.             hItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX);
  509.             CPL_Stack_Remove(globals.m_hPlaylist, hItem);
  510.             CPL_Stack_Append(globals.m_hPlaylist, hItem);
  511.             iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX);
  512.         }
  513.     }
  514. }
  515. //
  516. //
  517. //
  518. void CPlaylistWindow_RenameMenu(const int iItem, const int iSubItem)
  519. {
  520.     HWND hWndList;
  521.     POINT ptItem;
  522.     RECT rSubItem;
  523.     HMENU hmMenu;
  524.     UINT uiMenuCommand;
  526.     // We want to get the subitem's rect in the co-ordinate space of the dialog
  527.     hWndList = CLV_GetHWND(globals.m_hPlaylistViewControl);
  528.     CLV_GetItemSubRect(globals.m_hPlaylistViewControl, &rSubItem, iItem, iSubItem);
  529.     ptItem.x = rSubItem.left;
  530.     ptItem.y = rSubItem.bottom;
  531.     ClientToScreen(hWndList, &ptItem);
  533.     // Create menu
  534.     hmMenu = CreatePopupMenu();
  536.     AppendMenu(hmMenu, MF_STRING, (DWORD)rwsArtistAlbumNumberTitle, "Rename to <artist> - <album> - <tracknum> - <title>");
  537.     AppendMenu(hmMenu, MF_STRING, (DWORD)rwsArtistNumberTitle, "Rename to <artist> - <tracknum> - <title>");
  538.     AppendMenu(hmMenu, MF_STRING, (DWORD)rwsAlbumNumberTitle, "Rename to <album> - <tracknum> - <title>");
  539.     AppendMenu(hmMenu, MF_STRING, (DWORD)rwsAlbumNumber, "Rename to <album> - <tracknum>");
  540.     AppendMenu(hmMenu, MF_STRING, (DWORD)rwsNumberTitle, "Rename to <tracknum> - <title>");
  541.     AppendMenu(hmMenu, MF_STRING, (DWORD)rwsTitle, "Rename to <title>");
  543.     uiMenuCommand = TrackPopupMenuEx( hmMenu,
  544.                                       TPM_NONOTIFY
  545.                                       | TPM_RETURNCMD
  546.                                       | TPM_RIGHTBUTTON,
  547.                                       ptItem.x, ptItem.y,
  548.                                       IF_GetHWnd(windows.m_hifPlaylist),
  549.                                       NULL);
  550.     DestroyMenu(hmMenu);
  552.     if(uiMenuCommand)
  553.     {
  554.         int iSearchItemIDX;
  555.         int iNumberOfErrors;
  557.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  558.         iNumberOfErrors = 0;
  559.         while(iSearchItemIDX != CPC_INVALIDITEM)
  560.         {
  561.             BOOL bSucceeded;
  562.             bSucceeded = CPLI_RenameTrack((CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX),
  563.                                           (CPe_FilenameFormat)uiMenuCommand);
  564.             iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX);
  566.             if(!bSucceeded)
  567.                 iNumberOfErrors++;
  568.         }
  570.         if(iNumberOfErrors > 0)
  571.         {
  572.             MessageBox(IF_GetHWnd(windows.m_hifPlaylist),
  573.                        "Some files could not be renamed.nnThis could be because they are either currently playing or are read-only.",
  574.                        "Error",
  575.                        MB_OK | MB_ICONASTERISK);
  576.         }
  577.     }
  578. }
  579. //
  580. //
  581. //
  582. void CPlaylistWindow_CreateIPEdit(const int iItem, const int iSubItem)
  583. {
  584.     RECT rSubItem;
  585.     const char* pcClass;
  586.     DWORD dwStyle;
  587.     int iSearchItemIDX;
  588.     UINT uiControlID;
  589.     BOOL bClearNonSelectedItems;
  590.     CP_HPLAYLISTITEM hClickedItem;
  591.     HWND hWndList;
  592.     int iNumItemsSelected;
  594.     // If the clicked item is not read/write then skip this
  595.     hClickedItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iItem);
  596.     if(CPLI_GetReadWriteState(hClickedItem) != rwsReadWrite)
  597.     {
  598.         MessageBox(windows.m_hWndPlaylist, "This file's ID3 tag cannot be updated.  This is because CoolPlayer cannot write to this file.", "Cannot update tag", MB_OK | MB_ICONSTOP);
  599.         return;
  600.     }
  602.     // For some sub items it is not logical to multi update - action these
  603.     if(iSubItem == PLAYLIST_TITLE)
  604.         bClearNonSelectedItems = TRUE;
  605.     else
  606.         bClearNonSelectedItems = FALSE;
  608.     // Go through the selected items and remove the selection of items that
  609.     // cannot be written to (eg because of a read only file)
  610.     iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  611.     iNumItemsSelected = 1;
  612.     for(;iSearchItemIDX != -1; iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX))
  613.     {
  614.         CP_HPLAYLISTITEM hItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX);
  615.         CPLI_ReadTag(hItem);
  617.         // We've already checked this item
  618.         if(iSearchItemIDX == iItem)
  619.             continue;
  621.         iNumItemsSelected++;
  622.         if(bClearNonSelectedItems == TRUE || CPLI_GetReadWriteState(hItem) != rwsReadWrite)
  623.             CLV_SetItemSelected(globals.m_hPlaylistViewControl, iSearchItemIDX, FALSE);
  624.     }
  626.     // If the "track number" column was clicked - and there are multiple selections - auto number them
  627.     if(iSubItem == PLAYLIST_TRACKNUM && iNumItemsSelected > 1)
  628.     {
  629.         char cStatusMessage[1024];
  630.         int iTrackNumber;
  632.         // Autonumber
  633.         SetCursor(LoadCursor(NULL, IDC_WAIT));
  634.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  635.         iTrackNumber = 1;
  636.         for(;iSearchItemIDX != CPC_INVALIDITEM; iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX))
  637.         {
  638.             CP_HPLAYLISTITEM hItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX);
  640.             sprintf(cStatusMessage, "Tagging "%s"", CPLI_GetFilename(hItem));
  641.   CP_TRACE1("status: %s",cStatusMessage);
  642.            CPIC_SetIndicatorValue("status", cStatusMessage);
  643.             UpdateWindow(IF_GetHWnd(windows.m_hifPlaylist));
  645. //            CPLI_SetTrackNum(hItem, iTrackNumber);
  646.             CPLI_WriteTag(hItem);
  647.             iTrackNumber++;
  648.         }
  649.         SetCursor(LoadCursor(NULL, IDC_ARROW));
  650.         CPIC_SetIndicatorValue("status", NULL);
  651.         return;
  652.     }
  654.     // If the length was clicked - work out the lengths for all selected items
  655.     if(iSubItem == PLAYLIST_LENGTH)
  656.     {
  657.         char cStatusMessage[1024];
  659.         SetCursor(LoadCursor(NULL, IDC_WAIT));
  660.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  661.         for(; iSearchItemIDX != CPC_INVALIDITEM; iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX))
  662.         {
  663.             CP_HPLAYLISTITEM hItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX);
  665.             CPLI_CalculateLength(hItem);
  666.             sprintf(cStatusMessage, "Tagging "%s"", CPLI_GetFilename(hItem));
  667.             
  668. CPIC_SetIndicatorValue("status", cStatusMessage);
  669. CP_TRACE1("status: %s",cStatusMessage);
  670.            UpdateWindow(IF_GetHWnd(windows.m_hifPlaylist));
  672.             CPLI_WriteTag(hItem);
  673.         }
  674.         SetCursor(LoadCursor(NULL, IDC_ARROW));
  675.         CPIC_SetIndicatorValue("status", NULL);
  676.         return;
  677.     }
  679.     // We want to get the subitem's rect in the co-ordinate space of the dialog
  680.     hWndList = CLV_GetHWND(globals.m_hPlaylistViewControl);
  681.     CLV_GetItemSubRect(globals.m_hPlaylistViewControl, &rSubItem, iItem, iSubItem);
  682.     ClientToScreen(hWndList, (POINT*)&rSubItem);
  683.     ClientToScreen(hWndList, ((POINT*)&rSubItem)+1);
  684.     ScreenToClient(IF_GetHWnd(windows.m_hifPlaylist), (POINT*)&rSubItem);
  685.     ScreenToClient(IF_GetHWnd(windows.m_hifPlaylist), ((POINT*)&rSubItem)+1);
  687.     if(iSubItem == PLAYLIST_GENRE)
  688.     {
  689.         int iRectHeight = rSubItem.bottom-rSubItem.top;
  690.         int iListHeight = iRectHeight<<3;
  692.         InflateRect(&rSubItem, 2, 2);
  693.         pcClass = "COMBOBOX";
  694.         uiControlID = IDC_PL_FLOATINGCOMBO;
  695.         dwStyle = CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL;
  697.         rSubItem.bottom += (rSubItem.bottom-rSubItem.top)<<3;
  698.     }
  699.     else
  700.     {
  701.         InflateRect(&rSubItem, 2, 2);
  702.         pcClass = "EDIT";
  703.         dwStyle = ES_AUTOHSCROLL;
  704.         uiControlID = IDC_PL_FLOATINGEDIT;
  706.         if(iSubItem == PLAYLIST_TRACKNUM || iSubItem == PLAYLIST_YEAR)
  707.             dwStyle |= ES_NUMBER;
  708.     }
  710.     // Setup window class and style (the Genre window will be a combo)
  711.     globals.m_bIP_InhibitUpdates = TRUE;
  712.     windows.wnd_playlist_IPEdit = CreateWindow( pcClass,
  713.                                   "",
  714.                                   WS_CHILD
  715.                                   | WS_BORDER
  716.                                   | WS_CLIPSIBLINGS
  717.                                   | dwStyle,
  718.                                   rSubItem.left, rSubItem.top,
  719.                                   rSubItem.right-rSubItem.left, rSubItem.bottom-rSubItem.top,
  720.                                   IF_GetHWnd(windows.m_hifPlaylist),
  721.                                   (HMENU)uiControlID,
  722.                                   GetModuleHandle(NULL), NULL);
  723.     SetWindowPos(windows.wnd_playlist_IPEdit, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
  724.     ShowWindow(windows.wnd_playlist_IPEdit, SW_SHOW);
  725.     SetFocus(windows.wnd_playlist_IPEdit);
  727.     // Setup the font in the control
  728.     SendMessage(windows.wnd_playlist_IPEdit, WM_SETFONT, (WPARAM)glb_pSkin->mpl_hfFont, MAKELPARAM(TRUE, 0));
  730.     // Hook the listview window (so that we can dismiss on VScroll)
  731.     globals.m_hhkListView_Posted = SetWindowsHookEx(WH_GETMESSAGE, exp_ListViewHookProc_Posted, NULL, GetCurrentThreadId());
  733.     // Add the genre items to the list
  734.     if(iSubItem == PLAYLIST_GENRE)
  735.     {
  736.         int iGenreIDX;
  737.         for(iGenreIDX = 0; iGenreIDX < CIC_NUMGENRES; iGenreIDX++)
  738.         {
  739.             int iNewItemIDX = SendMessage(windows.wnd_playlist_IPEdit,
  740.                                           CB_ADDSTRING,
  741.                                           0L,
  742.                                           (LPARAM)glb_pcGenres[iGenreIDX]);
  743.             SendMessage(windows.wnd_playlist_IPEdit, CB_SETITEMDATA, (WPARAM)iNewItemIDX, (LPARAM)iGenreIDX);
  744.         }
  745.     }
  747.     // Setup the initial string
  748.     globals.m_iInPlaceSubItem = iSubItem;
  749.     {
  750.         switch(iSubItem)
  751.         {
  752.         case PLAYLIST_TITLE:
  753.             SendMessage(windows.wnd_playlist_IPEdit, WM_SETTEXT, 0L, (LPARAM)CPLI_GetTrackName(hClickedItem));
  754.             if(!options.support_id3v2)
  755.                 SendMessage(windows.wnd_playlist_IPEdit, EM_LIMITTEXT, 30, 0);
  756.             break;
  758.         case PLAYLIST_ARTIST:
  759.             SendMessage(windows.wnd_playlist_IPEdit, WM_SETTEXT, 0L, (LPARAM)CPLI_GetArtist(hClickedItem));
  760.             if(!options.support_id3v2)
  761.                 SendMessage(windows.wnd_playlist_IPEdit, EM_LIMITTEXT, 30, 0);
  762.             break;
  764.         case PLAYLIST_ALBUM:
  765.             SendMessage(windows.wnd_playlist_IPEdit, WM_SETTEXT, 0L, (LPARAM)CPLI_GetAlbum(hClickedItem));
  766.             if(!options.support_id3v2)
  767.                 SendMessage(windows.wnd_playlist_IPEdit, EM_LIMITTEXT, 30, 0);
  768.             break;
  770.         case PLAYLIST_YEAR:
  771.             SendMessage(windows.wnd_playlist_IPEdit, WM_SETTEXT, 0L, (LPARAM)CPLI_GetYear(hClickedItem));
  772.             if(!options.support_id3v2)
  773.                 SendMessage(windows.wnd_playlist_IPEdit, EM_LIMITTEXT, 4, 0);
  774.             break;
  776.         case PLAYLIST_TRACKNUM:
  777.             {
  778.                 char cTrackNum[33];
  779.                 unsigned char iTrackNum;
  781.                 iTrackNum = CPLI_GetTrackNum(hClickedItem);
  782.                 if(iTrackNum != CIC_INVALIDTRACKNUM && iTrackNum != 0)
  783.                     SendMessage(windows.wnd_playlist_IPEdit, WM_SETTEXT, 0L, (LPARAM)itoa(iTrackNum, cTrackNum, 10));
  784.             }
  785.             SendMessage(windows.wnd_playlist_IPEdit, EM_LIMITTEXT, 3, 0);
  786.             break;
  788.         case PLAYLIST_COMMENT:
  789.             SendMessage(windows.wnd_playlist_IPEdit, WM_SETTEXT, 0L, (LPARAM)CPLI_GetComment(hClickedItem));
  790.             if(!options.support_id3v2)
  791.                 SendMessage(windows.wnd_playlist_IPEdit, EM_LIMITTEXT, 28, 0);
  792.             break;
  794.         case PLAYLIST_GENRE:
  795.             SendMessage(windows.wnd_playlist_IPEdit, CB_SELECTSTRING, (WPARAM)-1, (LPARAM)CPLI_GetGenre(hClickedItem));
  796.             break;
  797.         }
  798.     }
  799.     globals.m_bIP_InhibitUpdates = FALSE;
  800. }
  801. //
  802. //
  803. //
  804. BOOL CPlaylistWindow_OffsetSelectedItems(const int iOffset)
  805. {
  806.     int iNumItemsInList;
  807.     int iStartItem, iTermItem, iItemInc, iItemIDX;
  808.     int iScanStartItem, iScanTermItem;
  809.     CP_HPLAYLISTITEM hActive;
  810.     int iNewFocusItemIDX;
  812.     if(iOffset == 0)
  813.         return FALSE;
  815.     // Determine which direction to move in list
  816.     iNumItemsInList = CLV_GetItemCount(globals.m_hPlaylistViewControl);
  817.     if(iOffset < 0)
  818.     {
  819.         iStartItem = 0;
  820.         iTermItem = iNumItemsInList;
  821.         iItemInc = 1;
  823.         iScanStartItem = 0;
  824.         iScanTermItem = -iOffset;
  825.     }
  826.     else
  827.     {
  828.         iStartItem = iNumItemsInList-1;
  829.         iTermItem = -1;
  830.         iItemInc = -1;
  832.         iScanStartItem = iNumItemsInList-1;
  833.         iScanTermItem = iScanStartItem-iOffset;
  834.     }
  836.     // Ensure that the selection can move intact (ie there are no selected items that could
  837.     // be "scrolled off" the list
  838.     for(iItemIDX = iScanStartItem; iItemIDX != iScanTermItem; iItemIDX += iItemInc)
  839.     {
  840.         if(CLV_IsItemSelected(globals.m_hPlaylistViewControl, iItemIDX))
  841.             return FALSE;
  842.     }
  844.     iNewFocusItemIDX = CLV_GetFocusItem(globals.m_hPlaylistViewControl) + iOffset;
  845.     CLV_SetFocusItem(globals.m_hPlaylistViewControl, iNewFocusItemIDX);
  846.     CLV_EnsureVisible(globals.m_hPlaylistViewControl, iNewFocusItemIDX);
  849.     // Go through all the items scanning the -ve offset item and swapping it
  850.     // in if needed
  851.     for(iItemIDX = iStartItem; iItemIDX != iTermItem; iItemIDX += iItemInc)
  852.     {
  853.         // Work out the item to probe
  854.         const int iProbeItemIDX = iItemIDX - iOffset;
  855.         CP_HPLAYLISTITEM hItem, hItem_Probe, hReindexCursor;
  856.         CP_HPLAYLISTITEM hReindexStart, hReindexEnd;
  857.         int iReindexItemIDX;
  859.         // If this probe item is unselected (or out of bounds) - set the current item's selection
  860.         // to unselected and try the next item
  861.         if(iProbeItemIDX < 0 || iProbeItemIDX >= iNumItemsInList
  862.                 || CLV_IsItemSelected(globals.m_hPlaylistViewControl, iProbeItemIDX) == FALSE)
  863.         {
  864.             CLV_SetItemSelected(globals.m_hPlaylistViewControl, iItemIDX, FALSE);
  865.             continue;
  866.         }
  868.         // The probe item is selected - move that item over to this item
  869.         // - If the item is moving down it needs to be inserted after - otherwise it
  870.         // needs to be inserted before
  871.         hItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iItemIDX);
  872.         hItem_Probe = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iProbeItemIDX);
  873.         if(iOffset > 0)
  874.         {
  875.             // Get start reindex item
  876.             hReindexStart = CPLI_Next(hItem_Probe);
  877.             if(hReindexStart == NULL)
  878.                 hReindexStart = CPL_GetFirstItem(globals.m_hPlaylist);
  880.             CPL_InsertItemAfter(globals.m_hPlaylist, hItem, hItem_Probe);
  882.             // Get end reindex item
  883.             hReindexEnd = CPLI_Next(hItem_Probe);
  885.             // Perform reindexing
  886.             iReindexItemIDX = iProbeItemIDX;
  887.             for(hReindexCursor = hReindexStart; hReindexCursor != hReindexEnd; hReindexCursor = CPLI_Next(hReindexCursor))
  888.             {
  889.                 CPLI_SetCookie(hReindexCursor, iReindexItemIDX);
  890.                 CPL_cb_OnItemUpdated(hReindexCursor);
  891.                 iReindexItemIDX++;
  892.             }
  893.         }
  894.         else
  895.         {
  896.             // Get start reindex item
  897.             hReindexStart = CPLI_Prev(hItem_Probe);
  898.             if(hReindexStart == NULL)
  899.                 hReindexStart = CPL_GetLastItem(globals.m_hPlaylist);
  901.             CPL_InsertItemBefore(globals.m_hPlaylist, hItem, hItem_Probe);
  903.             // Get end reindex item
  904.             hReindexEnd = CPLI_Prev(hItem_Probe);
  906.             // Perform reindexing
  907.             iReindexItemIDX = iProbeItemIDX;
  908.             for(hReindexCursor = hReindexStart; hReindexCursor != hReindexEnd; hReindexCursor = CPLI_Prev(hReindexCursor))
  909.             {
  910.                 CPLI_SetCookie(hReindexCursor, iReindexItemIDX);
  911.                 CPL_cb_OnItemUpdated(hReindexCursor);
  912.                 iReindexItemIDX--;
  913.             }
  914.         }
  916.         // Set the item's selection
  917.         CLV_SetItemSelected(globals.m_hPlaylistViewControl, iItemIDX, TRUE);
  918.     }
  920.     // Set the "active" item in the list
  921.     hActive = CPL_GetActiveItem(globals.m_hPlaylist);
  922.     return TRUE;
  923. }
  924. //
  925. //
  926. //
  927. void CPlaylistWindow_CB_onMouseMove(CP_HINTERFACE hInterface, const POINTS _ptMouse, const unsigned short iFlags)
  928. {
  929.     POINT ptMouse;
  930.     int iHitItem;
  932.     ptMouse.x = _ptMouse.x;
  933.     ptMouse.y = _ptMouse.y;
  935.     // Which item is this over?
  936.     ClientToScreen(IF_GetHWnd(windows.m_hifPlaylist), &ptMouse);
  937.     ScreenToClient(CLV_GetHWND(globals.m_hPlaylistViewControl), &ptMouse);
  938.     iHitItem = CLV_GetNearestItem(globals.m_hPlaylistViewControl, &ptMouse);
  940.     // Perform drag
  941.     if(iHitItem != CPC_INVALIDITEM && iHitItem != globals.main_drag_anchor_point)
  942.     {
  943.         BOOL bDragResult;
  944.         bDragResult = CPlaylistWindow_OffsetSelectedItems(iHitItem - globals.main_drag_anchor_point);
  946.         if(bDragResult == TRUE)
  947.             globals.main_drag_anchor_point = iHitItem;
  948.     }
  949. }
  950. //
  951. //
  952. //
  953. void CPlaylistWindow_CB_onMouseButton_LUp(CP_HINTERFACE hInterface, const POINTS ptMouse, const unsigned short iFlags)
  954. {
  955.     IF_ReleaseMouseCapture(windows.m_hifPlaylist);
  956. }
  957. //
  958. //
  959. //
  960. void CPlaylistWindow_WM_COMMAND_IDC_PL_FLOATINGEDIT(WPARAM wParam, LPARAM lParam)
  961. {
  962.     if(HIWORD(wParam) == EN_KILLFOCUS)
  963.     {
  964.         // Floating combo control looses focus - destroy it (after breaking out of kill focus context)
  965.         IF_PostAppMessage(windows.m_hifPlaylist, CPPLM_DESTROYINPLACE, 0L, 0L);
  966.     }
  967.     else if(HIWORD(wParam) == EN_CHANGE && globals.m_bIP_InhibitUpdates == FALSE)
  968.     {
  969.         int iSearchItemIDX;
  970.         char* pcEditText;
  971.         DWORD dwTextLen;
  973.         // Get the text from the control
  974.         dwTextLen = SendMessage(windows.wnd_playlist_IPEdit, WM_GETTEXTLENGTH, 0L, 0L) + 1;
  975.         pcEditText = (char*)malloc( dwTextLen * sizeof(char));
  976.         SendMessage(windows.wnd_playlist_IPEdit, WM_GETTEXT, (WPARAM)dwTextLen, (LPARAM)pcEditText);
  978.         // Update all of the selected items
  979.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  980.         for(;iSearchItemIDX != -1; iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX))
  981.         {
  982.             CP_HPLAYLISTITEM hPlaylistItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX);
  984.             switch(globals.m_iInPlaceSubItem)
  985.             {
  986.             case PLAYLIST_TITLE:
  987.                 CPLI_SetTrackName(hPlaylistItem, pcEditText);
  988.                 break;
  990.             case PLAYLIST_ARTIST:
  991.                 CPLI_SetArtist(hPlaylistItem, pcEditText);
  992.                 break;
  994.             case PLAYLIST_ALBUM:
  995.                 CPLI_SetAlbum(hPlaylistItem, pcEditText);
  996.                 break;
  998.             case PLAYLIST_YEAR:
  999.                 CPLI_SetYear(hPlaylistItem, pcEditText);
  1000.                 break;
  1002.             case PLAYLIST_TRACKNUM:
  1003.                 CPLI_SetTrackNum_AsText(hPlaylistItem, pcEditText);
  1004.                 break;
  1006.             case PLAYLIST_COMMENT:
  1007.                 CPLI_SetComment(hPlaylistItem, pcEditText);
  1008.                 break;
  1009.             }
  1010.         }
  1012.         free(pcEditText);
  1013.     }
  1014. }
  1015. //
  1016. //
  1017. //
  1018. void CPlaylistWindow_WM_COMMAND_IDC_PL_FLOATINGCOMBO(WPARAM wParam, LPARAM lParam)
  1019. {
  1020.     if(HIWORD(wParam) == CBN_KILLFOCUS)
  1021.     {
  1022.         // Floating combo control looses focus - destroy it (after breaking out of kill focus context)
  1023.         IF_PostAppMessage(windows.m_hifPlaylist, CPPLM_DESTROYINPLACE, 0L, 0L);
  1024.     }
  1025.     else if(HIWORD(wParam) == CBN_SELCHANGE && globals.m_bIP_InhibitUpdates == FALSE)
  1026.     {
  1027.         int iSearchItemIDX;
  1028.         int iSelectedItemIDX;
  1029.         unsigned char cNewGenre;
  1031.         iSelectedItemIDX = SendMessage(windows.wnd_playlist_IPEdit, CB_GETCURSEL, 0L, 0L);
  1032.         cNewGenre = (unsigned char)SendMessage(windows.wnd_playlist_IPEdit, CB_GETITEMDATA, (WPARAM)iSelectedItemIDX, 0L);
  1034.         // Update all of the selected items
  1035.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  1036.         for(;iSearchItemIDX != -1; iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, iSearchItemIDX))
  1037.         {
  1038.             CP_HPLAYLISTITEM hPlaylistItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX);
  1039.             CPLI_SetGenreIDX(hPlaylistItem, cNewGenre);
  1040.         }
  1041.     }
  1042. }
  1043. //
  1044. //
  1045. //
  1046. void LVCB_DrawBackgroundRect(CPs_DrawContext* pDC)
  1047. {
  1048.     RECT rClient;
  1049.     GetClientRect(IF_GetHWnd(windows.m_hifPlaylist), &rClient);
  1051.     // Draw the window background
  1052.     CPIG_TiledFill(pDC, &rClient, &glb_pSkin->mpl_rBackground_SourceTile, glb_pSkin->mpl_pBackground, CIC_TILEDFILOPTIONS_NONE);
  1053. }
  1054. //
  1055. //
  1056. //
  1057. void CPlaylistWindow_CB_onClose(CP_HINTERFACE hInterface)
  1058. {
  1059.     options.show_playlist = FALSE;
  1060.     CPlaylistWindow_SetVisible(FALSE);
  1061. }
  1062. //
  1063. //
  1064. //
  1065. void LVCB_HeaderChanged(CP_HLISTVIEW _hListData)
  1066. {
  1067.     CLV_GetColumnOrder(_hListData, options.playlist_column_seq, PLAYLIST_last + 1);
  1068.     CLV_GetColumnWidths(_hListData, options.playlist_column_widths, PLAYLIST_last + 1);
  1069.     CLV_GetColumnVisibleState(_hListData, options.playlist_column_visible, PLAYLIST_last + 1);
  1070. }
  1071. //
  1072. //
  1073. //
  1074. void LVCB_ItemSelected(CP_HLISTVIEW _hListData, const int iItemIDX, const CP_HPLAYLISTITEM hItem)
  1075. {
  1076.     if(options.read_id3_tag_of_selected)
  1077.         CPLI_ReadTag(hItem);
  1078. }
  1079. //
  1080. //
  1081. //
  1082. void LVCB_ItemAction(CP_HLISTVIEW _hListData, const int iItemIDX, const CP_HPLAYLISTITEM hItem)
  1083. {
  1084.     // Setup & play the active item
  1085.     if(CPL_Stack_GetItemState(globals.m_hPlaylist, hItem) == issUnstacked)
  1086.     {
  1087.         CPL_Stack_ClipFromCurrent(globals.m_hPlaylist);
  1088.         CPL_Stack_Append(globals.m_hPlaylist, hItem);
  1089.         CPL_SetActiveItem(globals.m_hPlaylist, hItem);
  1090.         CPL_PlayItem(globals.m_hPlaylist, TRUE, pmCurrentItem);
  1091.     }
  1092.     else
  1093.     {
  1094.         CPL_SetActiveItem(globals.m_hPlaylist, hItem);
  1095.         CPL_PlayItem(globals.m_hPlaylist, TRUE, pmCurrentItem);
  1096.     }
  1097. }
  1098. //
  1099. //
  1100. //
  1101. void LVCB_ItemDrag(CP_HLISTVIEW _hListData, const int iItemIDX, const CP_HPLAYLISTITEM hItem)
  1102. {
  1103.     globals.main_drag_anchor_point = iItemIDX;
  1104.     IF_SetMouseCapture(windows.m_hifPlaylist, CPlaylistWindow_CB_onMouseMove, CPlaylistWindow_CB_onMouseButton_LUp);
  1105. }
  1106. //
  1107. //
  1108. //
  1109. void LVCB_ColHeaderClick(CP_HLISTVIEW _hListData, const int iColIDX)
  1110. {
  1111.     // Work out assending or decending
  1112.     BOOL bDesc;
  1113.     if(iColIDX == globals.m_iLastPlaylistSortColoumn)
  1114.     {
  1115.         globals.m_iLastPlaylistSortColoumn = -1;
  1116.         bDesc = TRUE;
  1117.     }
  1118.     else
  1119.     {
  1120.         globals.m_iLastPlaylistSortColoumn = iColIDX;
  1121.         bDesc = FALSE;
  1122.     }
  1124.     // Perform sorting
  1125.     switch(iColIDX)
  1126.     {
  1127.     case PLAYLIST_TRACKSTACK:
  1128.         CPL_SortList(globals.m_hPlaylist, piseTrackStackPos, FALSE);
  1129.         break;
  1130.     case PLAYLIST_TITLE:
  1131.         CPL_SortList(globals.m_hPlaylist, piseTrackName, bDesc);
  1132.         break;
  1133.     case PLAYLIST_ARTIST:
  1134.         CPL_SortList(globals.m_hPlaylist, piseArtist, bDesc);
  1135.         break;
  1136.     case PLAYLIST_ALBUM:
  1137.         CPL_SortList(globals.m_hPlaylist, piseAlbum, bDesc);
  1138.         break;
  1139.     case PLAYLIST_YEAR:
  1140.         CPL_SortList(globals.m_hPlaylist, piseYear, bDesc);
  1141.         break;
  1142.     case PLAYLIST_TRACKNUM:
  1143.         CPL_SortList(globals.m_hPlaylist, piseTrackNum, bDesc);
  1144.         break;
  1145.     case PLAYLIST_COMMENT:
  1146.         CPL_SortList(globals.m_hPlaylist, piseComment, bDesc);
  1147.         break;
  1148.     case PLAYLIST_GENRE:
  1149.         CPL_SortList(globals.m_hPlaylist, piseGenre, bDesc);
  1150.         break;
  1151.     case PLAYLIST_PATH:
  1152.         CPL_SortList(globals.m_hPlaylist, pisePath, bDesc);
  1153.         break;
  1154.     case PLAYLIST_FILENAME:
  1155.         CPL_SortList(globals.m_hPlaylist, piseFilename, bDesc);
  1156.         break;
  1157.     case PLAYLIST_LENGTH:
  1158.         CPL_SortList(globals.m_hPlaylist, piseLength, bDesc);
  1159.         break;
  1160.     }
  1161. }
  1162. //
  1163. //
  1164. //
  1165. void LVCB_ItemRightClick(CP_HLISTVIEW _hListData, const int iItemIDX, const int iColumnIDX, const CP_HPLAYLISTITEM hItem)
  1166. {
  1167.     IF_PostAppMessage(windows.m_hifPlaylist, CPPLM_CREATEINPLACE, (WPARAM)iItemIDX, (LPARAM)iColumnIDX);
  1168. }
  1169. //
  1170. //
  1171. //
  1172. void LVCB_UnhandledKeyPress(CP_HLISTVIEW _hListData, const int iVKey, const BOOL bAlt, const BOOL bCtrl, const BOOL bShift)
  1173. {
  1174.     CP_HandleKeyPress_Playlist(windows.m_hWndPlaylist, iVKey, bAlt, bCtrl, bShift);
  1175. }
  1176. //
  1177. //
  1178. //
  1179. void CPlaylistWindow_ClearSelectedItems()
  1180. {
  1181.     int iSearchItemIDX;
  1182.     int iFocusItem;
  1184.     CLV_BeginBatch(globals.m_hPlaylistViewControl);
  1185.     iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  1186.     while(iSearchItemIDX != CPC_INVALIDITEM)
  1187.     {
  1188.         CP_HPLAYLISTITEM hItem = (CP_HPLAYLISTITEM)CLV_GetItemData(globals.m_hPlaylistViewControl, iSearchItemIDX);
  1189.         CPL_RemoveItem(globals.m_hPlaylist, hItem);
  1190.         iSearchItemIDX = CLV_GetNextSelectedItem(globals.m_hPlaylistViewControl, CPC_INVALIDITEM);
  1191.     }
  1193.     iFocusItem = CLV_GetFocusItem(globals.m_hPlaylistViewControl);
  1194.     if(iFocusItem != CPC_INVALIDITEM)
  1195.         CLV_SetItemSelected(globals.m_hPlaylistViewControl, iFocusItem, TRUE);
  1196.     CLV_EndBatch(globals.m_hPlaylistViewControl);
  1197. }
  1199. //
  1200. //
  1201. //
  1202. void CPlaylistWindow_CB_onCreate(CP_HINTERFACE hInterface, const RECT* pInitialPosition)
  1203. {
  1204.     CPlaylistWindow_CreateListView();
  1205. }
  1206. //
  1207. //
  1208. //
  1209. void CPlaylistWindow_CB_onDraw(CP_HINTERFACE hInterface, CPs_DrawContext* pContext)
  1210. {
  1211.     RECT rClient;
  1213.     // Draw the window background
  1214.     GetClientRect(IF_GetHWnd(windows.m_hifPlaylist), &rClient);
  1215.     CPIG_TiledFill(pContext, &rClient, &glb_pSkin->mpl_rBackground_SourceTile, glb_pSkin->mpl_pBackground, CIC_TILEDFILOPTIONS_NONE);
  1216. }
  1217. //
  1218. //
  1219. //
  1220. void CPlaylistWindow_CB_onKeyDown(CP_HINTERFACE hInterface, const unsigned int iVKeyCode, const BOOL bAlt, const BOOL bCtrl, const BOOL bShift)
  1221. {
  1222.     CP_HandleKeyPress_Playlist(NULL, iVKeyCode, bAlt, bCtrl, bShift);
  1223. }
  1224. //
  1225. //
  1226. //
  1227. void CPlaylistWindow_CB_onDropFiles(CP_HINTERFACE hInterface, HDROP hDrop)
  1228. {
  1229.     CPL_SyncLoadNextFile(globals.m_hPlaylist);
  1230.     CPL_AddDroppedFiles(globals.m_hPlaylist, hDrop);
  1231. }
  1232. //
  1233. //
  1234. //
  1235. void CPlaylistWindow_CB_onPosChange(CP_HINTERFACE hInterface, const RECT* pNewPosition, const BOOL bSizeChanged)
  1236. {
  1237.     options.playlist_window_pos = *pNewPosition;
  1239.     if(bSizeChanged)
  1240.     {
  1241.         SIZE szWindow;
  1243.         szWindow.cx = pNewPosition->right - pNewPosition->left;
  1244.         szWindow.cy = pNewPosition->bottom - pNewPosition->top;
  1245.         MoveWindow(CLV_GetHWND(globals.m_hPlaylistViewControl),
  1246.                    glb_pSkin->mpl_rList_Border.left,
  1247.                    glb_pSkin->mpl_rList_Border.top,
  1248.                    (szWindow.cx - glb_pSkin->mpl_rList_Border.right) - glb_pSkin->mpl_rList_Border.left,
  1249.                    (szWindow.cy - glb_pSkin->mpl_rList_Border.bottom) - glb_pSkin->mpl_rList_Border.top,
  1250.                    TRUE);
  1251.     }
  1252. }
  1253. //
  1254. //
  1255. //
  1256. void CPlaylistWindow_CB_onFocus(CP_HINTERFACE hInterface, const BOOL bHasFocus)
  1257. {
  1258.     if(bHasFocus == TRUE)
  1259.         SetFocus(CLV_GetHWND(globals.m_hPlaylistViewControl));
  1260. }
  1261. //
  1262. //
  1263. //
  1264. void CPlaylistWindow_CB_onCommandMessage(CP_HINTERFACE hInterface, const WPARAM wParam, const LPARAM lParam)
  1265. {
  1266.     if(LOWORD(wParam) == IDC_PL_FLOATINGEDIT)
  1267.         CPlaylistWindow_WM_COMMAND_IDC_PL_FLOATINGEDIT(wParam, lParam);
  1268.     else if(LOWORD(wParam) == IDC_PL_FLOATINGCOMBO)
  1269.         CPlaylistWindow_WM_COMMAND_IDC_PL_FLOATINGCOMBO(wParam, lParam);
  1270. }
  1271. //
  1272. //
  1273. //
  1274. LRESULT CPlaylistWindow_CB_onAppMessage(CP_HINTERFACE hInterface, const UINT uiMessage, const WPARAM wParam, const LPARAM lParam)
  1275. {
  1276.     if(uiMessage == CPPLM_CREATEINPLACE)
  1277.     {
  1278.         int iItem = (int)wParam;
  1279.         int iSubItem = (int)lParam;
  1281.         CPlaylistWindow_DestroyIPEdit();
  1283.         // It's a hit - create sub control (for IP controls)
  1284.         if(iItem != CPC_INVALIDITEM && iSubItem != CPC_INVALIDCOLUMN)
  1285.         {
  1286.             if(iSubItem != PLAYLIST_TRACKSTACK
  1287.                     && iSubItem != PLAYLIST_PATH
  1288.                     && iSubItem != PLAYLIST_FILENAME)
  1289.             {
  1290.                 CPlaylistWindow_CreateIPEdit(iItem, iSubItem);
  1291.             }
  1292.             else if(iSubItem == PLAYLIST_TRACKSTACK)
  1293.             {
  1294.                 CPlaylistWindow_TrackStackMenu(iItem);
  1295.             }
  1296.             else if(iSubItem == PLAYLIST_PATH || iSubItem == PLAYLIST_FILENAME)
  1297.             {
  1298.                 CPlaylistWindow_RenameMenu(iItem, iSubItem);
  1299.             }
  1300.         }
  1301.     }
  1302.     else if(uiMessage == CPPLM_DESTROYINPLACE)
  1303.         CPlaylistWindow_DestroyIPEdit();
  1305.     return 0;
  1306. }
  1307. //
  1308. //
  1309. //
  1310. CPe_CustomDrawColour LVCB_GetTrackStackItemColour(const void* pvItemData)
  1311. {
  1312.     CP_HPLAYLISTITEM hItem = (CP_HPLAYLISTITEM)pvItemData;
  1313.     int iTrackStackPos;
  1315.     iTrackStackPos = CPLI_GetTrackStackPos(hItem);
  1316.     if(iTrackStackPos == CIC_TRACKSTACK_UNSTACKED)
  1317.         return cdcNormal;
  1318.     else if(iTrackStackPos == 0)
  1319.         return cdcHighlighted;
  1320.     else if(iTrackStackPos < 0)
  1321.         return cdcLowlighted;
  1323.     return cdcNormal;
  1324. }
  1325. //
  1326. //
  1327. //
  1328. CPe_CustomDrawColour LVCB_GetItemColour(const void* pvItemData)
  1329. {
  1330.     CP_HPLAYLISTITEM hItem = (CP_HPLAYLISTITEM)pvItemData;
  1332.     if(CPLI_GetTrackStackPos(hItem) == 0)
  1333.         return cdcHighlighted;
  1335.     return cdcNormal;
  1336. }
  1337. //
  1338. //
  1339. //