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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
openfile_win32.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：40k
源码类别：

Windows CE

开发平台：

C/C++

openfile_win32.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: openfile_win32.c 531 2006-01-04 12:56:13Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../../common/common.h"
  25. #include "../win.h"
  26. #include "openfile_win32.h"
  27. #include "interface.h"
  28. #include "resource.h"
  30. #if defined(TARGET_WINCE) || defined(TARGET_WIN32)
  32. #ifndef STRICT
  33. #define STRICT
  34. #endif
  35. #include <windows.h>
  36. #if _MSC_VER > 1000
  37. #pragma warning(disable : 4201)
  38. #endif
  39. #include <commctrl.h>
  41. #define OPENFILE_TYPES 50000
  43. #define EM_SETSYMBOLS       0x00DF
  44. #define SYMBOLS T("./:-1\~?#")
  46. #define MAXHISTORY 20
  48. #define IMG_FILE 0
  49. #define IMG_DIR 1
  50. #define IMG_PLAYLIST 2
  51. #define IMG_VIDEO 3
  52. #define IMG_AUDIO 4
  53. #define IMG_DIRUP 5
  55. typedef struct openitem
  56. {
  57. int Image;
  58. tchar_t FileName[MAXPATH];
  59. tchar_t Name[MAXPATH];
  60. tchar_t Ext[MAXPATH];
  61. filepos_t Size;
  62. int64_t Date;
  63. bool_t DisplayName;
  65. } openitem;
  67. typedef struct openfile
  68. {
  69. win Win;
  70. HWND WndList;
  71. HWND WndURL;
  72. HWND WndGo;
  73. int* CurrentFileType;
  74. int FileType;
  75. int FileTypeSingle;
  76. int FileTypeSave;
  77. int SortCol;
  78. int Class;
  79. int Flags;
  80. int Top;
  81. int TypesMenu;
  82. bool_t SortDir;
  83. bool_t Multiple;
  84. bool_t SelectDir;
  85. bool_t OwnSelect;
  86. bool_t NextFocus;
  87. bool_t OnlyName;
  88. bool_t OnlyNameState;
  89. bool_t KeyClick;
  90. int InUpdate;
  91. int LastClick;
  92. int DlgWidth[4];
  93. tchar_t Path[MAXPATH];
  94. tchar_t Base[MAXPATH];
  95. tchar_t Exts[1024];
  96. tchar_t Last[MAXPATH];
  98. tchar_t SaveName[MAXPATH];
  99. array Types;
  100. int HistoryCount;
  101. tchar_t* History[MAXHISTORY];
  103. } openfile;
  105. static const datatable Params[] =
  106. {
  107. { OPENFILE_FLAGS, TYPE_INT, DF_HIDDEN },
  108. { OPENFILE_CLASS, TYPE_INT, DF_HIDDEN },
  109. { OPENFILE_MULTIPLE, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  110. { OPENFILE_FILETYPE, TYPE_INT, DF_SETUP|DF_HIDDEN },
  111. { OPENFILE_FILETYPE_SINGLE, TYPE_INT, DF_SETUP|DF_HIDDEN },
  112. { OPENFILE_FILETYPE_SAVE,TYPE_INT, DF_SETUP|DF_HIDDEN },
  113. { OPENFILE_PATH, TYPE_STRING, DF_SETUP|DF_HIDDEN },
  114. { OPENFILE_SORTCOL, TYPE_INT, DF_SETUP|DF_HIDDEN },
  115. { OPENFILE_SORTDIR, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  116. { OPENFILE_WIDTH_NAME, TYPE_INT, DF_SETUP|DF_HIDDEN },
  117. { OPENFILE_WIDTH_TYPE, TYPE_INT, DF_SETUP|DF_HIDDEN },
  118. { OPENFILE_WIDTH_SIZE, TYPE_INT, DF_SETUP|DF_HIDDEN },
  119. { OPENFILE_WIDTH_DATE, TYPE_INT, DF_SETUP|DF_HIDDEN },
  120. { OPENFILE_ONLYNAME, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  121. { OPENFILE_HISTORYCOUNT,TYPE_INT, DF_SETUP|DF_HIDDEN },
  123. { OPENFILE_SAVE_NAME, TYPE_STRING, DF_HIDDEN },
  124. { OPENFILE_SAVE_TYPE, TYPE_INT, DF_ENUMCLASS|DF_HIDDEN  },
  125. { OPENFILE_URL,   TYPE_STRING, DF_HIDDEN },
  126. { OPENFILE_LIST,   0, DF_HIDDEN },
  128. DATATABLE_END(OPENFILE_ID)
  129. };
  131. static int Enum(openfile* p, int* No, datadef* Param )
  132. {
  133. if (NodeEnumTable(No,Param,Params)==ERR_NONE)
  134. {
  135. if (Param->No == OPENFILE_SAVE_TYPE)
  136. Param->Format1 = p->Class;
  137. return ERR_NONE;
  138. }
  140. if (*No >= 0 && *No < p->HistoryCount)
  141. {
  142. memset(Param,0,sizeof(datadef));
  143. Param->No = OPENFILE_HISTORY + *No;
  144. Param->Type = TYPE_STRING;
  145. Param->Size = MAXDATA;
  146. Param->Flags = DF_HIDDEN | DF_SETUP;
  147. Param->Class = OPENFILE_ID;
  148. return ERR_NONE;
  149. }
  151. return ERR_INVALID_PARAM;
  152. }
  154. static int Get(openfile* p,int No,void* Data,int Size)
  155. {
  156. int Result = ERR_INVALID_PARAM;
  157. switch (No)
  158. {
  159. case OPENFILE_MULTIPLE: GETVALUE(p->Multiple,bool_t); break;
  160. case OPENFILE_CLASS: GETVALUE(p->Class,int); break;
  161. case OPENFILE_FLAGS: GETVALUE(p->Flags,int); break;
  162. case OPENFILE_FILETYPE: GETVALUE(p->FileType,int); break;
  163. case OPENFILE_FILETYPE_SINGLE: GETVALUE(p->FileTypeSingle,int); break;
  164. case OPENFILE_FILETYPE_SAVE: GETVALUE(p->FileTypeSave,int); break;
  165. case OPENFILE_PATH: GETSTRING(p->Path); break;
  166. case OPENFILE_SORTCOL: GETVALUE(p->SortCol,int); break;
  167. case OPENFILE_SORTDIR: GETVALUE(p->SortDir,bool_t); break;
  168. case OPENFILE_WIDTH_NAME: GETVALUE(p->DlgWidth[0],int); break;
  169. case OPENFILE_WIDTH_TYPE: GETVALUE(p->DlgWidth[1],int); break;
  170. case OPENFILE_WIDTH_SIZE: GETVALUE(p->DlgWidth[2],int); break;
  171. case OPENFILE_WIDTH_DATE: GETVALUE(p->DlgWidth[3],int); break;
  172. case OPENFILE_HISTORYCOUNT: GETVALUE(p->HistoryCount,int); break;
  173. case OPENFILE_ONLYNAME: GETVALUE(p->OnlyName,bool_t); break;
  174. case OPENFILE_SAVE_NAME: GETSTRING(p->SaveName); break;
  175. case OPENFILE_SAVE_TYPE: GETVALUE(p->FileTypeSave,int); break;
  176. }
  178. if (No >= OPENFILE_HISTORY && No < OPENFILE_HISTORY+p->HistoryCount && p->History[No-OPENFILE_HISTORY])
  179. GETSTRING(p->History[No-OPENFILE_HISTORY]);
  181. return Result;
  182. }
  184. static void SetColWidth(openfile* p, int Index,int Width)
  185. {
  186. ListView_SetColumnWidth(p->WndList,Index,WinUnitToPixelX(&p->Win,Width));
  187. }
  189. static int GetColWidth(openfile* p, int Index)
  190. {
  191. if (p->Win.Smartphone)
  192. return p->DlgWidth[Index]; // no GUI update possible
  193. return WinPixelToUnitX(&p->Win,ListView_GetColumnWidth(p->WndList,Index));
  194. }
  196. static int UpdateOnlyName(openfile* p)
  197. {
  198. int i;
  199. if (p->OnlyName != p->OnlyNameState)
  200. {
  201. WinMenuCheck(&p->Win,1,OPENFILE_ONLYNAME,p->OnlyName);
  202. p->OnlyNameState = p->OnlyName;
  204. if (p->OnlyName)
  205. {
  206. for (i=0;i<4;++i)
  207. p->DlgWidth[i] = GetColWidth(p,i);
  208. ShowWindow(p->WndList,SW_HIDE);
  209. SetColWidth(p,3,0);
  210. SetColWidth(p,2,0);
  211. SetColWidth(p,1,0);
  212. SetColWidth(p,0,300);
  213. ShowWindow(p->WndList,SW_SHOWNA);
  214. }
  215. else
  216. {
  217. ShowWindow(p->WndList,SW_HIDE);
  218. for (i=3;i>=0;--i)
  219. SetColWidth(p,i,max(15,p->DlgWidth[i]));
  220. ShowWindow(p->WndList,SW_SHOWNA);
  221. }
  222. }
  223. return ERR_NONE;
  224. }
  226. static int Set(openfile* p,int No,const void* Data,int Size)
  227. {
  228. int Result = ERR_INVALID_PARAM;
  229. switch (No)
  230. {
  231. case OPENFILE_MULTIPLE: SETVALUE(p->Multiple,bool_t,ERR_NONE); break;
  232. case OPENFILE_FLAGS: SETVALUE(p->Flags,int,ERR_NONE); break;
  233. case OPENFILE_CLASS: SETVALUE(p->Class,int,ERR_NONE); break;
  234. case OPENFILE_FILETYPE: SETVALUE(p->FileType,int,ERR_NONE); break;
  235. case OPENFILE_FILETYPE_SINGLE: SETVALUE(p->FileTypeSingle,int,ERR_NONE); break;
  236. case OPENFILE_FILETYPE_SAVE: SETVALUE(p->FileTypeSave,int,ERR_NONE); break;
  237. case OPENFILE_PATH: SETSTRING(p->Path); break;
  238. case OPENFILE_SORTCOL: SETVALUE(p->SortCol,int,ERR_NONE); break;
  239. case OPENFILE_SORTDIR: SETVALUE(p->SortDir,bool_t,ERR_NONE); break;
  240. case OPENFILE_WIDTH_NAME: SETVALUE(p->DlgWidth[0],int,ERR_NONE); break;
  241. case OPENFILE_WIDTH_TYPE: SETVALUE(p->DlgWidth[1],int,ERR_NONE); break;
  242. case OPENFILE_WIDTH_SIZE: SETVALUE(p->DlgWidth[2],int,ERR_NONE); break;
  243. case OPENFILE_ONLYNAME: SETVALUE(p->OnlyName,bool_t,UpdateOnlyName(p)); break;
  244. case OPENFILE_HISTORYCOUNT: SETVALUE(p->HistoryCount,int,ERR_NONE); break;
  245. case OPENFILE_SAVE_NAME: SETSTRING(p->SaveName); break;
  246. case OPENFILE_SAVE_TYPE: SETVALUE(p->FileTypeSave,int,ERR_NONE); break;
  247. }
  249. if (No >= OPENFILE_HISTORY && No < OPENFILE_HISTORY+p->HistoryCount)
  250. {
  251. free(p->History[No-OPENFILE_HISTORY]);
  252. p->History[No-OPENFILE_HISTORY] = tcsdup((tchar_t*)Data);
  253. Result = ERR_NONE;
  254. }
  256. return Result;
  257. }
  259. static void AddCol(openfile* p, int Index, const tchar_t* Name, int Width, int Format )
  260. {
  261. LVCOLUMN Col;
  262. Col.mask=LVCF_TEXT | LVCF_WIDTH | LVCF_FMT;
  263. Col.cx=WinUnitToPixelX(&p->Win,Width);
  264. Col.pszText=(tchar_t*)Name;
  265. Col.cchTextMax=tcslen(Name)+1;
  266. Col.fmt=Format;
  268. ListView_InsertColumn(p->WndList,Index,&Col);
  269. }
  271. static int CALLBACK CompareProc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
  272. {
  273. openfile* p = (openfile*)lParamSort;
  274. openitem* a = (openitem*)lParam1;
  275. openitem* b = (openitem*)lParam2;
  276. int Result = 0;
  278. if (!a) return b?-1:0;
  279. if (!b) return 1;
  281. if (a->Image==IMG_DIR)
  282. if (b->Image==IMG_DIR)
  283. Result = tcsicmp(a->Name,b->Name);
  284. else
  285. Result = -1;
  286. else
  287. if (b->Image==IMG_DIR)
  288. Result = 1;
  289. else
  290. switch(p->SortCol)
  291. {
  292. case 0: 
  293. Result = tcsicmp(a->Name,b->Name); 
  294. break;
  295. case 1: 
  296. Result = tcsicmp(a->Ext,b->Ext); 
  297. if (!Result) 
  298. Result = tcsicmp(a->Name,b->Name);
  299. break;
  300. case 2: 
  301. if (a->Size == b->Size) 
  302. Result = tcsicmp(a->Name,b->Name);
  303. else
  304. Result = a->Size > b->Size ? 1:-1;
  305. break;
  306. case 3:
  307. if (a->Date == b->Date) 
  308. Result = tcsicmp(a->Name,b->Name);
  309. else
  310. Result = a->Date > b->Date ? 1:-1;
  311. break;
  312. }
  314. if (p->SortDir)
  315. Result = -Result;
  316. return Result;
  317. }
  319. static void SavePos(openfile* p)
  320. {
  321. LVITEM Item;
  322. int n;
  324. p->Last[0] = 0;
  326. for (n=0;n<ListView_GetItemCount(p->WndList);++n)
  327. if (ListView_GetItemState(p->WndList,n,LVIS_FOCUSED)==LVIS_FOCUSED)
  328. {
  329. Item.iItem=n;
  330. Item.iSubItem = 0;
  331. Item.mask=LVIF_PARAM;
  332. ListView_GetItem(p->WndList,&Item);
  334. if (Item.lParam)
  335. tcscpy_s(p->Last,TSIZEOF(p->Last),((openitem*)Item.lParam)->Name);
  337. break;
  338. }
  339. }
  341. static void ClearList(openfile* p)
  342. {
  343. LVITEM Item;
  344. int n;
  346. for (n=0;n<ListView_GetItemCount(p->WndList);++n)
  347. {
  348. Item.iItem=n;
  349. Item.iSubItem=0;
  350. Item.mask=LVIF_PARAM;
  351. ListView_GetItem(p->WndList,&Item);
  352. if (Item.lParam)
  353. free((void*)Item.lParam);
  354. }
  356. ListView_DeleteAllItems(p->WndList);
  357. }
  359. static void SelectAll(openfile* p)
  360. {
  361. LVITEM Item;
  362. int n;
  363. int State;
  365. p->OwnSelect = 1;
  367. for (n=0;n<ListView_GetItemCount(p->WndList);++n)
  368. {
  369. Item.iItem=n;
  370. Item.iSubItem=0;
  371. Item.mask=LVIF_PARAM;
  372. ListView_GetItem(p->WndList,&Item);
  374. State = 0;
  375. if (Item.lParam && (((openitem*)Item.lParam)->Image != IMG_DIR || p->SelectDir))
  376. State = LVIS_SELECTED;
  378. ListView_SetItemState(p->WndList,n,State,LVIS_SELECTED);
  379. }
  381. p->OwnSelect = 0;
  382. }
  384. static void UpdateSelectDir(openfile* p)
  385. {
  386. if (p->Flags & OPENFLAG_SINGLE) 
  387. return;
  389. if (p->Win.Smartphone)
  390. {
  391. WinMenuCheck(&p->Win,1,OPENFILE_SELECTDIR2,p->SelectDir);
  392. }
  393. else
  394. {
  395. TBBUTTONINFO Button;
  396. Button.cbSize = sizeof(Button);
  397. Button.dwMask = TBIF_STATE;
  398. Button.fsState = TBSTATE_ENABLED;
  399. if (p->SelectDir)
  400. Button.fsState |= TBSTATE_CHECKED;
  402. SendMessage(p->Win.WndTB,TB_SETBUTTONINFO,OPENFILE_SELECTDIR,(LPARAM)&Button);
  403. }
  404. }
  406. static void UpdateMultiple(openfile* p)
  407. {
  408. int Count,i;
  410. if (p->Flags & OPENFLAG_SINGLE) 
  411. return;
  413. if (p->Win.Smartphone)
  414. {
  415. WinMenuCheck(&p->Win,1,OPENFILE_MORE,p->Multiple);
  416. }
  417. else
  418. {
  419. TBBUTTONINFO Button;
  420. Button.cbSize = sizeof(Button);
  421. Button.dwMask = TBIF_STATE;
  422. Button.fsState = TBSTATE_ENABLED;
  423. if (p->Multiple)
  424. Button.fsState |= TBSTATE_CHECKED;
  426. SendMessage(p->Win.WndTB,TB_SETBUTTONINFO,OPENFILE_MORE,(LPARAM)&Button);
  427. }
  429. p->OwnSelect = 1;
  431. Count = ListView_GetItemCount(p->WndList);
  432. for (i=0;i<Count;++i)
  433. {
  434. int State = 0;
  435. if (!p->Multiple && ListView_GetItemState(p->WndList,i,LVIS_FOCUSED)==LVIS_FOCUSED)
  436. State = LVIS_SELECTED;
  437. ListView_SetItemState(p->WndList,i,State,LVIS_SELECTED);
  438. }
  440. p->OwnSelect = 0;
  441. }
  443. static void SetURLText(openfile* p,const tchar_t* s)
  444. {
  445. int Len = tcslen(s);
  447. ++p->InUpdate;
  448. SetWindowText(p->WndURL,s);
  449. if (p->Win.Smartphone)
  450. SendMessage(p->WndURL,EM_SETSEL,Len,Len);
  451. else
  452. SendMessage(p->WndURL,CB_SETEDITSEL,0,MAKEWORD(-1,-1));
  453. --p->InUpdate;
  454. }
  456. static void AddHistory(openfile* p,const tchar_t* s)
  457. {
  458. int i;
  461. for (i=0;i<p->HistoryCount;++i)
  462. if (p->History[i] && tcsicmp(p->History[i],s)==0)
  463. {
  464. for (;i>0;--i)
  465. SwapPChar(&p->History[i],&p->History[i-1]);
  466. break;
  467. }
  469. if (i==p->HistoryCount)
  470. {
  471. if (i<MAXHISTORY)
  472. p->HistoryCount++;
  473. else
  474. free(p->History[--i]);
  476. for (;i>0;--i)
  477. p->History[i] = p->History[i-1];
  479. p->History[0] = tcsdup(s);
  480. }
  482. if (!p->Win.Smartphone)
  483. {
  484. int i;
  485. SendMessage(p->WndURL,CB_RESETCONTENT,0,0);
  486. for (i=0;i<p->HistoryCount;++i)
  487. if (p->History[i])
  488. SendMessage(p->WndURL,CB_ADDSTRING,0,(LPARAM)p->History[i]);
  489. }
  491. SetURLText(p,s);
  492. }
  494. static void UpdateList(openfile* p, bool_t Silent, int ListMode)
  495. {
  496. streamdir DirItem;
  497. stream* Stream;
  498. int Result;
  499. openitem New;
  500. LVITEM Item;
  501. int No=0;
  502. int Pos=0;
  503. int State = LVIS_FOCUSED;
  504. int Len;
  505. const tchar_t* s;
  506. bool_t HasHost;
  508. if (!p->Multiple || (p->Flags & OPENFLAG_SINGLE))
  509. State |= LVIS_SELECTED; 
  511. Len = tcslen(p->Path);
  512. if (Len && (p->Path[Len-1] == '\' || p->Path[Len-1] == '/'))
  513. p->Path[--Len] = 0;
  515. tcscpy_s(p->Base,TSIZEOF(p->Base),p->Path);
  516. s = p->Path[0] ? p->Path : T("\");
  517. AddHistory(p,s);
  519. if (!ListMode)
  520. return;
  522. ++p->InUpdate;
  523. WaitBegin();
  525. ShowWindow(p->WndList,SW_HIDE);
  526. ClearList(p);
  528. Item.mask=LVIF_TEXT|LVIF_IMAGE|LVIF_PARAM;
  529. Item.pszText=T("");
  530. Item.cchTextMax=1;
  531. Item.iSubItem=0;
  533. Stream = GetStream(p->Path,Silent);
  535. if (Stream)
  536. {
  537. s = GetMime(p->Path,NULL,0,&HasHost);
  538. if (*s)
  539. {
  540. Item.iImage=IMG_DIRUP;
  541. Item.iItem = No;
  542. Item.lParam = 0;
  544. ListView_InsertItem(p->WndList,&Item);
  545. ListView_SetItemText(p->WndList,No,0,T(".."));
  546. ListView_SetItemText(p->WndList,No,1,(tchar_t*)LangStr(OPENFILE_ID,OPENFILE_UP));
  547. ++No;
  548. }
  550. Result = Stream->EnumDir(Stream,p->Path,p->Exts,*p->CurrentFileType!=-1,&DirItem);
  552. if (ListMode==2 && Result == ERR_FILE_NOT_FOUND && UpperPath(p->Path,p->Last,TSIZEOF(p->Last)))
  553. {
  554. WaitEnd();
  555. --p->InUpdate;
  557. p->LastClick = -1;
  558. UpdateList(p,Silent,ListMode);
  559. return;
  560. }
  562. if (Result == ERR_NOT_DIRECTORY && !Silent)
  563. {
  564. New.FileName[0] = 0;
  565. New.Ext[0] = 0;
  566. New.Image = IMG_FILE;
  567. New.Size = 0;
  569. Item.lParam = (DWORD)malloc(sizeof(openitem));
  570. if (Item.lParam)
  571. {
  572. p->Last[0] = 0;
  573. Pos = No;
  574. State = LVIS_SELECTED;
  575. PostMessage(p->Win.Wnd,WM_COMMAND,PLATFORM_OK,0);
  577. *(openitem*)Item.lParam = New;
  578. Item.iItem = No;
  579. Item.iImage = New.Image;
  580. ListView_InsertItem(p->WndList,&Item);
  581. ++No;
  582. }
  583. }
  585. if (Result == ERR_NONE)
  586. Stream->Get(Stream,STREAM_BASE,p->Base,sizeof(p->Base));
  588. while (Result == ERR_NONE)
  589. {
  590. tchar_t Size[32];
  591. tchar_t Date[32];
  593. int i;
  594. for (i=0;i<No;++i)
  595. {
  596. LVITEM Item;
  597. Item.iItem=i;
  598. Item.iSubItem = 0;
  599. Item.mask=LVIF_PARAM;
  600. ListView_GetItem(p->WndList,&Item);
  602. if (Item.lParam && tcscmp(((openitem*)Item.lParam)->FileName,DirItem.FileName)==0)
  603. break;
  604. }
  606. if (i==No)
  607. {
  608. tchar_t DisplayName[MAXPATH];
  609. tcscpy_s(New.FileName,TSIZEOF(New.FileName),DirItem.FileName);
  610. New.DisplayName = DirItem.DisplayName[0] != 0;
  611. tcscpy_s(DisplayName,TSIZEOF(DisplayName),New.DisplayName?DirItem.DisplayName:DirItem.FileName);
  612. Size[0] = 0;
  613. Date[0] = 0;
  615. if (DirItem.Size < 0)
  616. {
  617. New.Image = IMG_DIR;
  618. New.Size = 0;
  619. New.Date = 0;
  620. tcscpy_s(New.Ext,TSIZEOF(New.Ext),LangStr(OPENFILE_ID,OPENFILE_DIR));
  621. tcscpy_s(New.Name,TSIZEOF(New.Name),DisplayName); //keep extension
  622. }
  623. else
  624. {
  625. switch (DirItem.Type)
  626. {
  627. case FTYPE_AUDIO: New.Image = IMG_AUDIO; break;
  628. case FTYPE_PLAYLIST: New.Image = IMG_PLAYLIST; break;
  629. case FTYPE_VIDEO: New.Image = IMG_VIDEO; break;
  630. default: New.Image = IMG_FILE; break;
  631. }
  632. New.Size = DirItem.Size;
  633. New.Date = DirItem.Date;
  635. SplitURL(DisplayName,NULL,0,NULL,0,New.Name,TSIZEOF(New.Name),New.Ext,TSIZEOF(New.Ext));
  636. tcsupr(New.Ext);
  637. if (New.Size >= 0)
  638. {
  639. if (New.Size < 10000*1024)
  640. stprintf_s(Size,TSIZEOF(Size),T("%d KB"),New.Size/1024);
  641. else
  642. stprintf_s(Size,TSIZEOF(Size),T("%d MB"),New.Size/(1024*1024));
  643. }
  644. if (New.Date >= 0)
  645. {
  646. FILETIME Time;
  647. SYSTEMTIME SysTime;
  648. Time.dwHighDateTime = (DWORD)(New.Date >> 32);
  649. Time.dwLowDateTime = (DWORD)(New.Date);
  650. if (FileTimeToSystemTime(&Time,&SysTime))
  651. GetDateFormat(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&SysTime,NULL,Date,TSIZEOF(Date));
  652. }
  653. }
  655. Item.lParam = (DWORD)malloc(sizeof(openitem));
  656. if (Item.lParam)
  657. {
  658. *(openitem*)Item.lParam = New;
  659. Item.iItem = No;
  660. Item.iImage = New.Image;
  661. ListView_InsertItem(p->WndList,&Item);
  662. ListView_SetItemText(p->WndList,No,0,New.Name);
  663. ListView_SetItemText(p->WndList,No,1,New.Ext);
  664. ListView_SetItemText(p->WndList,No,2,Size);
  665. ListView_SetItemText(p->WndList,No,3,Date);
  666. ++No;
  667. }
  668. }
  670. Result = Stream->EnumDir(Stream,NULL,NULL,0,&DirItem);
  671. }
  673. NodeDelete((node*)Stream);
  674. }
  676. ListView_SortItems(p->WndList,CompareProc,p);
  677. ShowWindow(p->WndList,SW_SHOWNA);
  679. if (p->Last[0])
  680. {
  681. int i;
  682. for (i=0;i<No;++i)
  683. {
  684. LVITEM Item;
  685. Item.iItem=i;
  686. Item.iSubItem = 0;
  687. Item.mask=LVIF_PARAM;
  688. ListView_GetItem(p->WndList,&Item);
  690. if (Item.lParam && tcsicmp(((openitem*)Item.lParam)->Name,p->Last)==0)
  691. {
  692. Pos = i;
  693. break;
  694. }
  695. }
  696. }
  698. SetFocus(p->WndList);
  700. p->OwnSelect = 1;
  701. ListView_SetItemState(p->WndList,Pos,State,State);
  702. p->OwnSelect = 0;
  704. ListView_EnsureVisible(p->WndList,Pos,TRUE);
  706. WaitEnd();
  707. --p->InUpdate;
  708. }
  710. static void UpdateMenu(openfile* p)
  711. {
  712. int No;
  713. int* i;
  715. p->TypesMenu = WinMenuFind(&p->Win,OPENFILE_ALL_FILES);
  716. WinMenuInsert(&p->Win,p->TypesMenu,OPENFILE_ALL_FILES,OPENFILE_TYPES-1,LangStr(p->Class,0));
  718. ArrayClear(&p->Types);
  719. NodeEnumClass(&p->Types,p->Class);
  720. for (No=0,i=ARRAYBEGIN(p->Types,int);i!=ARRAYEND(p->Types,int);++i,++No)
  721. {
  722. const tchar_t* Name = LangStr(*i,NODE_NAME);
  723. if (Name[0] && UniqueExts(ARRAYBEGIN(p->Types,int),i))
  724. WinMenuInsert(&p->Win,p->TypesMenu,OPENFILE_ALL_FILES,OPENFILE_TYPES+No,Name);
  725. }
  726. }
  728. static void UpdateSort(openfile* p)
  729. {
  730. WinMenuCheck(&p->Win,1,OPENFILE_LABEL_NAME,p->SortCol==0);
  731. WinMenuCheck(&p->Win,1,OPENFILE_LABEL_TYPE,p->SortCol==1);
  732. WinMenuCheck(&p->Win,1,OPENFILE_LABEL_SIZE,p->SortCol==2);
  733. WinMenuCheck(&p->Win,1,OPENFILE_LABEL_DATE,p->SortCol==3);
  734. ListView_SortItems(p->WndList, CompareProc, (LPARAM)p);
  735. }
  737. static void UpdateFileType(openfile* p,int ListMode)
  738. {
  739. int No;
  740. int* i;
  741. int FileType;
  743. if (p->InUpdate)
  744. return;
  746. FileType = *p->CurrentFileType;
  747. if (FileType && FileType!=-1 && !NodeEnumClass(NULL,FileType))
  748. FileType = *p->CurrentFileType = 0;
  750. WinMenuCheck(&p->Win,p->TypesMenu,OPENFILE_TYPES-1,FileType==0);
  751. WinMenuCheck(&p->Win,p->TypesMenu,OPENFILE_ALL_FILES,FileType==-1);
  753. p->Exts[0]=0;
  755. for (No=0,i=ARRAYBEGIN(p->Types,int);i!=ARRAYEND(p->Types,int);++i,++No)
  756. {
  757. WinMenuCheck(&p->Win,p->TypesMenu,OPENFILE_TYPES+No,FileType==*i);
  758. if (FileType==*i || FileType==0 || FileType==-1)
  759. {
  760. const tchar_t *Exts = LangStr(*i,NODE_EXTS);
  761. if (Exts[0])
  762. {
  763. if (p->Exts[0]) tcscat_s(p->Exts,TSIZEOF(p->Exts),T(";"));
  764. tcscat_s(p->Exts,TSIZEOF(p->Exts),Exts);
  765. }
  766. }
  767. }
  769. p->Last[0] = 0;
  770. UpdateList(p,1,ListMode);
  771. }
  773. static void SetSaveName(openfile* p,int Pos)
  774. {
  775. LVITEM Item;
  776. Item.iItem=Pos;
  777. Item.iSubItem=0;
  778. Item.mask=LVIF_PARAM;
  779. if (ListView_GetItem(p->WndList,&Item) && Item.lParam && ((openitem*)Item.lParam)->Image != IMG_DIR)
  780. {
  781. int* i;
  782. SplitURL(((openitem*)Item.lParam)->FileName,NULL,0,NULL,0,p->SaveName,TSIZEOF(p->SaveName),p->SaveName,TSIZEOF(p->SaveName));
  784. for (i=ARRAYBEGIN(p->Types,int);i!=ARRAYEND(p->Types,int);++i)
  785. if (CheckExts(p->SaveName,LangStr(*i,NODE_EXTS)))
  786. {
  787. tchar_t *s = tcsrchr(p->SaveName,'.');
  788. if (s) *s = 0;
  789. p->FileTypeSave = *i;
  790. WinPropUpdate(&p->Win,&p->Win.Node,OPENFILE_FILETYPE_SAVE);
  791. break;
  792. }
  794. WinPropUpdate(&p->Win,&p->Win.Node,OPENFILE_SAVE_NAME);
  795. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_SAVE_NAME,1);
  796. }
  797. }
  799. static void Save(openfile* p)
  800. {
  801. player* Player = (player*)Context()->Player;
  802. if (Player)
  803. {
  804. tchar_t URL[MAXPATH];
  805. tchar_t Exts[MAXPATH];
  807. if (!p->SaveName[0])
  808. {
  809. ShowError(0,OPENFILE_ID,OPENFILE_EMPTYNAME);
  810. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_SAVE_NAME,1);
  811. return;
  812. }
  813. else
  814. {
  815. AbsPath(URL,TSIZEOF(URL),p->SaveName,p->Base);
  816. SplitURL(p->SaveName,NULL,0,NULL,0,NULL,0,Exts,TSIZEOF(Exts));
  818. if (!Exts[0])
  819. {
  820. tchar_t* s;
  821. tcscpy_s(Exts,TSIZEOF(Exts),LangStr(p->FileTypeSave,NODE_EXTS));
  822. s = tcschr(Exts,':');
  823. if (s) *s = 0;
  824. SetFileExt(URL,TSIZEOF(URL),Exts);
  825. }
  827. PlayerSaveList(Player,URL,p->FileTypeSave);
  828. }
  829. }
  830. WinClose(&p->Win);
  831. }
  833. static bool_t IsSelected(openfile* p)
  834. {
  835. int Count,i;
  836. Count = ListView_GetItemCount(p->WndList);
  838. for (i=0;i<Count;++i)
  839. if (ListView_GetItemState(p->WndList,i,LVIS_SELECTED)==LVIS_SELECTED)
  840. {
  841. LVITEM Item;
  842. Item.iItem=i;
  843. Item.iSubItem=0;
  844. Item.mask=LVIF_PARAM;
  845. if (ListView_GetItem(p->WndList,&Item) && Item.lParam && (((openitem*)Item.lParam)->Image != IMG_DIR || p->SelectDir))
  846. break;
  847. }
  849. return i<Count;
  850. }
  852. static void SelectIfNone(openfile* p,int Pos)
  853. {
  854. if (!IsSelected(p))
  855. {
  856. p->OwnSelect = 1;
  857. ListView_SetItemState(p->WndList,Pos,LVIS_SELECTED,LVIS_SELECTED);
  858. p->OwnSelect = 0;
  859. }
  860. }
  862. static void Add(openfile* p)
  863. {
  864. player* Player = (player*)Context()->Player;
  865. bool_t Add = (p->Flags & OPENFLAG_ADD) != 0;
  866. bool_t b;
  867. int Count,n,i;
  869. if (Player && IsSelected(p))
  870. {
  871. if (p->Class != SKIN_CLASS)
  872. {
  873. if (Add)
  874. {
  875. Player->Get(Player,PLAYER_LIST_COUNT,&n,sizeof(n));
  876. Add = n>0;
  877. }
  878. else
  879. {
  880. b = 0;
  881. Player->Set(Player,PLAYER_PLAY,&b,sizeof(b));
  882. n = 0;
  883. Player->Set(Player,PLAYER_LIST_COUNT,&n,sizeof(n));
  884. }
  885. }
  887. Count = ListView_GetItemCount(p->WndList);
  889. for (i=0;i<Count;++i)
  890. if (ListView_GetItemState(p->WndList,i,LVIS_SELECTED)==LVIS_SELECTED)
  891. {
  892. LVITEM Item;
  893. Item.iItem=i;
  894. Item.iSubItem=0;
  895. Item.mask=LVIF_PARAM;
  896. if (ListView_GetItem(p->WndList,&Item) && Item.lParam && (((openitem*)Item.lParam)->Image != IMG_DIR || p->SelectDir))
  897. {
  898. tchar_t URL[MAXPATH];
  899. if (((openitem*)Item.lParam)->FileName[0])
  900. AbsPath(URL,TSIZEOF(URL),((openitem*)Item.lParam)->FileName,p->Base);
  901. else
  902. tcscpy_s(URL,TSIZEOF(URL),p->Path);
  904. if (p->Class == SKIN_CLASS)
  905. {
  906. p->Win.Parent->Node.Set(&p->Win.Parent->Node,IF_SKINPATH,URL,TSIZEOF(URL));
  907. }
  908. else
  909. if (((openitem*)Item.lParam)->Image == IMG_DIR)
  910. n = PlayerAddDir(Player,n,URL,p->Exts,*p->CurrentFileType!=-1,0);
  911. else
  912. n = PlayerAdd(Player,n,URL,((openitem*)Item.lParam)->DisplayName?((openitem*)Item.lParam)->Name:NULL);
  913. }
  914. }
  916. if (!Add)
  917. p->Win.Result = 2;
  918. }
  920. WinClose(&p->Win);
  921. }
  923. static void Resize(openfile* p)
  924. {
  925. RECT r;
  926. int BorderX = WinUnitToPixelX(&p->Win,1);
  927. int BorderY = WinUnitToPixelY(&p->Win,1);
  928. int URLHeight;
  930. GetClientRect(p->Win.Wnd,&r);
  932. r.left += BorderX;
  933. r.right -= BorderX;
  935. if (p->Win.Smartphone)
  936. {
  937. URLHeight = WinUnitToPixelY(&p->Win,15);
  938. MoveWindow(p->WndURL,r.left,p->Top+BorderY,r.right-r.left,URLHeight-2*BorderY,0);
  939. }
  940. else
  941. {
  942. RECT Combo;
  943. int ButtonWidth = WinUnitToPixelX(&p->Win,30);
  945. SendMessage(p->WndURL,CB_SHOWDROPDOWN,0,0);
  946. r.right -= ButtonWidth;
  947. MoveWindow(p->WndURL,r.left,p->Top+BorderY,r.right-r.left-BorderX,WinUnitToPixelY(&p->Win,200),0);
  948. GetWindowRect(p->WndURL,&Combo);
  949. URLHeight = Combo.bottom - Combo.top + BorderY*2;
  950. MoveWindow(p->WndGo,r.right,p->Top+BorderY,ButtonWidth,URLHeight-BorderY*2,0);
  951. }
  953. GetClientRect(p->Win.Wnd,&r);
  955. r.top += p->Win.ToolBarHeight;
  956. MoveWindow(p->Win.WndDialog,r.left,r.top,r.right-r.left,URLHeight+p->Top,0);
  958. r.top += p->Top+URLHeight;
  959. MoveWindow(p->WndList,r.left,r.top,r.right-r.left,r.bottom-r.top,0);
  960. }
  962. static void InitMenu(openfile* p)
  963. {
  964. int i;
  966. if (!WinMenuEnable(&p->Win,1,OPENFILE_EMPTY,0))
  967. {
  968. WinMenuInsert(&p->Win,1,OPENFILE_HISTORY+1,OPENFILE_EMPTY,LangStr(OPENFILE_ID,OPENFILE_EMPTY));
  970. for (i=1;i<MAXHISTORY;++i)
  971. WinMenuDelete(&p->Win,1,OPENFILE_HISTORY+i);
  972. }
  974. if (p->HistoryCount>1)
  975. {
  976. for (i=1;i<MAXHISTORY;++i)
  977. WinMenuInsert(&p->Win,1,OPENFILE_EMPTY,OPENFILE_HISTORY+i,p->History[i]);
  979. WinMenuDelete(&p->Win,1,OPENFILE_EMPTY);
  980. }
  981. else
  982. WinMenuEnable(&p->Win,1,OPENFILE_EMPTY,0);
  983. }
  985. static bool_t DialogProc(openfile* p,int Msg, uint32_t wParam, uint32_t lParam, int* Result)
  986. {
  987. int i;
  989. switch (Msg)
  990. {
  991. case WM_KEYDOWN:
  992. if (wParam == VK_RETURN)
  993. PostMessage(p->Win.Wnd,WM_COMMAND,PLATFORM_OK,0);
  994. break;
  996. case WM_COMMAND:
  998. if (p->WndGo == (HWND)lParam && HIWORD(wParam)==BN_CLICKED && !p->InUpdate)
  999. SendMessage(p->Win.Wnd,WM_COMMAND,OPENFILE_GO,0);
  1001. if (p->WndURL == (HWND)lParam)
  1002. {
  1003. if (p->Win.Smartphone)
  1004. {
  1005. switch (HIWORD(wParam))
  1006. {
  1007. case EN_SETFOCUS:
  1008. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_URL,0);
  1009. p->Win.CaptureKeys = 1;
  1010. break;
  1011. case EN_KILLFOCUS:
  1012. p->Win.CaptureKeys = 0;
  1013. break;
  1014. }
  1015. }
  1016. else
  1017. {
  1018. switch (HIWORD(wParam))
  1019. {
  1020. case CBN_CLOSEUP:
  1021. if (!p->InUpdate)
  1022. {
  1023. i = SendMessage(p->WndURL,CB_GETCURSEL,0,0);
  1024. if (i!=CB_ERR && i>0 && i < p->HistoryCount)
  1025. {
  1026. SetURLText(p,p->History[i]);
  1027. PostMessage(p->Win.Wnd,WM_COMMAND,OPENFILE_GO,0);
  1028. }
  1029. }
  1030. break;
  1032. case CBN_SETFOCUS:
  1033. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_URL,0);
  1034. p->Win.CaptureKeys = 1;
  1035. break;
  1037. case CBN_KILLFOCUS:
  1038. p->Win.CaptureKeys = 0;
  1039. break;
  1040. }
  1041. }
  1042. }
  1043. }
  1044. return 0;
  1045. }
  1047. static const menudef MenuDef[] =
  1048. {
  1049. { 0,PLATFORM_ID, PLATFORM_OK },
  1050. { 0,OPENFILE_ID, OPENFILE_FILTER },
  1051. { 1,OPENFILE_ID, OPENFILE_ALL_FILES },
  1052. { 0,PLATFORM_ID, PLATFORM_CANCEL },
  1053. { 0,-1,-1 },
  1054. { 0,OPENFILE_ID, OPENFILE_MORE },
  1055. { 0,-1,-1 },
  1056. { 0,OPENFILE_ID, OPENFILE_SELECTALL },
  1057. { 0,-1,-1 },
  1058. { 0,OPENFILE_ID, OPENFILE_SELECTDIR },
  1060. MENUDEF_END
  1061. };
  1063. static const menudef MenuDefSingle[] =
  1064. {
  1065. { 0,PLATFORM_ID, PLATFORM_OK },
  1066. { 0,OPENFILE_ID, OPENFILE_FILTER },
  1067. { 1,OPENFILE_ID, OPENFILE_ALL_FILES },
  1068. { 0,PLATFORM_ID, PLATFORM_CANCEL },
  1070. MENUDEF_END
  1071. };
  1073. static const menudef MenuDefSmart[] =
  1074. {
  1075. { 0,PLATFORM_ID, PLATFORM_OK },
  1076. { 0,OPENFILE_ID, OPENFILE_OPTIONS },
  1077. { 1,OPENFILE_ID, OPENFILE_ENTERURL },
  1078. { 1,OPENFILE_ID, OPENFILE_HISTORYMENU },
  1079. { 2,OPENFILE_ID, OPENFILE_EMPTY },
  1080. { 1,OPENFILE_ID, OPENFILE_MORE },
  1081. { 1,OPENFILE_ID, OPENFILE_SELECTALL },
  1082. { 1,OPENFILE_ID, OPENFILE_SELECTDIR2 },
  1083. { 1,OPENFILE_ID, OPENFILE_SORT },
  1084. { 2,OPENFILE_ID, OPENFILE_LABEL_NAME },
  1085. { 2,OPENFILE_ID, OPENFILE_LABEL_TYPE },
  1086. { 2,OPENFILE_ID, OPENFILE_LABEL_SIZE },
  1087. { 2,OPENFILE_ID, OPENFILE_LABEL_DATE },
  1088. { 1,OPENFILE_ID, OPENFILE_FILTER },
  1089. { 2,OPENFILE_ID, OPENFILE_ALL_FILES },
  1090. { 1,OPENFILE_ID, OPENFILE_ONLYNAME },
  1091. { 1,PLATFORM_ID, PLATFORM_CANCEL },
  1093. MENUDEF_END
  1094. };
  1096. static const menudef MenuDefSmartSingle[] =
  1097. {
  1098. { 0,PLATFORM_ID, PLATFORM_OK },
  1099. { 0,OPENFILE_ID, OPENFILE_OPTIONS },
  1100. { 1,OPENFILE_ID, OPENFILE_ENTERURL },
  1101. { 1,OPENFILE_ID, OPENFILE_HISTORYMENU },
  1102. { 2,OPENFILE_ID, OPENFILE_EMPTY },
  1103. { 1,OPENFILE_ID, OPENFILE_SORT },
  1104. { 2,OPENFILE_ID, OPENFILE_LABEL_NAME },
  1105. { 2,OPENFILE_ID, OPENFILE_LABEL_TYPE },
  1106. { 2,OPENFILE_ID, OPENFILE_LABEL_SIZE },
  1107. { 2,OPENFILE_ID, OPENFILE_LABEL_DATE },
  1108. { 1,OPENFILE_ID, OPENFILE_FILTER },
  1109. { 2,OPENFILE_ID, OPENFILE_ALL_FILES },
  1110. { 1,OPENFILE_ID, OPENFILE_ONLYNAME },
  1111. { 1,PLATFORM_ID, PLATFORM_CANCEL },
  1113. MENUDEF_END
  1114. };
  1116. static const menudef MenuDefSmartSingleSave[] =
  1117. {
  1118. { 0,OPENFILE_ID, OPENFILE_SAVE },
  1119. { 0,OPENFILE_ID, OPENFILE_OPTIONS },
  1120. { 1,OPENFILE_ID, OPENFILE_ENTERNAME },
  1121. { 1,OPENFILE_ID, OPENFILE_ENTERURL },
  1122. { 1,OPENFILE_ID, OPENFILE_HISTORYMENU },
  1123. { 2,OPENFILE_ID, OPENFILE_EMPTY },
  1124. { 1,OPENFILE_ID, OPENFILE_SORT },
  1125. { 2,OPENFILE_ID, OPENFILE_LABEL_NAME },
  1126. { 2,OPENFILE_ID, OPENFILE_LABEL_TYPE },
  1127. { 2,OPENFILE_ID, OPENFILE_LABEL_SIZE },
  1128. { 2,OPENFILE_ID, OPENFILE_LABEL_DATE },
  1129. { 1,OPENFILE_ID, OPENFILE_FILTER },
  1130. { 2,OPENFILE_ID, OPENFILE_ALL_FILES },
  1131. { 1,OPENFILE_ID, OPENFILE_ONLYNAME },
  1132. { 1,PLATFORM_ID, PLATFORM_CANCEL },
  1134. MENUDEF_END
  1135. };
  1137. static int Command(openfile* p,int i)
  1138. {
  1139. if (i>=OPENFILE_HISTORY && i<OPENFILE_HISTORY+p->HistoryCount && !p->InUpdate)
  1140. {
  1141. SetURLText(p,p->History[i-OPENFILE_HISTORY]);
  1142. PostMessage(p->Win.Wnd,WM_COMMAND,OPENFILE_GO,0);
  1143. }
  1144. else
  1145. switch (i)
  1146. {
  1147. case OPENFILE_SAVE:
  1148. Save(p);
  1149. break;
  1151. case PLATFORM_OK:
  1152. if (p->Win.Focus && p->Win.Focus->Pin.No == OPENFILE_URL)
  1153. SendMessage(p->Win.Wnd,WM_COMMAND,OPENFILE_GO,0);
  1154. else
  1155. if (p->Flags & OPENFLAG_SAVE)
  1156. Save(p);
  1157. else
  1158. Add(p); 
  1159. return ERR_NONE;
  1161. case OPENFILE_TYPES-1:
  1162. *p->CurrentFileType = 0;
  1163. UpdateFileType(p,1);
  1164. break;
  1165. case OPENFILE_ALL_FILES:
  1166. *p->CurrentFileType = -1;
  1167. UpdateFileType(p,1);
  1168. break;
  1170. case OPENFILE_ONLYNAME:
  1171. p->OnlyName = !p->OnlyName;
  1172. UpdateOnlyName(p);
  1173. break;
  1175. case OPENFILE_LABEL_NAME:
  1176. case OPENFILE_LABEL_TYPE:
  1177. case OPENFILE_LABEL_SIZE:
  1178. case OPENFILE_LABEL_DATE:
  1179. if (i == OPENFILE_LABEL_DATE)
  1180. i = 3;
  1181. else
  1182. i -= OPENFILE_LABEL_NAME;
  1183. if (p->SortCol != i)
  1184. p->SortDir = 0;
  1185. else
  1186. p->SortDir = !p->SortDir;
  1187. p->SortCol = i;
  1188. UpdateSort(p);
  1189. break;
  1191. case OPENFILE_GO:
  1192. if (!p->InUpdate)
  1193. {
  1194. tcscpy_s(p->Last,TSIZEOF(p->Last),p->Path);
  1195. GetWindowText(p->WndURL,p->Path,TSIZEOF(p->Path));
  1196. if (tcsicmp(p->Last,p->Path)==0)
  1197. SavePos(p);
  1198. else
  1199. p->Last[0] = 0;
  1201. UpdateList(p,0,1);
  1202. }
  1203. break;
  1205. case OPENFILE_ENTERNAME:
  1206. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_SAVE_NAME,1);
  1207. break;
  1209. case OPENFILE_ENTERURL:
  1210. SendMessage(p->WndURL,EM_SETSYMBOLS,0,(LPARAM)SYMBOLS);
  1211. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_URL,1);
  1212. break;
  1214. case OPENFILE_SELECTDIR:
  1215. case OPENFILE_SELECTDIR2:
  1216. p->SelectDir = !p->SelectDir;
  1217. UpdateSelectDir(p);
  1218. break;
  1220. case OPENFILE_SELECTALL:
  1221. p->Multiple = 1;
  1222. UpdateMultiple(p);
  1223. SelectAll(p);
  1224. break;
  1226. case OPENFILE_MORE:
  1227. p->Multiple = !p->Multiple;
  1228. UpdateMultiple(p);
  1229. break;
  1230. }
  1232. if (i >= OPENFILE_TYPES && i < OPENFILE_TYPES+ARRAYCOUNT(p->Types,int))
  1233. {
  1234. *p->CurrentFileType = ARRAYBEGIN(p->Types,int)[i-OPENFILE_TYPES];
  1235. UpdateFileType(p,1);
  1236. }
  1238. return ERR_INVALID_PARAM;
  1239. }
  1241. static bool_t Proc(openfile* p,int Msg, uint32_t wParam, uint32_t lParam, int* Result)
  1242. {
  1243. LPNMLISTVIEW Notify;
  1244. int Style;
  1245. int FontSize;
  1246. wincontrol* Control;
  1247. bool_t HasHost;
  1248. tchar_t Mime[MAXMIME];
  1250. switch (Msg)
  1251. {
  1252. case WM_KEYDOWN:
  1253. if (wParam == VK_RETURN)
  1254. {
  1255. SendMessage(p->Win.Wnd,WM_COMMAND,OPENFILE_GO,0);
  1256. return 1;
  1257. }
  1259. if (wParam == VK_ESCAPE)
  1260. PostMessage(p->Win.Wnd,WM_CLOSE,0,0);
  1261. break;
  1263. case WM_INITMENUPOPUP:
  1264. InitMenu(p);
  1265. break;
  1267. case MSG_PREPARE:
  1268. p->CurrentFileType = (p->Flags & OPENFLAG_SINGLE) ? &p->FileTypeSingle : &p->FileType;
  1269. p->Last[0] = 0;
  1271. if (p->Win.Smartphone)
  1272. if (p->Flags & OPENFLAG_SAVE)
  1273. p->Win.MenuDef = MenuDefSmartSingleSave;
  1274. else
  1275. p->Win.MenuDef = (p->Flags & OPENFLAG_SINGLE) ? MenuDefSmartSingle : MenuDefSmart;
  1276. else
  1277. p->Win.MenuDef = (p->Flags & OPENFLAG_SINGLE) ? MenuDefSingle : MenuDef;
  1278. break;
  1280. case WM_CREATE:
  1281. if (p->Win.Smartphone)
  1282. {
  1283. p->WndGo = NULL;
  1284. p->WndURL = CreateWindow(T("EDIT"), NULL, WS_TABSTOP|WS_VISIBLE|WS_CHILD|WS_BORDER|ES_AUTOHSCROLL, 
  1285. 0,0,10,10,p->Win.WndDialog, NULL, p->Win.Module, NULL);
  1286. SetWindowLong(p->WndURL,GWL_USERDATA,1); // send back key to control
  1287. SendMessage(p->WndURL,EM_SETSYMBOLS,0,(LPARAM)SYMBOLS);
  1288. }
  1289. else
  1290. {
  1291. p->WndURL = CreateWindow(T("COMBOBOX"), NULL, WS_TABSTOP|WS_VISIBLE|WS_CHILD|CBS_DROPDOWN|CBS_AUTOHSCROLL, 
  1292. 0,0,10,10,p->Win.WndDialog, NULL, p->Win.Module, 0L);
  1294. p->WndGo = CreateWindow(T("BUTTON"),NULL,WS_TABSTOP|WS_VISIBLE|WS_CHILD|BS_PUSHBUTTON|BS_NOTIFY,
  1295. 0,0,10,10,p->Win.WndDialog, NULL, p->Win.Module, NULL );
  1297. SetWindowText(p->WndGo,LangStr(OPENFILE_ID,OPENFILE_GO));
  1299. FontSize = 11;
  1300. SendMessage(p->WndGo,WM_SETFONT,(WPARAM)WinFont(&p->Win,&FontSize,0),0);
  1301. }
  1303. FontSize = 12;
  1304. SendMessage(p->WndURL,WM_SETFONT,(WPARAM)WinFont(&p->Win,&FontSize,0),0);
  1306. Style = WS_TABSTOP|WS_VISIBLE|WS_CHILD|WS_VSCROLL|WS_HSCROLL|LVS_REPORT|LVS_SHOWSELALWAYS;
  1307. if (p->Win.Smartphone)
  1308. Style |= LVS_NOCOLUMNHEADER;
  1310. p->WndList = CreateWindow(T("SysListView32"), NULL, Style,
  1311. 0,0,20,20, p->Win.Wnd, NULL, p->Win.Module, NULL);
  1313. ListView_SetExtendedListViewStyle(p->WndList,LVS_EX_FULLROWSELECT);
  1315. if (WinUnitToPixelX(&p->Win,72) >= 96*2)
  1316. ListView_SetImageList(p->WndList,
  1317. ImageList_LoadBitmap(p->Win.Module,MAKEINTRESOURCE(IDB_FICON32),32,0,0xFF00FF), LVSIL_SMALL);
  1318. else
  1319. ListView_SetImageList(p->WndList,
  1320. ImageList_LoadBitmap(p->Win.Module,MAKEINTRESOURCE(IDB_FICON16),16,0,0xFF00FF), LVSIL_SMALL);
  1322. AddCol(p,0,LangStr(OPENFILE_ID,OPENFILE_LABEL_NAME),max(15,p->DlgWidth[0]),LVCFMT_LEFT);
  1323. AddCol(p,1,LangStr(OPENFILE_ID,OPENFILE_LABEL_TYPE),max(15,p->DlgWidth[1]),LVCFMT_LEFT);
  1324. AddCol(p,2,LangStr(OPENFILE_ID,OPENFILE_LABEL_SIZE),max(15,p->DlgWidth[2]),LVCFMT_RIGHT);
  1325. AddCol(p,3,LangStr(OPENFILE_ID,OPENFILE_LABEL_DATE),max(15,p->DlgWidth[3]),LVCFMT_LEFT);
  1326. p->OnlyNameState = 0;
  1328. p->LastClick = -1;
  1329. p->Top = 0;
  1330. p->Win.LabelWidth = 40;
  1332. if (p->Flags & OPENFLAG_SAVE)
  1333. {
  1334. if (!p->FileTypeSave)
  1335. p->FileTypeSave = NodeEnumClass(NULL,p->Class);
  1337. p->Top += 2;
  1338. WinPropValue(&p->Win,&p->Top,&p->Win.Node,OPENFILE_SAVE_NAME);
  1339. p->Top += 2;
  1340. WinPropValue(&p->Win,&p->Top,&p->Win.Node,OPENFILE_SAVE_TYPE);
  1341. p->Top = WinUnitToPixelY(&p->Win,p->Top+2);
  1342. }
  1344. Control = WinPropNative(&p->Win,&p->Win.Node,OPENFILE_LIST);
  1345. Control->Control = p->WndList;
  1346. Control->ListView = 1;
  1347. Control->External = 1;
  1349. Control = WinPropNative(&p->Win,&p->Win.Node,OPENFILE_URL);
  1350. Control->Control = p->WndURL;
  1351. Control->External = 1;
  1353. p->SelectDir = 0;
  1355. Resize(p);
  1357. GetMime(p->Path,Mime,TSIZEOF(Mime),&HasHost);
  1359. UpdateMenu(p);
  1360. UpdateFileType(p,HasHost?0:2);
  1361. UpdateSort(p);
  1362. UpdateMultiple(p);
  1363. UpdateSelectDir(p);
  1364. UpdateOnlyName(p);
  1366. if (p->Flags & OPENFLAG_SAVE)
  1367. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_SAVE_NAME,1);
  1368. else
  1369. if (HasHost)
  1370. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_URL,1);
  1371. break;
  1373. case WM_DESTROY:
  1374. if (!p->OnlyNameState)
  1375. {
  1376. p->DlgWidth[0] = GetColWidth(p,0);
  1377. p->DlgWidth[1] = GetColWidth(p,1);
  1378. p->DlgWidth[2] = GetColWidth(p,2);
  1379. p->DlgWidth[3] = GetColWidth(p,3);
  1380. }
  1381. ClearList(p);
  1382. break;
  1384. case WM_SIZE:
  1385. Resize(p);
  1386. break;
  1388. case WM_NOTIFY:
  1389. Notify = (LPNMLISTVIEW) lParam;
  1391. if (Notify->hdr.hwndFrom == p->WndList)
  1392. {
  1393. if (Notify->hdr.code == NM_SETFOCUS)
  1394. WinPropFocus(&p->Win,&p->Win.Node,OPENFILE_LIST,0);
  1396. // mouse double click in multiple mode
  1397. if (p->Multiple && !(p->Flags & OPENFLAG_SINGLE) && 
  1398. Notify->hdr.code==LVN_ITEMACTIVATE && Notify->iItem==p->LastClick &&
  1399. Notify->ptAction.x >= 0 && Notify->ptAction.y >= 0)
  1400. {
  1401. LVITEM Item;
  1402. Item.iItem=Notify->iItem;
  1403. Item.iSubItem=0;
  1404. Item.mask=LVIF_PARAM;
  1406. if (ListView_GetItem(p->WndList,&Item) && Item.lParam && (((openitem*)Item.lParam)->Image != IMG_DIR || p->SelectDir))
  1407. {
  1408. SelectIfNone(p,Notify->iItem);
  1409. PostMessage(p->Win.Wnd,WM_COMMAND,PLATFORM_OK,0);
  1410. return 0;
  1411. }
  1412. }
  1414. if (Notify->hdr.code==LVN_ITEMACTIVATE || Notify->hdr.code==NM_CLICK)
  1415. {
  1416. LVITEM Item;
  1417. Item.iItem=Notify->iItem;
  1418. Item.iSubItem=0;
  1419. Item.mask=LVIF_PARAM;
  1421. p->LastClick = Notify->iItem;
  1423. if (ListView_GetItem(p->WndList,&Item))
  1424. {
  1425. tchar_t Path[MAXPATH];
  1427. if (!Item.lParam) // ".."
  1428. {
  1429. if (UpperPath(p->Path,p->Last,TSIZEOF(p->Last))) 
  1430. {
  1431. p->LastClick = -1;
  1432. UpdateList(p,1,1);
  1433. }
  1434. }
  1435. else
  1436. if (((openitem*)Item.lParam)->Image==IMG_DIR && !p->SelectDir) // directory
  1437. {
  1438. AbsPath(Path,TSIZEOF(Path),((openitem*)Item.lParam)->FileName,p->Base);
  1439. tcscpy_s(p->Path,TSIZEOF(p->Path),Path);
  1440. p->Last[0] = 0;
  1441. p->LastClick = -1;
  1442. UpdateList(p,1,1);
  1443. }
  1444. else
  1445. {
  1446. if (p->Multiple && !(p->Flags & OPENFLAG_SINGLE))
  1447. {
  1448. int State = ListView_GetItemState(p->WndList,Notify->iItem,LVIS_SELECTED) & LVIS_SELECTED;
  1450. p->OwnSelect = 1;
  1451. ListView_SetItemState(p->WndList,Notify->iItem,(State ^ LVIS_SELECTED)|LVIS_FOCUSED,LVIS_SELECTED|LVIS_FOCUSED);
  1452. p->OwnSelect = 0;
  1454. if (p->KeyClick)
  1455. keybd_event(VK_DOWN,1,0,0);
  1456. }
  1457. else
  1458. {
  1459. if (p->Flags & OPENFLAG_SAVE)
  1460. SetSaveName(p,Notify->iItem);
  1461. else
  1462. {
  1463. SelectIfNone(p,Notify->iItem);
  1464. PostMessage(p->Win.Wnd,WM_COMMAND,PLATFORM_OK,0);
  1465. }
  1466. }
  1467. }
  1468. }
  1470. p->KeyClick = 0;
  1471. }
  1473. if (Notify->hdr.code==LVN_KEYDOWN && ((LPNMLVKEYDOWN)lParam)->wVKey == VK_ESCAPE)
  1474. PostMessage(p->Win.Wnd,WM_CLOSE,0,0);
  1476. if (p->Multiple && !(p->Flags & OPENFLAG_SINGLE))
  1477. {
  1478. // manual focus and selection
  1480. if (Notify->hdr.code==LVN_KEYDOWN)
  1481. {
  1482. // pass one focus change after keyboard
  1484. LPNMLVKEYDOWN Key = (LPNMLVKEYDOWN) lParam;
  1486. if (Key->wVKey == VK_RETURN)
  1487. p->KeyClick = 1;
  1489. if (Key->wVKey == VK_UP ||
  1490. Key->wVKey == VK_PRIOR  ||
  1491. Key->wVKey == VK_HOME)
  1492. {
  1493. if (ListView_GetItemState(p->WndList,0,LVIS_FOCUSED)!=LVIS_FOCUSED)
  1494. p->NextFocus = 1;
  1495. }
  1497. if (Key->wVKey == VK_DOWN ||
  1498. Key->wVKey == VK_NEXT ||
  1499. Key->wVKey == VK_END)
  1500. {
  1501. if (ListView_GetItemState(p->WndList,ListView_GetItemCount(p->WndList)-1,LVIS_FOCUSED)!=LVIS_FOCUSED)
  1502. p->NextFocus = 1;
  1503. }
  1504. }
  1506. if (p->NextFocus && Notify->hdr.code==LVN_ITEMCHANGED && (Notify->uChanged & LVIF_STATE) && 
  1507. ((Notify->uOldState ^ Notify->uNewState) & LVIS_FOCUSED))
  1508. {
  1509. // clear NextFocus if the new focus has been set
  1510. if (Notify->uNewState & LVIS_FOCUSED)
  1511. p->NextFocus = 0;
  1513. if ((Notify->uOldState ^ Notify->uNewState) & LVIS_SELECTED)
  1514. {
  1515. // restore old selection
  1516. p->OwnSelect = 1;
  1517. ListView_SetItemState(p->WndList,Notify->iItem,Notify->uOldState & LVIS_SELECTED,LVIS_SELECTED);
  1518. p->OwnSelect = 0;
  1519. }
  1520. }
  1522. if (!p->OwnSelect && Notify->hdr.code==LVN_ITEMCHANGING && (Notify->uChanged & LVIF_STATE))
  1523. {
  1524. // let focus change pass (if NextFocus is set)
  1525. if (!p->NextFocus || !((Notify->uOldState ^ Notify->uNewState) & LVIS_FOCUSED))
  1526. {
  1527. *Result = 1;
  1528. return 1;
  1529. }
  1530. }
  1531. }
  1533. if (Notify->hdr.code==LVN_COLUMNCLICK)
  1534. {
  1535. if (p->SortCol != Notify->iSubItem)
  1536. p->SortDir = 0;
  1537. else
  1538. p->SortDir = !p->SortDir;
  1539. p->SortCol = Notify->iSubItem;
  1541. UpdateSort(p);
  1542. }
  1543. }
  1544. break;
  1545. }
  1546. return 0;
  1547. }
  1549. static void Delete(openfile* p)
  1550. {
  1551. int i;
  1552. #ifndef REGISTRY_GLOBAL
  1553. NodeRegSave(&p->Win.Node);
  1554. #endif
  1555. ArrayClear(&p->Types);
  1556. for (i=0;i<MAXHISTORY;++i)
  1557. free(p->History[i]);
  1558. }
  1560. static int Create(openfile* p)
  1561. {
  1562. p->OnlyName = p->Win.Smartphone;
  1563. p->DlgWidth[1] = 40;
  1564. p->DlgWidth[2] = 46;
  1565. p->DlgWidth[3] = 60;
  1566. p->Class = MEDIA_CLASS;
  1567. p->CurrentFileType = &p->FileType;
  1569. #ifdef TARGET_WIN32
  1570. p->DlgWidth[0] = 150;
  1571. p->Win.WinWidth = 320;
  1572. #else
  1573. p->DlgWidth[0] = 90;
  1574. p->Win.WinWidth = 180;
  1575. #endif
  1576. p->Win.WinHeight = 240;
  1577. p->Win.Flags |= WIN_DIALOG;
  1578. p->Win.OwnDialogSize = 1;
  1579. p->Win.Command = (wincommand)Command;
  1580. p->Win.Proc = Proc;
  1581. p->Win.DialogProc = DialogProc;
  1582. p->Win.Node.Enum = Enum;
  1583. p->Win.Node.Get = Get;
  1584. p->Win.Node.Set = Set;
  1585. return ERR_NONE;
  1586. }
  1588. static const nodedef OFile =
  1589. {
  1590. sizeof(openfile)|CF_GLOBAL,
  1591. OPENFILE_ID,
  1592. WIN_CLASS,
  1593. PRI_DEFAULT,
  1594. (nodecreate)Create,
  1595. (nodedelete)Delete,
  1596. };
  1598. void OpenFile_Init()
  1599. {
  1600. NodeRegisterClass(&OFile);
  1601. }
  1603. void OpenFile_Done()
  1604. {
  1605. NodeUnRegisterClass(OPENFILE_ID);
  1606. }
  1608. #endif