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

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

Windows CE

开发平台：

C/C++

interface.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: interface.c 624 2006-02-01 17:48:42Z 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 "interface.h"
  27. #include "resource.h"
  28. #include "openfile_win32.h"
  29. #include "../about.h"
  30. #include "../benchresult.h"
  31. #include "../mediainfo.h"
  32. #include "../settings.h"
  33. #include "playlst.h"
  34. #include "../skin.h"
  35. #include "../../config.h"
  37. #define CORETHEQUE_UI_ID FOURCC('C','T','Q','U')
  39. #if defined(TARGET_WINCE) || defined(TARGET_WIN32)
  41. #ifndef STRICT
  42. #define STRICT
  43. #endif
  44. #include <windows.h>
  45. #if _MSC_VER > 1000
  46. #pragma warning(disable : 4201)
  47. #endif
  48. #include <commctrl.h>
  50. #define REG_INITING 0x2400
  52. #define TIMER_CLIPPING 500
  53. #define TIMER_INITING 501
  54. #define TIMER_SLEEP 502
  55. #define TIMER_KEYINSEEK 503
  56. #define TIMER_SLIDERINSEEK 504
  57. #define TIMER_SLIDERINVOL 505
  58. #define TIMER_CLIPPING2 506
  59. #define TIMER_TITLESCROLL 507
  61. #define SLIDERINSEEK_CYCLE 250
  62. #define SLIDERINVOL_CYCLE 100
  63. #define KEYINSEEK_START 1000
  64. #define KEYINSEEK_REPEAT 500
  65. #define CLIPPING_CYCLE 200
  66. #define INITING_CYCLE 3000
  67. #define SLEEP_CYCLE 5000
  68. #define CLIPPING2_CYCLE 200
  69. #define TITLESCROLL_CYCLE 150
  70. #define TITLESCROLL_WAIT (4000/TITLESCROLL_CYCLE)
  72. #define TRACKMAX 30000
  73. #define TRACKHEIGHT 16
  74. #define TRACKTHUMB 12
  76. #define TITLEHEIGHT 16
  77. #define TITLEFONT 11
  79. #define VOLMINWIDTH 35
  80. #define VOLTHUMB 12
  82. #define IF_AUDIO 50000
  83. #define IF_VIDEO 51000
  84. #define IF_VIDEOACCEL 52000
  85. #define IF_CHAPTER 53000
  86. #define IF_STREAM_AUDIO 54000
  87. #define IF_STREAM_VIDEO 55000
  88. #define IF_STREAM_SUBTITLE 56000
  90. static int HotKey[] = 
  91. {
  92. IF_FILE_OPENFILE,
  93. IF_FILE_PLAYLIST,
  94. IF_PLAY,
  95. IF_PLAYPAUSE,
  96. IF_PLAY_FULLSCREEN,
  97. IF_STOP,
  98. IF_MOVE_FFWD,
  99. IF_MOVE_BACK,
  100. IF_NEXT,
  101. IF_PREV,
  102. IF_PREV_SMART,
  103. IF_NEXT2,
  104. IF_PREV_SMART2,
  105. IF_FASTFORWARD,
  106. IF_OPTIONS_VOLUME_UP,
  107. IF_OPTIONS_VOLUME_DOWN,
  108. IF_OPTIONS_VOLUME_UP_FINE,
  109. IF_OPTIONS_VOLUME_DOWN_FINE,
  110. IF_OPTIONS_MUTE,
  111. IF_OPTIONS_EQUALIZER,
  112. IF_OPTIONS_FULLSCREEN,
  113. IF_OPTIONS_ZOOM_FIT,
  114. IF_OPTIONS_ZOOM_IN,
  115. IF_OPTIONS_ZOOM_OUT,
  116. IF_OPTIONS_ROTATE,
  117. IF_OPTIONS_BRIGHTNESS_UP,
  118. IF_OPTIONS_BRIGHTNESS_DOWN,
  119. IF_OPTIONS_CONTRAST_UP,
  120. IF_OPTIONS_CONTRAST_DOWN,
  121. IF_OPTIONS_SATURATION_UP,
  122. IF_OPTIONS_SATURATION_DOWN,
  123. IF_OPTIONS_TOGGLE_VIDEO,
  124. IF_OPTIONS_TOGGLE_AUDIO,
  125. //!SUBTITLE IF_OPTIONS_TOGGLE_SUBTITLE,
  126. IF_OPTIONS_AUDIO_STEREO_TOGGLE,
  127. IF_OPTIONS_SCREEN,
  128. IF_FILE_EXIT,
  129. };
  131. #define HOTKEYCOUNT (sizeof(HotKey)/sizeof(int))
  133. typedef struct intface
  134. {
  135. win Win;
  136. DWORD ThreadId;
  137. player* Player;
  138. node* Color;
  139. node* Equalizer;
  140. WNDPROC DefTrackProc;
  141. WNDPROC DefVolProc;
  142. HWND WndTrack;
  143. HWND WndTitle;
  144. HWND WndVol;
  145. HWND WndVolBack;
  146. int TrackThumb;
  147. RECT ClientRect;
  148. rect SkinViewport;
  149. rect SkinArea;
  150. rect Viewport;
  151. int InSkin;
  152. bool_t InVol;
  153. bool_t InSeek;
  154. bool_t Capture;
  155. bool_t ForceFullScreen;
  156. bool_t TrackBar;
  157. bool_t TitleBar;
  158. bool_t TaskBar;
  159. bool_t Buttons;
  160. bool_t Focus;
  161. bool_t Clipping;
  162. bool_t Overlap;
  163. bool_t VolResizeNeeded;
  164. bool_t VolResizeNeeded2;
  165. bool_t Exited;
  166. POINT Offset;
  167. bool_t Bench;
  168. bool_t Wait;
  169. bool_t CmdLineMode;
  170. int Vol;
  171. int HotKey[HOTKEYCOUNT];
  173. // refresh states
  174. int TrackSetPos;
  175. int TrackPos;
  176. bool_t Play;
  177. bool_t FFwd;
  178. bool_t FullScreen;
  179. bool_t Mute;
  181. HFONT TitleFont;
  182. int TitleFontSize;
  183. tick_t TitleTime;
  184. int TitleTimeWidth;
  185. int TitleNameWidth;
  186. int TitleNameSize;
  187. int TitleNameOffset;
  188. int ScrollMode;
  189. bool_t UpdateScroll;
  190. int TitleDurWidth;
  191. int TitleBorder;
  192. int TitleTop;
  193. int TitleWidth;
  194. int TitleHeight;
  195. HBRUSH TitleBrush;
  196. rgbval_t TitleFace;
  197. rgbval_t TitleText;
  198. tchar_t TitleName[256];
  199. tchar_t TitleDur[32];
  200. int MenuPreAmp;
  202. int MenuStreams;
  203. int MenuAStream;
  204. int MenuVStream;
  205. int MenuSubStream;
  207. array VOutput;
  208. array AOutput;
  210. bool_t AllKeys;
  211. bool_t AllKeysWarning;
  212. int SkinNo;
  213. skin Skin[MAX_SKIN];
  214. tchar_t SkinPath[MAXPATH];
  216. } intface;
  218. static void ResizeVolume(intface* p)
  219. {
  220. if (p->WndVolBack)
  221. {
  222. RECT rv;
  223. RECT r;
  224. POINT o;
  225. int Width;
  226. int i;
  228. GetClientRect(p->Win.WndTB,&r);
  229. if (r.left<r.right)
  230. {
  231. SendMessage(p->Win.WndTB,TB_GETRECT,IF_OPTIONS_MUTE,(LPARAM)&rv);
  233. #if defined(TARGET_WINCE)
  234. if (p->Win.ToolBarHeight) // decrease width by 'X' button on right
  235. r.right = max(r.left,r.right-(rv.right-rv.left));
  236. #endif
  238. Width = r.right-rv.right;
  239. if (Width < 16)
  240. Width = 16;
  242. i = WinUnitToPixelX(&p->Win,50);
  243. if (Width > i)
  244. Width = i;
  246. o.x = o.y = 0;
  247. if (!p->Win.ToolBarHeight)
  248. ClientToScreen(p->Win.WndTB,&o);
  250. MoveWindow(p->WndVolBack,rv.right+o.x,o.y+1,Width,r.bottom-1,TRUE);
  252. GetClientRect(p->WndVolBack,&r);
  253. i = WinUnitToPixelX(&p->Win,2);
  254. MoveWindow(p->WndVol,-i,0,r.right+2*i,r.bottom,TRUE);
  256. SendMessage(p->WndVol, TBM_SETTHUMBLENGTH,WinUnitToPixelY(&p->Win,VOLTHUMB),0);
  257. }
  258. }
  259. }
  261. static bool_t Toggle(intface* p,int Param,int Force);
  262. static void UpdateVolume(intface* p);
  263. static void UpdateClipping(intface* p,bool_t Suggest,bool_t HotKey);
  265. static void ShowVol(intface* p,bool_t Show)
  266. {
  267. if (p->WndVolBack && !p->Win.ToolBarHeight)
  268. {
  269. if (Show)
  270. SetWindowPos(p->WndVolBack,HWND_TOPMOST,0,0,0,0,SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_SHOWWINDOW);
  271. else
  272. ShowWindow(p->WndVolBack,SW_HIDE);
  274. if (p->VolResizeNeeded2>1)
  275. p->VolResizeNeeded2=1;
  277. }
  278. }
  280. static void Resize(intface* p)
  281. {
  282. RECT r;
  283. bool_t Rotated = IsOrientationChanged();
  285. DEBUG_MSG(DEBUG_VIDEO,T("Resize begin"));
  287. if (Rotated)
  288. {
  289. p->Player->Set(p->Player,PLAYER_ROTATEBEGIN,NULL,0);
  290. p->Player->Set(p->Player,PLAYER_RESETVIDEO,NULL,0);
  291. if (!p->Win.ToolBarHeight)
  292. {
  293. p->VolResizeNeeded2 = 1; // toolbar position may change later
  294. if (p->WndVolBack && IsWindowVisible(p->WndVolBack))
  295. {
  296. ShowVol(p,0);
  297. p->VolResizeNeeded2 = 2;
  298. }
  299. }
  300. else
  301. p->VolResizeNeeded = 1;
  303. if (p->Win.FullScreen)
  304. PostMessage(p->Win.Wnd,MSG_PLAYER,PLAYER_FULLSCREEN,0);
  305. }
  307. p->Offset.x = 0;
  308. p->Offset.y = 0;
  309. ClientToScreen(p->Win.Wnd,&p->Offset);
  311. if (!p->Win.FullScreen)
  312. {
  313. #if !defined(TARGET_WINCE) && defined(MAXIMIZE_FULLSCREEN)
  314. WINDOWPLACEMENT Place;
  315. Place.length = sizeof(Place);
  316. GetWindowPlacement(p->Win.Wnd,&Place);
  317. if (Place.showCmd != SW_MAXIMIZE)
  318. #endif
  319. {
  320. GetClientRect(p->Win.Wnd,&r);
  322. if (r.right != p->ClientRect.right || r.bottom != p->ClientRect.bottom)
  323. {
  324. bool_t Skin = p->Skin[p->SkinNo].Valid;
  325. int TrackThumb;
  326. int TrackHeight = 0;
  327. p->TitleHeight = 0;
  328. p->ClientRect = r;
  330. r.top += p->Win.ToolBarHeight;
  332. if (p->WndTrack)
  333. {
  334. TrackHeight = WinUnitToPixelY(&p->Win,TRACKHEIGHT);
  335. r.bottom -= TrackHeight;
  336. MoveWindow(p->WndTrack,r.left,r.bottom,r.right,TrackHeight,TRUE);
  338. TrackThumb = WinUnitToPixelY(&p->Win,TRACKTHUMB);
  339. if (p->TrackThumb != TrackThumb)
  340. {
  341. p->TrackThumb = TrackThumb; // avoid calling this regulary because it shows the trackbar
  342. SendMessage(p->WndTrack, TBM_SETTHUMBLENGTH,TrackThumb,0);
  343. }
  344. }
  346. if (p->WndTitle)
  347. {
  348. p->TitleTimeWidth = 0;
  349. p->TitleFontSize = TITLEFONT;
  350. p->TitleFont = WinFont(&p->Win,&p->TitleFontSize,0);
  351. p->TitleHeight = WinUnitToPixelY(&p->Win,TITLEHEIGHT);
  352. p->TitleBorder = WinUnitToPixelX(&p->Win,3);
  353. p->TitleWidth = r.right - r.left;
  355. if (Skin) 
  356. {
  357. skinitem* i = &p->Skin[p->SkinNo].Item[SKIN_TITLE];
  358. p->TitleWidth = i->Rect.Width;
  359. p->TitleHeight = i->Rect.Height;
  360. MoveWindow(p->WndTitle,r.left + i->Rect.x,r.top + i->Rect.y,p->TitleWidth,p->TitleHeight,TRUE);
  361. }
  362. else
  363. {
  364. if (p->Win.ToolBarHeight)
  365. {
  366. r.bottom -= p->TitleHeight;
  367. MoveWindow(p->WndTitle,r.left,r.bottom,p->TitleWidth,p->TitleHeight,TRUE);
  368. }
  369. else
  370. {
  371. MoveWindow(p->WndTitle,r.left,r.top,p->TitleWidth,p->TitleHeight,TRUE);
  372. r.top += p->TitleHeight;
  373. }
  374. }
  376. p->TitleTop = (p->TitleHeight-WinUnitToPixelY(&p->Win,p->TitleFontSize))/2;
  377. }
  379. p->SkinArea.x = r.left;
  380. p->SkinArea.y = r.top;
  381. p->SkinArea.Width = r.right - r.left;
  382. p->SkinArea.Height = r.bottom - r.top;
  384. if (!Skin)
  385. p->SkinViewport = p->SkinArea;
  386. else
  387. {
  388. p->SkinViewport = p->Skin[p->SkinNo].Item[SKIN_VIEWPORT].Rect;
  389. p->SkinViewport.x += p->SkinArea.x;
  390. p->SkinViewport.y += p->SkinArea.y;
  391. }
  393. if (p->Win.ToolBarHeight && !p->VolResizeNeeded)
  394. ResizeVolume(p);
  395. }
  397. p->Viewport = p->SkinViewport;
  398. p->Viewport.x += p->Offset.x;
  399. p->Viewport.y += p->Offset.y;
  400. p->Player->Set(p->Player,PLAYER_SKIN_VIEWPORT,&p->Viewport,sizeof(rect));
  401. p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
  403. if (p->VolResizeNeeded)
  404. {
  405. ResizeVolume(p);
  406. p->VolResizeNeeded = 0;
  407. }
  408. }
  409. }
  410. else
  411. {
  412. GetClientRect(p->Win.Wnd,&r);
  413. p->Viewport.x = r.left + p->Offset.x;
  414. p->Viewport.y = r.top + p->Offset.y;
  415. p->Viewport.Width = r.right - r.left;
  416. p->Viewport.Height = r.bottom - r.top;
  417. }
  419. if (Rotated)
  420. p->Player->Set(p->Player,PLAYER_ROTATEEND,NULL,0);
  422. DEBUG_MSG4(DEBUG_VIDEO,T("Resize end %d,%d,%d,%d"),p->Viewport.x,p->Viewport.y,p->Viewport.Width,p->Viewport.Height);
  423. }
  425. static BOOL CALLBACK EnumCheck(HWND Wnd, LPARAM lParam )
  426. {
  427. intface* p = (intface*) lParam;
  428. RECT r;
  430. if (Wnd == p->Win.Wnd)
  431. return 0;
  433. if (IsWindowVisible(Wnd))
  434. {
  435. GetWindowRect(Wnd,&r);
  437. if (p->Viewport.x < r.right &&
  438. p->Viewport.x + p->Viewport.Width > r.left &&
  439. p->Viewport.y < r.bottom &&
  440. p->Viewport.y + p->Viewport.Height > r.top)
  441. {
  442. p->Overlap = 1;
  443. return 0;
  444. }
  445. }
  446. return 1;
  447. }
  449. static void UpdateHotKey(intface* p,bool_t State,bool_t NoKeep)
  450. {
  451. int i;
  452. if (!p->AllKeys)
  453. {
  454. for (i=0;i<HOTKEYCOUNT;++i)
  455. if (p->HotKey[i])
  456. {
  457. if (State)
  458. {
  459. if (!WinEssentialKey(p->HotKey[i]))
  460. WinRegisterHotKey(&p->Win,HotKey[i],p->HotKey[i]);
  461. }
  462. else
  463. if (NoKeep || !(p->HotKey[i] & HOTKEY_KEEP))
  464. WinUnRegisterHotKey(&p->Win,HotKey[i]);
  465. else
  466. if (WinEssentialKey(p->HotKey[i])) //essential keys -> register in the background
  467. WinRegisterHotKey(&p->Win,HotKey[i],p->HotKey[i]);
  468. }
  469. }
  470. else
  471. {
  472. WinAllKeys(State);
  473. if (!State && !NoKeep)
  474. for (i=0;i<HOTKEYCOUNT;++i)
  475. if (p->HotKey[i] & HOTKEY_KEEP)
  476. WinRegisterHotKey(&p->Win,HotKey[i],p->HotKey[i]);
  477. }
  478. }
  480. static void UpdateSleepTimer(intface* p)
  481. {
  482. #if defined(TARGET_WINCE)
  483. if (p->Play>0 || p->FFwd>0)
  484. {
  485. SleepTimerReset();
  486. SetTimer(p->Win.Wnd,TIMER_SLEEP,SLEEP_CYCLE,NULL);
  487. }
  488. else
  489. KillTimer(p->Win.Wnd,TIMER_SLEEP);
  490. #endif
  491. }
  493. static void UpdateTitleScroll(intface* p)
  494. {
  495. if (p->Focus && p->TitleNameSize < p->TitleNameWidth)
  496. {
  497. if (p->TitleNameOffset >= p->TitleNameWidth - p->TitleNameSize)
  498. p->TitleNameOffset = p->TitleNameWidth - p->TitleNameSize;
  499. SetTimer(p->Win.Wnd,TIMER_TITLESCROLL,TITLESCROLL_CYCLE,NULL);
  500. }
  501. else
  502. {
  503. p->TitleNameOffset = 0;
  504. p->ScrollMode = 0;
  505. KillTimer(p->Win.Wnd,TIMER_TITLESCROLL);
  506. }
  507. }
  509. static void TitleScroll(intface* p)
  510. {
  511. if (p->ScrollMode<TITLESCROLL_WAIT)
  512. ++p->ScrollMode;
  513. else
  514. if (p->ScrollMode==TITLESCROLL_WAIT)
  515. {
  516. p->TitleNameOffset += 3;
  517. if (p->TitleNameOffset >= p->TitleNameWidth - p->TitleNameSize)
  518. {
  519. p->TitleNameOffset = p->TitleNameWidth - p->TitleNameSize;
  520. ++p->ScrollMode;
  521. }
  522. InvalidateRect(p->WndTitle,NULL,1); 
  523. }
  524. else
  525. if (p->ScrollMode<TITLESCROLL_WAIT*2+1)
  526. ++p->ScrollMode;
  527. else
  528. {
  529. p->TitleNameOffset -= 3;
  530. if (p->TitleNameOffset<=0)
  531. {
  532. p->TitleNameOffset=0;
  533. p->ScrollMode = 0;
  534. }
  535. InvalidateRect(p->WndTitle,NULL,1); 
  536. }
  538. UpdateTitleScroll(p);
  539. }
  541. static bool_t ShowVideo(intface* p)
  542. {
  543. bool_t b = p->Focus;
  544. if (!b)
  545. p->Player->Get(p->Player,PLAYER_SHOWINBACKGROUND,&b,sizeof(b));
  546. return b;
  547. }
  549. static void UpdateClippingTimer(intface* p)
  550. {
  551. if (p->Clipping && ShowVideo(p))
  552. SetTimer(p->Win.Wnd,TIMER_CLIPPING,CLIPPING_CYCLE,NULL);
  553. else
  554. KillTimer(p->Win.Wnd,TIMER_CLIPPING);
  555. }
  557. static bool_t IsOverlay(intface* p)
  558. {
  559. bool_t b = 0;
  560. p->Player->Get(p->Player,PLAYER_VIDEO_OVERLAY,&b,sizeof(b));
  561. return b;
  562. }
  564. static bool_t IsOverlapped(intface* p)
  565. {
  566. if (!p->Win.FullScreen || p->Wait)
  567. {
  568. // check for overlapping top-level windows
  569. p->Overlap = 0;
  570. EnumWindows(EnumCheck,(LPARAM)p);
  571. if (p->Overlap)
  572. return 1;
  573. }
  574. return 0;
  575. }
  577. static void UpdateClipping(intface* p,bool_t Suggest,bool_t HotKey)
  578. {
  579. if (p->Clipping != Suggest)
  580. {
  581. KillTimer(p->Win.Wnd,TIMER_CLIPPING2);
  583. if (!Suggest && IsOverlapped(p))
  584. return; // overlapping window -> clipping still needed
  586. p->Clipping = Suggest;
  587. p->Player->Set(p->Player,PLAYER_CLIPPING,&p->Clipping,sizeof(bool_t));
  589. if (HotKey)
  590. UpdateHotKey(p,!p->Clipping,0);
  592. UpdateClippingTimer(p);
  593. }
  594. }
  596. static void RefreshButton(intface* p,int No,bool_t* State,int Id,int Off,int On)
  597. {
  598. int i;
  599. bool_t b;
  601. if (p->Player->Get(p->Player,No,&b,sizeof(b)) != ERR_NONE)
  602. b = -1;
  604. switch (No)
  605. {
  606. case PLAYER_PLAY: i = SKIN_PLAY; break;
  607. case PLAYER_FFWD: i = SKIN_FFWD; break;
  608. case PLAYER_MUTE: i = SKIN_MUTE; break;
  609. case PLAYER_FULLSCREEN: i = SKIN_FULLSCREEN; break;
  610. case PLAYER_REPEAT: i = SKIN_REPEAT; break;
  611. default: i = -1; break;
  612. }
  614. if (i>=0 && p->Skin[p->SkinNo].Item[i].Pushed != b)
  615. {
  616. p->Skin[p->SkinNo].Item[i].Pushed = b;
  617. SkinDrawItem(p->Skin+p->SkinNo,p->Win.Wnd,i,&p->SkinArea);
  618. }
  620. if (State && b != *State)
  621. {
  622. if (b == -1 || *State == -1)
  623. SendMessage(p->Win.WndTB,TB_ENABLEBUTTON,Id,MAKELPARAM(b!=-1,0));
  625. *State = b;
  627. if (b != -1)
  628. {
  629. SendMessage(p->Win.WndTB,TB_CHECKBUTTON,Id,MAKELPARAM(b,0));
  631. if (On>=0)
  632. SendMessage(p->Win.WndTB,TB_CHANGEBITMAP,Id,MAKELPARAM(p->Win.BitmapNo+(b?On:Off),0));
  633. }
  634. }
  635. }
  637. static void SetTrackThumb(HWND Wnd, bool_t State)
  638. {
  639. int Style = GetWindowLong(Wnd,GWL_STYLE);
  641. if ((Style & TBS_NOTHUMB) != (State?0:TBS_NOTHUMB))
  642. {
  643. Style ^= TBS_NOTHUMB;
  644. SetWindowLong(Wnd,GWL_STYLE,Style);
  645. }
  646. }
  648. static void UpdateTitleTime(intface* p)
  649. {
  650. if (p->WndTitle)
  651. {
  652. tick_t Time;
  653. if (p->Player->Get(p->Player,PLAYER_POSITION,&Time,sizeof(tick_t)) == ERR_NONE)
  654. {
  655. Time = (Time / TICKSPERSEC) * TICKSPERSEC;
  656. if (Time<0)
  657. Time=0;
  658. }
  659. else
  660. Time = -1;
  662. if (Time != p->TitleTime)
  663. {
  664. RECT r;
  666. r.left = p->TitleWidth - p->TitleTimeWidth - p->TitleDurWidth - p->TitleBorder;
  667. r.right = r.left + p->TitleTimeWidth;
  668. r.top = 0;
  669. r.bottom = p->TitleHeight;
  671. p->TitleTime = Time;
  672. InvalidateRect(p->WndTitle,&r,0);
  673. }
  674. }
  675. }
  677. static void UpdateMenuBool(intface* p,int MenuId,int Param)
  678. {
  679. bool_t b = 0;
  680. WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&b,sizeof(b)) != ERR_NOT_SUPPORTED);
  681. WinMenuCheck(&p->Win,1,MenuId,b);
  682. }
  684. static void UpdateMenuInt(intface* p,int MenuId,int Param,int Value)
  685. {
  686. int v = 0;
  687. WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&v,sizeof(v)) != ERR_NOT_SUPPORTED);
  688. WinMenuCheck(&p->Win,1,MenuId,v==Value);
  689. }
  691. static void UpdateMenuFrac(intface* p,int MenuId,int Param,int Num,int Den)
  692. {
  693. fraction f = {0,0};
  694. WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&f,sizeof(f)) != ERR_NOT_SUPPORTED);
  695. WinMenuCheck(&p->Win,1,MenuId,f.Num*Den==f.Den*Num);
  696. }
  698. static void UpdateMenu(intface* p)
  699. {
  700. packetformat PacketFormat;
  701. node* AOutput;
  702. bool_t Stereo;
  703. bool_t b;
  704. int* i;
  705. int No,Id;
  706. int PreAmp;
  707. bool_t Accel;
  708. tchar_t Name[20+1];
  709. int ACurrent = -1;
  710. int VCurrent = -1;
  711. int SubCurrent = -1;
  713. // remove old chapters
  714. if (!WinMenuEnable(&p->Win,0,IF_FILE_CHAPTERS_NONE,0))
  715. {
  716. WinMenuInsert(&p->Win,0,IF_CHAPTER+1,IF_FILE_CHAPTERS_NONE,LangStr(INTERFACE_ID,IF_FILE_CHAPTERS_NONE));
  718. for (No=1;No<MAXCHAPTER;++No)
  719. if (!WinMenuDelete(&p->Win,0,IF_CHAPTER+No))
  720. break;
  721. }
  723. // add new chapters
  724. for (No=1;No<MAXCHAPTER && PlayerGetChapter(p->Player,No,Name,TSIZEOF(Name))>=0;++No)
  725. WinMenuInsert(&p->Win,0,IF_FILE_CHAPTERS_NONE,IF_CHAPTER+No,Name);
  727. if (No>1)
  728. WinMenuDelete(&p->Win,0,IF_FILE_CHAPTERS_NONE);
  729. else
  730. WinMenuEnable(&p->Win,0,IF_FILE_CHAPTERS_NONE,0);
  732. // remove old streams
  733. if (p->MenuVStream >= 0)
  734. {
  735. WinMenuInsert(&p->Win,1,p->MenuVStream,IF_OPTIONS_VIDEO_STREAM_NONE, LangStr(INTERFACE_ID,IF_OPTIONS_VIDEO_STREAM_NONE));
  737. for (No=0;No<p->MenuStreams;++No)
  738. WinMenuDelete(&p->Win,1,IF_STREAM_VIDEO+No);
  739. }
  740. if (p->MenuAStream >= 0)
  741. {
  742. WinMenuInsert(&p->Win,1,p->MenuAStream,IF_OPTIONS_AUDIO_STREAM_NONE, LangStr(INTERFACE_ID,IF_OPTIONS_AUDIO_STREAM_NONE));
  744. for (No=0;No<p->MenuStreams;++No)
  745. WinMenuDelete(&p->Win,1,IF_STREAM_AUDIO+No);
  746. }
  748. if (p->MenuSubStream >= 0)
  749. for (No=0;No<p->MenuStreams;++No)
  750. WinMenuDelete(&p->Win,1,IF_STREAM_SUBTITLE+No);
  752. // add new streams
  753. p->MenuStreams = 0;
  754. p->MenuAStream = -1;
  755. p->MenuVStream = -1;
  756. p->MenuSubStream = -1;
  758. for (No=0;PlayerGetStream(p->Player,No,&PacketFormat,Name,TSIZEOF(Name),NULL);++No)
  759. switch (PacketFormat.Type)
  760. {
  761. case PACKET_VIDEO:
  762. p->MenuVStream = IF_STREAM_VIDEO+No;
  763. WinMenuInsert(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE,IF_STREAM_VIDEO+No,Name);
  764. break;
  765. case PACKET_AUDIO:
  766. p->MenuAStream = IF_STREAM_AUDIO+No;
  767. WinMenuInsert(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE,IF_STREAM_AUDIO+No,Name);
  768. break;
  769. case PACKET_SUBTITLE:
  770. p->MenuSubStream = IF_STREAM_SUBTITLE+No;
  771. WinMenuInsert(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,IF_STREAM_SUBTITLE+No,Name);
  772. break;
  773. }
  775. p->MenuStreams = No;
  777. p->Player->Get(p->Player,PLAYER_VSTREAM,&VCurrent,sizeof(int));
  778. p->Player->Get(p->Player,PLAYER_ASTREAM,&ACurrent,sizeof(int));
  779. p->Player->Get(p->Player,PLAYER_SUBSTREAM,&SubCurrent,sizeof(int));
  781. if (p->MenuVStream<0)
  782. WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE,0);
  783. else
  784. {
  785. WinMenuCheck(&p->Win,1,IF_STREAM_VIDEO+VCurrent,1);
  786. WinMenuDelete(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE);
  787. }
  789. if (p->MenuAStream<0)
  790. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE,0);
  791. else
  792. {
  793. WinMenuCheck(&p->Win,1,IF_STREAM_AUDIO+ACurrent,1);
  794. WinMenuDelete(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE);
  795. }
  797. if (SubCurrent >= MAXSTREAM) 
  798. SubCurrent = -1;
  800. WinMenuEnable(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,p->MenuSubStream>=0);
  801. WinMenuCheck(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,SubCurrent<0);
  802. if (SubCurrent>=0)
  803. WinMenuCheck(&p->Win,1,IF_STREAM_SUBTITLE+SubCurrent,1);
  805. UpdateMenuFrac(p,IF_OPTIONS_ASPECT_AUTO,PLAYER_ASPECT,0,1);
  806. UpdateMenuFrac(p,IF_OPTIONS_ASPECT_SQUARE,PLAYER_ASPECT,1,1);
  807. UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_SCREEN,PLAYER_ASPECT,-4,3);
  808. UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_NTSC,PLAYER_ASPECT,10,11);
  809. UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_PAL,PLAYER_ASPECT,12,11);
  810. UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_SCREEN,PLAYER_ASPECT,-16,9);
  811. UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_NTSC,PLAYER_ASPECT,40,33);
  812. UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_PAL,PLAYER_ASPECT,16,11);
  814. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_SCREEN,PLAYER_FULL_ZOOM,0,1);
  815. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_110,PLAYER_FULL_ZOOM,-11,10);
  816. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_120,PLAYER_FULL_ZOOM,-12,10);
  817. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_130,PLAYER_FULL_ZOOM,-13,10);
  818. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FILL_SCREEN,PLAYER_FULL_ZOOM,-4,SCALE_ONE);
  819. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_STRETCH_SCREEN,PLAYER_FULL_ZOOM,-3,SCALE_ONE);
  820. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_50,PLAYER_FULL_ZOOM,1,2);
  821. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_100,PLAYER_FULL_ZOOM,1,1);
  822. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_150,PLAYER_FULL_ZOOM,3,2);
  823. UpdateMenuFrac(p,IF_OPTIONS_ZOOM_200,PLAYER_FULL_ZOOM,2,1);
  825. UpdateMenuBool(p,IF_OPTIONS_VIDEO_ZOOM_SMOOTH50,PLAYER_SMOOTH50);
  826. UpdateMenuBool(p,IF_OPTIONS_VIDEO_ZOOM_SMOOTHALWAYS,PLAYER_SMOOTHALWAYS);
  828. WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TITLEBAR,p->TitleBar);
  829. WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TRACKBAR,p->TrackBar);
  830. WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TASKBAR,p->TaskBar);
  832. //UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_LOW,PLAYER_AUDIO_QUALITY,0);
  833. //UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_MEDIUM,PLAYER_AUDIO_QUALITY,1);
  834. //UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_HIGH,PLAYER_AUDIO_QUALITY,2);
  836. if (p->Player->Get(p->Player,PLAYER_PREAMP,&PreAmp,sizeof(PreAmp)) != ERR_NONE)
  837. PreAmp = 0;
  838. if (PreAmp != p->MenuPreAmp)
  839. {
  840. p->MenuPreAmp = PreAmp;
  841. stprintf_s(Name,TSIZEOF(Name),LangStr(INTERFACE_ID,IF_OPTIONS_AUDIO_PREAMP),PreAmp);
  842. WinMenuDelete(&p->Win,1,IF_OPTIONS_AUDIO_PREAMP);
  843. WinMenuInsert(&p->Win,1,IF_OPTIONS_AUDIO_PREAMP_INC,IF_OPTIONS_AUDIO_PREAMP,Name);
  844. }
  846. UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_LOWEST,PLAYER_VIDEO_QUALITY,0);
  847. UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_LOW,PLAYER_VIDEO_QUALITY,1);
  848. UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_NORMAL,PLAYER_VIDEO_QUALITY,2);
  850. UpdateMenuInt(p,IF_OPTIONS_ROTATE_GUI,PLAYER_FULL_DIR,-1);
  851. UpdateMenuInt(p,IF_OPTIONS_ROTATE_0,PLAYER_FULL_DIR,0);
  852. UpdateMenuInt(p,IF_OPTIONS_ROTATE_90,PLAYER_FULL_DIR,DIR_SWAPXY | DIR_MIRRORLEFTRIGHT);
  853. UpdateMenuInt(p,IF_OPTIONS_ROTATE_270,PLAYER_FULL_DIR,DIR_SWAPXY | DIR_MIRRORUPDOWN);
  854. UpdateMenuInt(p,IF_OPTIONS_ROTATE_180,PLAYER_FULL_DIR,DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT);
  856. UpdateMenuFrac(p,IF_OPTIONS_SPEED_10,PLAYER_PLAY_SPEED,1,10);
  857. UpdateMenuFrac(p,IF_OPTIONS_SPEED_25,PLAYER_PLAY_SPEED,1,4);
  858. UpdateMenuFrac(p,IF_OPTIONS_SPEED_50,PLAYER_PLAY_SPEED,1,2);
  859. UpdateMenuFrac(p,IF_OPTIONS_SPEED_80,PLAYER_PLAY_SPEED,8,10);
  860. UpdateMenuFrac(p,IF_OPTIONS_SPEED_90,PLAYER_PLAY_SPEED,9,10);
  861. UpdateMenuFrac(p,IF_OPTIONS_SPEED_100,PLAYER_PLAY_SPEED,1,1);
  862. UpdateMenuFrac(p,IF_OPTIONS_SPEED_110,PLAYER_PLAY_SPEED,11,10);
  863. UpdateMenuFrac(p,IF_OPTIONS_SPEED_120,PLAYER_PLAY_SPEED,12,10);
  864. UpdateMenuFrac(p,IF_OPTIONS_SPEED_150,PLAYER_PLAY_SPEED,3,2);
  865. UpdateMenuFrac(p,IF_OPTIONS_SPEED_200,PLAYER_PLAY_SPEED,2,1);
  866. UpdateMenuFrac(p,IF_OPTIONS_SPEED_BENCHMARK,PLAYER_PLAY_SPEED,0,1);
  868. UpdateMenuBool(p,IF_PLAY,PLAYER_PLAY);
  870. WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_DITHER,p->Color->Get(p->Color,COLOR_DITHER,&b,sizeof(b)) != ERR_NOT_SUPPORTED);
  871. WinMenuCheck(&p->Win,1,IF_OPTIONS_VIDEO_DITHER,b);
  873. UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO,PLAYER_STEREO,STEREO_NORMAL);
  874. UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_SWAPPED,PLAYER_STEREO,STEREO_SWAPPED);
  875. UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_JOINED,PLAYER_STEREO,STEREO_JOINED);
  876. UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_LEFT,PLAYER_STEREO,STEREO_LEFT);
  877. UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_RIGHT,PLAYER_STEREO,STEREO_RIGHT);
  879. UpdateMenuBool(p,IF_OPTIONS_FULLSCREEN,PLAYER_FULLSCREEN);
  880. UpdateMenuBool(p,IF_OPTIONS_REPEAT,PLAYER_REPEAT);
  881. UpdateMenuBool(p,IF_OPTIONS_SHUFFLE,PLAYER_SHUFFLE);
  883. p->Equalizer->Get(p->Equalizer,EQUALIZER_ENABLED,&b,sizeof(b));
  884. WinMenuCheck(&p->Win,1,IF_OPTIONS_EQUALIZER,b);
  886. p->Player->Get(p->Player,PLAYER_VIDEO_ACCEL,&Accel,sizeof(Accel));
  887. p->Player->Get(p->Player,PLAYER_VOUTPUTID,&Id,sizeof(Id));
  889. WinMenuCheck(&p->Win,1,IF_OPTIONS_VIDEO_TURNOFF,!Id);
  891. for (No=0,i=ARRAYBEGIN(p->VOutput,int);i!=ARRAYEND(p->VOutput,int);++i,++No)
  892. {
  893. WinMenuCheck(&p->Win,1,IF_VIDEO+No,*i==Id && !Accel);
  894. WinMenuCheck(&p->Win,1,IF_VIDEOACCEL+No,*i==Id && Accel);
  895. }
  897. p->Player->Get(p->Player,PLAYER_AOUTPUTID,&Id,sizeof(Id));
  898. WinMenuCheck(&p->Win,1,IF_OPTIONS_AUDIO_TURNOFF,!Id);
  900. for (No=0,i=ARRAYBEGIN(p->AOutput,int);i!=ARRAYEND(p->AOutput,int);++i,++No)
  901. WinMenuCheck(&p->Win,1,IF_AUDIO+No,*i==Id);
  903. Stereo = 1;
  904. p->Player->Get(p->Player,PLAYER_AOUTPUT,&AOutput,sizeof(AOutput));
  905. if (AOutput && AOutput->Get(AOutput,OUT_INPUT|PIN_FORMAT,&PacketFormat,sizeof(PacketFormat))==ERR_NONE && 
  906. PacketFormat.Type == PACKET_AUDIO && PacketFormat.Format.Audio.Channels<2)
  907. Stereo = 0;
  909. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO,Stereo);
  910. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_SWAPPED,Stereo);
  911. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_JOINED,Stereo);
  912. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_LEFT,Stereo);
  913. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_RIGHT,Stereo);
  914. }
  916. static void UpdatePosition(intface* p);
  918. static int Delta(intface* p,node* Node,int Param,int d,int Min,int Max)
  919. {
  920. int State;
  921. if (Node && Node->Get(Node,Param,&State,sizeof(State))==ERR_NONE)
  922. {
  923. State += d;
  924. if (State < Min)
  925. State = Min;
  926. if (State > Max)
  927. State = Max;
  929. Node->Set(Node,Param,&State,sizeof(State));
  931. if (Param == PLAYER_VOLUME)
  932. {
  933. if (State > Min) Toggle(p,PLAYER_MUTE,0);
  934. UpdateVolume(p);
  935. }
  936. }
  937. return State;
  938. }
  940. static bool_t IsCoverAtr(player *Player)
  941. {
  942. node* Format;
  943. int CoverArt;
  944. int VStream;
  945. return Player->Get(Player,PLAYER_FORMAT,&Format,sizeof(Format))==ERR_NONE && Format &&
  946. Format->Get(Format,FORMAT_COVERART,&CoverArt,sizeof(CoverArt))==ERR_NONE &&
  947. Player->Get(Player,PLAYER_VSTREAM,&VStream,sizeof(VStream))==ERR_NONE && VStream==CoverArt;
  948. }
  950. static bool_t ToggleFullScreen(intface* p,int Force,int CoverArtFullScreen)
  951. {
  952. bool_t State = 0;
  953. if (p->Player->Get(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State))==ERR_NONE)
  954. {
  955. node* VOutput;
  956. bool_t Primary;
  957. packetformat Format;
  959. if (State==Force)
  960. return State;
  961. State = !State;
  963. if (p->Player->Get(p->Player,PLAYER_VOUTPUT,&VOutput,sizeof(VOutput))!=ERR_NONE ||
  964. !VOutput ||
  965. VOutput->Get(VOutput,VOUT_PRIMARY,&Primary,sizeof(Primary))!=ERR_NONE || !Primary ||
  966. (!CoverArtFullScreen && IsCoverAtr(p->Player)) ||
  967. (!p->ForceFullScreen && VOutput->Get(VOutput,OUT_INPUT|PIN_FORMAT,&Format,sizeof(Format))!=ERR_NONE) ||
  968. (!p->ForceFullScreen && !Format.Format.Video.Width))
  969. State = 0;
  971. UpdatePosition(p); // before returning from fullscreen
  973. if (!State)
  974. {
  975. p->Player->Set(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State));
  976. p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
  977. RefreshButton(p,PLAYER_FULLSCREEN,&p->FullScreen,IF_OPTIONS_FULLSCREEN,-1,-1);
  978. }
  980. if (p->Skin[p->SkinNo].Valid) p->Skin[p->SkinNo].Hidden = State;
  981. if (p->WndTrack) ShowWindow(p->WndTrack,State ? SW_HIDE:SW_SHOWNA);
  982. if (p->WndTitle) ShowWindow(p->WndTitle,State ? SW_HIDE:SW_SHOWNA);
  983. WinSetFullScreen(&p->Win,State);
  984. if (p->Win.WndTB) UpdateWindow(p->Win.WndTB);
  985. ShowVol(p,!State); // called after WinSetFullScreen so TOPMOST is over taskbar
  987. if (State)
  988. {
  989. p->Player->Set(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State));
  990. p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
  991. RefreshButton(p,PLAYER_FULLSCREEN,&p->FullScreen,IF_OPTIONS_FULLSCREEN,-1,-1);
  992. }
  993. }
  994. return State;
  995. }
  997. static bool_t Toggle(intface* p,int Param,int Force)
  998. {
  999. bool_t State = 0;
  1000. if (p->Player->Get(p->Player,Param,&State,sizeof(State))==ERR_NONE)
  1001. {
  1002. assert(Param != PLAYER_FULLSCREEN);
  1003. if (State==Force)
  1004. return State;
  1005. State = !State;
  1006. p->Player->Set(p->Player,Param,&State,sizeof(State));
  1007. if (Param == PLAYER_PLAY)
  1008. RefreshButton(p,PLAYER_PLAY,&p->Play,IF_PLAY,0,1);
  1009. else
  1010. if (Param == PLAYER_FFWD)
  1011. RefreshButton(p,PLAYER_FFWD,&p->FFwd,IF_FASTFORWARD,4,1);
  1012. else
  1013. RefreshButton(p,Param,NULL,0,0,0);
  1014. }
  1015. return State;
  1016. }
  1018. static bool_t IsAutoRun(intface* p, const tchar_t* CmdLine)
  1019. {
  1020. while (IsSpace(*CmdLine))
  1021. ++CmdLine;
  1023. return tcsnicmp(CmdLine,T("-autorun"),8)==0;
  1024. }
  1026. static void EnumDir(const tchar_t* Path,const tchar_t* Exts,player* Player)
  1027. {
  1028. streamdir DirItem;
  1029. stream* Stream = GetStream(Path,1);
  1030. if (Stream)
  1031. {
  1032. int Result = Stream->EnumDir(Stream,Path,Exts,1,&DirItem);
  1034. while (Result == ERR_NONE)
  1035. {
  1036. tchar_t FullPath[MAXPATH];
  1037. AbsPath(FullPath,TSIZEOF(FullPath),DirItem.FileName,Path);
  1039. if (DirItem.Size < 0)
  1040. EnumDir(FullPath,Exts,Player);
  1041. else
  1042. if (DirItem.Type == FTYPE_AUDIO || DirItem.Type == FTYPE_VIDEO)
  1043. {
  1044. int n;
  1045. Player->Get(Player,PLAYER_LIST_COUNT,&n,sizeof(n));
  1046. Player->Set(Player,PLAYER_LIST_URL+n,FullPath,sizeof(FullPath));
  1047. }
  1049. Result = Stream->EnumDir(Stream,NULL,NULL,0,&DirItem);
  1050. }
  1052. NodeDelete((node*)Stream);
  1053. }
  1054. }
  1056. void ProcessCmdLine( intface* p, const tchar_t* CmdLine)
  1057. {
  1058. int n;
  1059. tchar_t URL[MAXPATH];
  1061. if (IsAutoRun(p,CmdLine))
  1062. {
  1063. // search for media files on SD card
  1064. tchar_t Base[MAXPATH];
  1065. int* i;
  1066. array List;
  1067. tchar_t* s;
  1068. int ExtsLen = 1024;
  1069. tchar_t* Exts = malloc(ExtsLen*sizeof(tchar_t));
  1070. if (!Exts)
  1071. return;
  1073. Exts[0]=0;
  1074. NodeEnumClass(&List,FORMAT_CLASS);
  1075. for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
  1076. {
  1077. const tchar_t* s = LangStr(*i,NODE_EXTS);
  1078. if (s[0])
  1079. {
  1080. if (Exts[0]) tcscat_s(Exts,ExtsLen,T(";"));
  1081. tcscat_s(Exts,ExtsLen,s);
  1082. }
  1083. }
  1084. ArrayClear(&List);
  1086. n = 0;
  1087. p->Player->Set(p->Player,PLAYER_LIST_COUNT,&n,sizeof(n));
  1089. GetModuleFileName(GetModuleHandle(NULL),Base,MAXPATH);
  1090. s = tcsrchr(Base,'\');
  1091. if (s) *s=0;
  1092. s = tcsrchr(Base,'\');
  1093. if (s) *s=0;
  1095. EnumDir(Base,Exts,p->Player);
  1096. free(Exts);
  1097. }
  1098. else
  1099. {
  1100. while (IsSpace(*CmdLine))
  1101. ++CmdLine;
  1103. if (*CmdLine == '"')
  1104. {
  1105. tchar_t* ch = tcschr(++CmdLine,'"');
  1106. if (ch) *ch=0;
  1107. }
  1109. tcscpy_s(URL,TSIZEOF(URL),CmdLine);
  1111. p->CmdLineMode = 1;
  1113. n = 1;
  1114. p->Player->Set(p->Player,PLAYER_LIST_COUNT,&n,sizeof(n));
  1116. PlayerAdd(p->Player,0,URL,NULL);
  1117. }
  1119. n = 0;
  1120. p->Player->Set(p->Player,PLAYER_LIST_CURRIDX,&n,sizeof(n));
  1122. if (!IsWindowEnabled(p->Win.Wnd))
  1123. Toggle(p,PLAYER_PLAY,0);
  1124. }
  1126. void SetTrackPos(intface* p,int x)
  1127. {
  1128. fraction Percent;
  1129. RECT r,rt;
  1130. int Adj;
  1132. if (p->TrackSetPos == x)
  1133. return;
  1135. p->TrackSetPos = x;
  1136. SendMessage(p->WndTrack,TBM_GETCHANNELRECT,0,(LONG)&r);
  1137. SendMessage(p->WndTrack,TBM_GETTHUMBRECT,0,(LONG)&rt);
  1138. Adj = (rt.right-rt.left) >> 1;
  1139. r.left += Adj;
  1140. r.right -= (rt.right-rt.left)-Adj;
  1142. if (x > 32768) x -= 65536;
  1143. if (r.right <= r.left) r.right = r.left+1;
  1144. if (x < r.left) x = r.left;
  1145. if (x > r.right) x = r.right;
  1146. x = Scale(TRACKMAX,x-r.left,r.right-r.left);
  1148. Percent.Num = x;
  1149. Percent.Den = TRACKMAX;
  1150. p->Player->Set(p->Player,PLAYER_PERCENT,&Percent,sizeof(Percent));
  1151. }
  1153. LRESULT CALLBACK TitleProc(HWND WndTitle, UINT Msg, WPARAM wParam, LPARAM lParam)
  1154. {
  1155. intface* p = (intface*) WinGetObject(WndTitle);
  1156. if (p)
  1157. {
  1158. PAINTSTRUCT Paint;
  1159. RECT r;
  1160. tchar_t Time[32];
  1162. switch (Msg)
  1163. {
  1164. case WM_ERASEBKGND:
  1165. GetClientRect(WndTitle,&r);
  1166. FillRect((HDC)wParam,&r,p->TitleBrush ? p->TitleBrush:GetSysColorBrush(COLOR_BTNFACE));
  1167. break;
  1169. case WM_SIZE:
  1170. p->UpdateScroll = 1;
  1171. break;
  1173. case WM_LBUTTONDOWN:
  1174. break;
  1176. case WM_MOUSEMOVE:
  1177. break;
  1179. case WM_LBUTTONUP:
  1180. break;
  1182. case WM_PAINT:
  1183. BeginPaint(WndTitle,&Paint);
  1185. SelectObject(Paint.hdc,p->TitleFont);
  1186. SetBkColor(Paint.hdc,p->TitleFace);
  1187. SetTextColor(Paint.hdc,p->TitleText);
  1188. #if !defined(TARGET_WINCE)
  1189. SetTextAlign(Paint.hdc,TA_LEFT);
  1190. #endif
  1192. if (!p->TitleTimeWidth)
  1193. {
  1194. SIZE Size;
  1195. tchar_t* s;
  1196. tchar_t Dur[32];
  1197. tick_t Duration;
  1198. tchar_t TitleName[256];
  1199. node* Format;
  1201. if (p->Player->Get(p->Player,PLAYER_FORMAT,&Format,sizeof(Format)) == ERR_NONE && !Format)
  1202. p->TitleTime = -1;
  1204. p->Player->Get(p->Player,PLAYER_TITLE,TitleName,sizeof(TitleName));
  1205. if (tcscmp(p->TitleName,TitleName)!=0)
  1206. {
  1207. tcscpy_s(p->TitleName,TSIZEOF(p->TitleName),TitleName);
  1208. GetTextExtentPoint(Paint.hdc,p->TitleName,tcslen(p->TitleName),&Size);
  1209. p->TitleNameWidth = Size.cx;
  1210. p->TitleNameOffset = 0;
  1211. p->ScrollMode = 0;
  1212. p->UpdateScroll = 1;
  1213. }
  1215. s = Dur;
  1216. Dur[0] = 0;
  1217. if (p->Player->Get(p->Player,PLAYER_DURATION,&Duration,sizeof(Duration)) == ERR_NONE && Duration>=0)
  1218. {
  1219. TickToString(Dur,TSIZEOF(Dur),Duration,0,0,1);
  1220. if (p->TitleTime<0)
  1221. p->TitleTime = 0;
  1222. }
  1223. else
  1224. s = T("0:00:00");
  1226. GetTextExtentPoint(Paint.hdc,s,tcslen(s),&Size);
  1227. p->TitleTimeWidth = Size.cx;
  1228. p->TitleDurWidth = 0;
  1229. p->TitleDur[0] = 0;
  1231. if (Dur[0])
  1232. {
  1233. stprintf_s(p->TitleDur,TSIZEOF(p->TitleDur),T("/%s"),Dur);
  1234. GetTextExtentPoint(Paint.hdc,p->TitleDur,tcslen(p->TitleDur),&Size);
  1235. p->TitleDurWidth = Size.cx;
  1236. p->UpdateScroll = 1;
  1237. }
  1238. }
  1240. if (p->TitleTime>=0)
  1241. TickToString(Time,TSIZEOF(Time),p->TitleTime,0,0,1);
  1242. else
  1243. Time[0] = 0;
  1245. r.top = p->TitleTop;
  1246. r.bottom = p->TitleHeight - p->TitleTop;
  1247. r.left = p->TitleBorder;
  1248. r.right = p->TitleWidth - p->TitleTimeWidth - p->TitleDurWidth - p->TitleBorder * 2;
  1249. p->TitleNameSize  = r.right - r.left;
  1251. if (p->UpdateScroll)
  1252. {
  1253. p->UpdateScroll = 0;
  1254. UpdateTitleScroll(p);
  1255. }
  1257. ExtTextOut(Paint.hdc,r.left-p->TitleNameOffset,r.top,ETO_CLIPPED,&r,p->TitleName,tcslen(p->TitleName),NULL);
  1260. r.left = r.right + p->TitleBorder;
  1261. r.right = r.left + p->TitleTimeWidth;
  1262. //SetBkColor(Paint.hdc,0xFFFFFF);
  1263. ExtTextOut(Paint.hdc,r.left,r.top,ETO_CLIPPED|ETO_OPAQUE,&r,Time,tcslen(Time),NULL);
  1264. //SetBkColor(Paint.hdc,0x00FF00);
  1266. if (p->TitleDurWidth)
  1267. {
  1268. r.left = r.right;
  1269. r.right = r.left + p->TitleDurWidth;
  1270. ExtTextOut(Paint.hdc,r.left,r.top,ETO_CLIPPED,&r,p->TitleDur,tcslen(p->TitleDur),NULL);
  1271. }
  1273. EndPaint(WndTitle,&Paint);
  1274. break;
  1275. }
  1276. }
  1277. return DefWindowProc(WndTitle,Msg,wParam,lParam);
  1278. }
  1280. static void SetKeyInSeek(intface* p)
  1281. {
  1282. bool_t First = !p->InSeek;
  1283. p->InSeek = 1;
  1284. p->Player->Set(p->Player,PLAYER_INSEEK,&p->InSeek,sizeof(p->InSeek));
  1285. SetTimer(p->Win.Wnd,TIMER_KEYINSEEK,First?KEYINSEEK_START:KEYINSEEK_REPEAT,NULL);
  1286. }
  1288. static void StopSeek(intface* p)
  1289. {
  1290. p->InSeek = 0;
  1291. p->Player->Set(p->Player,PLAYER_INSEEK,&p->InSeek,sizeof(p->InSeek));
  1292. KillTimer(p->Win.Wnd,TIMER_KEYINSEEK);
  1293. if (p->Capture)
  1294. {
  1295. ReleaseCapture();
  1296. p->Capture = 0;
  1297. KillTimer(p->Win.Wnd,TIMER_SLIDERINSEEK);
  1298. }
  1299. }
  1301. LRESULT CALLBACK TrackProc(HWND WndTrack, UINT Msg, WPARAM wParam, LPARAM lParam)
  1302. {
  1303. intface* p = (intface*) WinGetObject(WndTrack);
  1304. if (Msg == WM_LBUTTONDOWN)
  1305. {
  1306. p->InSeek = 1;
  1307. p->Capture = 1;
  1308. p->TrackSetPos = -1;
  1309. p->Player->Set(p->Player,PLAYER_INSEEK,&p->InSeek,sizeof(p->InSeek));
  1310. SetTrackPos(p,LOWORD(lParam));
  1311. SetCapture(WndTrack);
  1312. SetTimer(p->Win.Wnd,TIMER_SLIDERINSEEK,SLIDERINSEEK_CYCLE,NULL);
  1313. return 0;
  1314. }
  1315. if (Msg == WM_MOUSEMOVE)
  1316. {
  1317. if (p->InSeek && (wParam & MK_LBUTTON))
  1318. SetTrackPos(p,LOWORD(lParam));
  1319. return 0;
  1320. }
  1321. if (Msg == WM_LBUTTONUP)
  1322. {
  1323. if (p->InSeek)
  1324. {
  1325. SetTrackPos(p,LOWORD(lParam));
  1326. StopSeek(p);
  1327. }
  1328. return 0;
  1329. }
  1330. return CallWindowProc(p->DefTrackProc,WndTrack,Msg,wParam,lParam);
  1331. }
  1333. void UpdateVol(intface* p)
  1334. {
  1335. if (p->Vol >= 0)
  1336. {
  1337. SendMessage(p->WndVol,TBM_SETPOS,1,p->Vol);
  1338. p->Player->Set(p->Player,PLAYER_VOLUME,&p->Vol,sizeof(p->Vol));
  1339. p->Vol = -1;
  1341. if (p->Skin[p->SkinNo].Valid)
  1342. SkinUpdate(&p->Skin[p->SkinNo],p->Player,p->Win.Wnd,&p->SkinArea);
  1343. }
  1344. }
  1346. void SetVolPos(intface* p,int x)
  1347. {
  1348. RECT r;
  1349. int Adj;
  1350. SendMessage(p->WndVol,TBM_GETCHANNELRECT,0,(LONG)&r);
  1351. Adj = WinUnitToPixelX(&p->Win,VOLTHUMB)/4;
  1352. r.left += Adj;
  1353. r.right -= Adj;
  1355. if (x > 32768) x -= 65536;
  1356. if (r.right <= r.left) r.right = r.left+1;
  1357. if (x < r.left) x = r.left;
  1358. if (x > r.right) x = r.right;
  1360. p->Vol = (100*(x-r.left))/(r.right-r.left);
  1361. }
  1363. LRESULT CALLBACK VolBackProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  1364. {
  1365. //DEBUG_MSG1(DEBUG_WIN,T("MSG %04x"),Msg);
  1367. switch (Msg)
  1368. {
  1369. #if defined(TARGET_WINCE)
  1370. case WM_CTLCOLORSTATIC:
  1371. return (LRESULT) GetSysColorBrush(COLOR_BTNFACE);
  1372. #endif
  1373. }
  1374. return DefWindowProc(Wnd,Msg,wParam,lParam);
  1375. }
  1377. LRESULT CALLBACK VolProc(HWND WndVol, UINT Msg, WPARAM wParam, LPARAM lParam)
  1378. {
  1379. intface* p = (intface*) WinGetObject(WndVol);
  1381. switch (Msg)
  1382. {
  1383. case WM_MOUSEMOVE:
  1384. if ((wParam & MK_LBUTTON)==0)
  1385. break;
  1387. case WM_LBUTTONDOWN:
  1388. case WM_LBUTTONDBLCLK:
  1390. SetVolPos(p,LOWORD(lParam));
  1391. if (!p->InVol)
  1392. {
  1393. p->InVol = 1;
  1394. SetForegroundWindow(p->Win.Wnd);
  1395. SetCapture(WndVol);
  1396. SetTimer(p->Win.Wnd,TIMER_SLIDERINVOL,SLIDERINVOL_CYCLE,NULL);
  1397. UpdateVol(p);
  1398. }
  1399. return 0;
  1401. case WM_LBUTTONUP:
  1402. if (!p->InVol)
  1403. SetForegroundWindow(p->Win.Wnd);
  1404. else
  1405. {
  1406. p->InVol = 0;
  1407. ReleaseCapture();
  1408. KillTimer(p->Win.Wnd,TIMER_SLIDERINVOL);
  1409. }
  1410. SetVolPos(p,LOWORD(lParam));
  1411. UpdateVol(p);
  1412. return 0;
  1413. }
  1415. return CallWindowProc(p->DefVolProc,WndVol,Msg,wParam,lParam);
  1416. }
  1418. void CreateDeviceMenu(intface* p)
  1419. {
  1420. int No;
  1421. int *i;
  1423. NodeEnumClass(&p->VOutput,VOUT_CLASS);
  1424. NodeEnumClass(&p->AOutput,AOUT_CLASS);
  1426. for (No=0,i=ARRAYBEGIN(p->VOutput,int);i!=ARRAYEND(p->VOutput,int);++i,++No)
  1427. {
  1428. if (VOutIDCT(*i))
  1429. {
  1430. tchar_t s[256];
  1431. stprintf_s(s,TSIZEOF(s),LangStr(INTERFACE_ID,IF_OPTIONS_VIDEO_ACCEL),LangStr(*i,NODE_NAME));
  1432. WinMenuInsert(&p->Win,1,IF_OPTIONS_VIDEO_TURNOFF,IF_VIDEOACCEL+No,s);
  1433. }
  1434. WinMenuInsert(&p->Win,1,IF_OPTIONS_VIDEO_TURNOFF,IF_VIDEO+No,LangStr(*i,NODE_NAME));
  1435. }
  1437. for (No=0,i=ARRAYBEGIN(p->AOutput,int);i!=ARRAYEND(p->AOutput,int);++i,++No)
  1438. WinMenuInsert(&p->Win,1,IF_OPTIONS_AUDIO_TURNOFF,IF_AUDIO+No,LangStr(*i,NODE_NAME));
  1439. }
  1441. static menudef MenuDef[] =
  1442. {
  1443. { 0,INTERFACE_ID, IF_FILE },
  1444. { 1,INTERFACE_ID, IF_FILE_OPENFILE },
  1445. { 1,INTERFACE_ID, IF_FILE_CORETHEQUE },
  1446. { 1,INTERFACE_ID, IF_FILE_PLAYLIST },
  1447. { 1,-1,-1 },
  1448. { 1,INTERFACE_ID, IF_PLAY },
  1449. { 1,INTERFACE_ID, IF_NEXT },
  1450. { 1,INTERFACE_ID, IF_PREV },
  1451. { 1,-1,-1 },
  1452. { 1,INTERFACE_ID, IF_FILE_CHAPTERS },
  1453. { 2,INTERFACE_ID, IF_FILE_CHAPTERS_NONE },
  1454. { 1,INTERFACE_ID, IF_FILE_MEDIAINFO },
  1455. { 1,INTERFACE_ID, IF_FILE_BENCHMARK },
  1456. { 1,INTERFACE_ID, IF_FILE_ABOUT },
  1457. { 1,-1,-1 },
  1458. { 1,INTERFACE_ID, IF_FILE_EXIT },
  1459. { 0,INTERFACE_ID, IF_OPTIONS },
  1460. { 1,INTERFACE_ID, IF_OPTIONS_SPEED },
  1461. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_10 },
  1462. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_25 },
  1463. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_50 }, 
  1464. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_80 },
  1465. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_90 },
  1466. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_100 },
  1467. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_110 },
  1468. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_120 },
  1469. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_150 },
  1470. { 2,INTERFACE_ID, IF_OPTIONS_SPEED_200 },
  1471. { 1,INTERFACE_ID, IF_OPTIONS_VIEW, MENU_SMALL },
  1472. { 2,INTERFACE_ID, IF_OPTIONS_ZOOM },
  1473. #if !defined(SH3)
  1474. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_SCREEN },
  1475. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FILL_SCREEN },
  1476. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_STRETCH_SCREEN },
  1477. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_110 },
  1478. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_120 },
  1479. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_130 },
  1480. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_50 }, 
  1481. #endif
  1482. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_100 },
  1483. #if !defined(SH3)
  1484. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_150 },
  1485. #endif
  1486. { 3,INTERFACE_ID, IF_OPTIONS_ZOOM_200 },
  1487. #if !defined(SH3)
  1488. { 2,INTERFACE_ID, IF_OPTIONS_ASPECT },
  1489. { 3,INTERFACE_ID, IF_OPTIONS_ASPECT_AUTO },
  1490. { 3,INTERFACE_ID, IF_OPTIONS_ASPECT_SQUARE },
  1491. { 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_SCREEN },
  1492. { 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_NTSC },
  1493. { 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_PAL },
  1494. { 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_SCREEN },
  1495. { 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_NTSC },
  1496. { 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_PAL },
  1497. #endif
  1498. { 2,INTERFACE_ID, IF_OPTIONS_ORIENTATION },
  1499. { 3,INTERFACE_ID, IF_OPTIONS_ORIENTATION_FULLSCREEN },
  1500. { 3,INTERFACE_ID, IF_OPTIONS_ROTATE_GUI },
  1501. { 3,INTERFACE_ID, IF_OPTIONS_ROTATE_0 },
  1502. { 3,INTERFACE_ID, IF_OPTIONS_ROTATE_90 },
  1503. { 3,INTERFACE_ID, IF_OPTIONS_ROTATE_270 },
  1504. { 3,INTERFACE_ID, IF_OPTIONS_ROTATE_180 },
  1505. { 2,INTERFACE_ID, IF_OPTIONS_VIEW, MENU_NOTSMALL },
  1506. { 3,INTERFACE_ID, IF_OPTIONS_VIEW_TITLEBAR },
  1507. { 3,INTERFACE_ID, IF_OPTIONS_VIEW_TRACKBAR }, 
  1508. { 3,INTERFACE_ID, IF_OPTIONS_VIEW_TASKBAR }, 
  1509. { 1,INTERFACE_ID, IF_OPTIONS_VIDEO },
  1510. #if !defined(SH3) && !defined(MIPS)
  1511. { 2,INTERFACE_ID, IF_OPTIONS_VIDEO_ZOOM_SMOOTH50 },
  1512. { 2,INTERFACE_ID, IF_OPTIONS_VIDEO_ZOOM_SMOOTHALWAYS },
  1513. { 2,INTERFACE_ID, IF_OPTIONS_VIDEO_DITHER },
  1514. #endif
  1515. { 2,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY },
  1516. { 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_LOWEST },
  1517. { 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_LOW },
  1518. { 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_NORMAL }, 
  1519. { 2,-1,-1 },
  1520. { 2,INTERFACE_ID, IF_OPTIONS_VIDEO_DEVICE, MENU_SMALL|MENU_GRAYED },
  1521. { 3,INTERFACE_ID, IF_OPTIONS_VIDEO_TURNOFF },
  1522. { 2,-1,-1 },
  1523. { 2,INTERFACE_ID, IF_OPTIONS_VIDEO_STREAM, MENU_SMALL|MENU_GRAYED },
  1524. { 3,INTERFACE_ID, IF_OPTIONS_VIDEO_STREAM_NONE },
  1526. { 1,INTERFACE_ID, IF_OPTIONS_AUDIO },
  1527. { 2,INTERFACE_ID, IF_OPTIONS_AUDIO_CHANNELS, MENU_SMALL },
  1528. { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO },
  1529. { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_SWAPPED },
  1530. { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_JOINED },
  1531. { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_LEFT },
  1532. { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_RIGHT },
  1533. // { 2,-1,-1 },
  1534. // { 2,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY },
  1535. // { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_LOW },
  1536. // { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_MEDIUM },
  1537. // { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_HIGH }, 
  1538. { 2,-1,-1 },
  1539. { 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP_DEC },
  1540. { 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP },
  1541. { 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP_INC }, 
  1542. { 2,-1,-1 },
  1543. { 2,INTERFACE_ID, IF_OPTIONS_AUDIO_DEVICE, MENU_SMALL|MENU_GRAYED },
  1544. { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_TURNOFF },
  1545. { 2,-1,-1 },
  1546. { 2,INTERFACE_ID, IF_OPTIONS_AUDIO_STREAM, MENU_SMALL|MENU_GRAYED },
  1547. { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STREAM_NONE },
  1549. //!SUBTITLE { 1,INTERFACE_ID, IF_OPTIONS_SUBTITLE_STREAM, MENU_GRAYED },
  1550. //!SUBTITLE { 2,INTERFACE_ID, IF_OPTIONS_SUBTITLE_STREAM_NONE },
  1552. { 1,-1,-1 },
  1553. { 1,INTERFACE_ID, IF_OPTIONS_REPEAT },
  1554. { 1,INTERFACE_ID, IF_OPTIONS_SHUFFLE },
  1555. { 1,INTERFACE_ID, IF_OPTIONS_EQUALIZER },
  1556. { 1,INTERFACE_ID, IF_OPTIONS_FULLSCREEN },
  1557. #if defined(CONFIG_SKIN)
  1558. { 1,INTERFACE_ID, IF_OPTIONS_SKIN },
  1559. #endif
  1560. { 1,-1,-1 },
  1561. { 1,INTERFACE_ID, IF_OPTIONS_SETTINGS },
  1563. MENUDEF_END
  1564. };
  1566. void CreateButtons(intface* p)
  1567. {
  1568. if (QueryPlatform(PLATFORM_TYPENO) != TYPE_SMARTPHONE)
  1569. {
  1570. bool_t FullScreenButton = 1;
  1571. RECT r,rv;
  1573. WinBitmap(&p->Win,IDB_TOOLBAR16,IDB_TOOLBAR32,10);
  1574. WinAddButton(&p->Win,-1,-1,NULL,0);
  1575. WinAddButton(&p->Win,IF_PLAY,0,NULL,1);
  1576. WinAddButton(&p->Win,IF_FASTFORWARD,4,NULL,1);
  1577. WinAddButton(&p->Win,IF_STOP,5,NULL,0);
  1578. WinAddButton(&p->Win,-1,-1,NULL,0);
  1579. WinAddButton(&p->Win,IF_OPTIONS_FULLSCREEN,6,NULL,1);
  1580. WinAddButton(&p->Win,IF_OPTIONS_MUTE,7,NULL,1);
  1582. GetClientRect(p->Win.WndTB,&r);
  1583. SendMessage(p->Win.WndTB,TB_GETRECT,IF_OPTIONS_MUTE,(LPARAM)&rv);
  1584. if (r.right-rv.right < VOLMINWIDTH)
  1585. {
  1586. WinDeleteButton(&p->Win,IF_FASTFORWARD);
  1587. SendMessage(p->Win.WndTB,TB_GETRECT,IF_OPTIONS_MUTE,(LPARAM)&rv);
  1588. if (r.right-rv.right < VOLMINWIDTH)
  1589. {
  1590. WinDeleteButton(&p->Win,IF_OPTIONS_FULLSCREEN);
  1591. FullScreenButton = 0;
  1592. }
  1593. }
  1595. WinMenuDelete(&p->Win,0,IF_PLAY);
  1596. if (FullScreenButton)
  1597. WinMenuDelete(&p->Win,1,IF_OPTIONS_FULLSCREEN);
  1598. WinMenuDelete(&p->Win,1,IF_OPTIONS_MUTE);
  1599. }
  1600. }
  1602. static void UpdateVolume(intface* p)
  1603. {
  1604. int x;
  1606. if (p->Skin[p->SkinNo].Valid)
  1607. SkinUpdate(&p->Skin[p->SkinNo],p->Player,p->Win.Wnd,&p->SkinArea);
  1609. if (p->WndVol)
  1610. {
  1611. bool_t Enable = p->Player->Get(p->Player,PLAYER_VOLUME,&x,sizeof(x))==ERR_NONE;
  1612. EnableWindow(p->WndVol,Enable);
  1613. SetTrackThumb(p->WndVol,Enable);
  1614. if (Enable)
  1615. SendMessage(p->WndVol,TBM_SETPOS,1,x);
  1616. }
  1617. RefreshButton(p,PLAYER_MUTE,&p->Mute,IF_OPTIONS_MUTE,7,8);
  1618. }
  1620. static void CreateVolumeTrack(intface* p)
  1621. {
  1622. if (QueryPlatform(PLATFORM_TYPENO) != TYPE_SMARTPHONE)
  1623. {
  1624. WNDCLASS WinClass;
  1626. memset(&WinClass,0,sizeof(WinClass));
  1627. WinClass.style = CS_HREDRAW | CS_VREDRAW;
  1628. WinClass.lpfnWndProc = (WNDPROC) VolBackProc;
  1629. WinClass.cbClsExtra = 0;
  1630. WinClass.cbWndExtra = 0;
  1631. WinClass.hInstance = p->Win.Module;
  1632. WinClass.hCursor = WinCursorArrow();
  1633. WinClass.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
  1634. WinClass.lpszMenuName = 0;
  1635. WinClass.lpszClassName = T("VolumeBack");
  1636. RegisterClass(&WinClass);
  1638. p->WndVolBack = CreateWindowEx( 
  1639. WS_EX_TOPMOST,                    
  1640. WinClass.lpszClassName,       
  1641. Context()->ProgramName,   
  1642. (p->Win.ToolBarHeight ? WS_CHILD:WS_POPUP) | WS_VISIBLE | 
  1643. TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH, 
  1644. 200, 0,    
  1645. 40, 20,   
  1646. (p->Win.ToolBarHeight ? p->Win.WndTB:p->Win.Wnd),
  1647. NULL,
  1648. p->Win.Module,                     
  1649. NULL                      
  1650. ); 
  1652. p->WndVol = CreateWindowEx( 
  1653. 0,                    
  1654. TRACKBAR_CLASS,       
  1655. NULL,   
  1656. WS_CHILD | WS_VISIBLE | 
  1657. TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH, 
  1658. 0, 0,    
  1659. 40, 20,   
  1660. p->WndVolBack,
  1661. NULL,
  1662. p->Win.Module,                     
  1663. NULL                      
  1664. ); 
  1666. p->DefVolProc = (WNDPROC)GetWindowLong(p->WndVol,GWL_WNDPROC);
  1667. SetWindowLong(p->WndVol,GWL_WNDPROC,(LONG)VolProc);
  1668. WinSetObject(p->WndVol,&p->Win);
  1670. SendMessage(p->WndVol, TBM_SETRANGE, FALSE,MAKELONG(0,100));
  1671. SendMessage(p->WndVol, TBM_SETPAGESIZE,0,10);
  1672. SendMessage(p->WndVol, TBM_SETLINESIZE,0,10);
  1674. ResizeVolume(p);
  1675. UpdateVolume(p);
  1676. }
  1677. }
  1679. static int UpdateTitleBar(intface* p,bool_t DoResize)
  1680. {
  1681. if (p->TitleBar && !p->WndTitle && p->Win.Wnd)
  1682. {
  1683. WNDCLASS WinClass;
  1685. memset(&WinClass,0,sizeof(WinClass));
  1686. WinClass.style = CS_HREDRAW | CS_VREDRAW;
  1687. WinClass.lpfnWndProc = (WNDPROC) TitleProc;
  1688. WinClass.cbClsExtra = 0;
  1689. WinClass.cbWndExtra = 0;
  1690. WinClass.hInstance = p->Win.Module;
  1691. WinClass.hCursor = WinCursorArrow();
  1692. WinClass.hbrBackground = NULL;
  1693. WinClass.lpszMenuName = 0;
  1694. WinClass.lpszClassName = T("TitleBar");
  1695. RegisterClass(&WinClass);
  1697. p->WndTitle = CreateWindowEx( 
  1698. 0,                    
  1699. WinClass.lpszClassName,       
  1700. T("Time"),   
  1701. WS_CHILD | WS_VISIBLE, 
  1702. 0, 0,    
  1703. 200, 20,   
  1704. p->Win.Wnd,
  1705. NULL,
  1706. p->Win.Module,                     
  1707. NULL                      
  1708. ); 
  1710. WinSetObject(p->WndTitle,&p->Win);
  1711. p->ClientRect.right = -1;
  1712. if (DoResize) Resize(p);
  1713. }
  1714. if (!p->TitleBar && p->WndTitle)
  1715. {
  1716. DestroyWindow(p->WndTitle);
  1717. p->WndTitle = NULL;
  1718. p->ClientRect.right = -1;
  1719. if (DoResize) Resize(p);
  1720. }
  1721. return ERR_NONE;
  1722. }
  1724. static NOINLINE void UpdateTrackPos(intface* p)
  1725. {
  1726. if (p->Skin[p->SkinNo].Valid)
  1727. SkinUpdate(p->Skin+p->SkinNo,p->Player,p->Win.Wnd,&p->SkinArea);
  1729. if (p->WndTrack)
  1730. {
  1731. fraction f;
  1732. int TrackPos;
  1733. if (p->Player->Get(p->Player,PLAYER_PERCENT,&f,sizeof(fraction)) == ERR_NONE)
  1734. TrackPos = Scale(TRACKMAX,f.Num,f.Den);
  1735. else
  1736. TrackPos = -1;
  1738. if (TrackPos != p->TrackPos)
  1739. {
  1740. if (TrackPos == -1)
  1741. {
  1742. SetTrackThumb(p->WndTrack,0);
  1743. EnableWindow(p->WndTrack,0);
  1744. }
  1745. if (p->TrackPos == -1)
  1746. {
  1747. SetTrackThumb(p->WndTrack,1);
  1748. EnableWindow(p->WndTrack,1);
  1749. }
  1750. p->TrackPos = TrackPos;
  1751. SendMessage(p->WndTrack,TBM_SETPOS,1,TrackPos);
  1752. }
  1753. }
  1754. }
  1756. static int UpdateTrackBar(intface* p,bool_t DoResize)
  1757. {
  1758. bool_t TrackBar = p->TrackBar && !p->Skin[p->SkinNo].Valid;
  1759. if (TrackBar && !p->WndTrack && p->Win.Wnd)
  1760. {
  1761. p->WndTrack = CreateWindowEx( 
  1762. 0,                    
  1763. TRACKBAR_CLASS,       
  1764. T("Time"),   
  1765. WS_CHILD | WS_VISIBLE | 
  1766. TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH, 
  1767. 0, 0,    
  1768. 200, 20,   
  1769. p->Win.Wnd,
  1770. NULL,
  1771. p->Win.Module,                     
  1772. NULL                      
  1773. ); 
  1775. p->DefTrackProc = (WNDPROC)GetWindowLong(p->WndTrack,GWL_WNDPROC);
  1776. SetWindowLong(p->WndTrack,GWL_WNDPROC,(LONG)TrackProc);
  1777. WinSetObject(p->WndTrack,&p->Win);
  1779. SendMessage(p->WndTrack, TBM_SETRANGE, FALSE,MAKELONG(0,TRACKMAX));
  1780. SendMessage(p->WndTrack, TBM_SETPAGESIZE,0,TRACKMAX/20);
  1781. SendMessage(p->WndTrack, TBM_SETLINESIZE,0,TRACKMAX/100);
  1783. p->TrackPos = 0;
  1784. UpdateTrackPos(p);
  1785. p->ClientRect.right = -1;
  1786. if (DoResize) Resize(p);
  1787. }
  1788. if (!TrackBar && p->WndTrack)
  1789. {
  1790. DestroyWindow(p->WndTrack);
  1791. p->WndTrack = NULL;
  1792. p->ClientRect.right = -1;
  1793. if (DoResize) Resize(p);
  1794. }
  1795. p->TrackThumb = -1;
  1796. return ERR_NONE;
  1797. }
  1799. static void BeforeExit(intface* p)
  1800. {
  1801. if (Context()->Wnd)
  1802. {
  1803. NodeRegSaveValue(0,REG_INITING,NULL,0,TYPE_INT);
  1804. NodeRegSave((node*)p);
  1805. UpdateHotKey(p,0,1);
  1806. if (p->WndVolBack)
  1807. {
  1808. DestroyWindow(p->WndVolBack);
  1809. p->WndVolBack = NULL;
  1810. }
  1811. Context_Wnd(NULL);
  1812. }
  1813. }
  1815. static void ShowError2(intface* p, const tchar_t* s)
  1816. {
  1817. win* Win;
  1819. if (p->Player)
  1820. {
  1821. p->Player->Set(p->Player,PLAYER_STOP,NULL,1); // full stop (no filling buffers)
  1822. ToggleFullScreen(p,0,0); //ATI tweaks would have problem
  1823. }
  1824. UpdateClipping(p,1,1); // force clipping mode
  1826. // find application foreground window
  1827. Win = &p->Win;
  1828. while (Win->Child) Win = Win->Child;
  1830. MessageBox(Win->Wnd,s,LangStr(PLATFORM_ID,PLATFORM_ERROR),MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
  1831. }
  1833. static void ToggleStream(intface* p,int Id,int Type,bool_t UseNone)
  1834. {
  1835. packetformat Format;
  1836. int No,Current,First=-1;
  1838. p->Player->Get(p->Player,Id,&Current,sizeof(int));
  1840. if (Current == MAXSTREAM)
  1841. Current = -1;
  1843. for (No=0;PlayerGetStream(p->Player,No,&Format,NULL,0,NULL);++No)
  1844. if (Format.Type == Type)
  1845. {
  1846. if (First < 0)
  1847. First = No;
  1848. if (Current == No)
  1849. Current = -1;
  1850. else
  1851. if (Current == -1)
  1852. Current = No;
  1853. }
  1855. if (Current == -1)
  1856. Current = UseNone ? MAXSTREAM:First;
  1858. if (Current >= 0)
  1859. {
  1860. p->Player->Set(p->Player,Id,&Current,sizeof(int));
  1861. p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
  1862. }
  1863. }
  1865. static int UpdateTaskBar(intface* p)
  1866. {
  1867. if (!p->Win.FullScreen)
  1868. DIASet(p->TaskBar?DIA_TASKBAR:0,DIA_TASKBAR);
  1869. return ERR_NONE;
  1870. }
  1872. static int UpdateSkin(intface* p,bool_t Others);
  1873. static int UpdateSkinFile(intface* p)
  1874. {
  1875. if (p->Player)
  1876. {
  1877. SkinFree(p->Skin,NULL);
  1878. SkinLoad(p->Skin,p->Win.Wnd,p->SkinPath);
  1879. UpdateSkin(p,1);
  1880. }
  1881. return ERR_NONE;
  1882. }
  1884. static int Command(intface* p,int Cmd)
  1885. {
  1886. node* Node;
  1887. bool_t b;
  1888. int i;
  1889. fraction f;
  1890. tick_t t;
  1891. int Zero = 0;
  1893. switch (Cmd)
  1894. {
  1895. case IF_SKIN0:
  1896. p->SkinNo = 0;
  1897. UpdateSkin(p,1);
  1898. break;
  1899. case IF_SKIN1:
  1900. p->SkinNo = 1;
  1901. UpdateSkin(p,1);
  1902. break;
  1903. case IF_OPTIONS_VOLUME_UP:
  1904. Delta(p,(node*)p->Player,PLAYER_VOLUME,10,0,100);
  1905. break;
  1906. case IF_OPTIONS_VOLUME_DOWN:
  1907. Delta(p,(node*)p->Player,PLAYER_VOLUME,-10,0,100);
  1908. break;
  1909. case IF_OPTIONS_VOLUME_UP_FINE:
  1910. Delta(p,(node*)p->Player,PLAYER_VOLUME,3,0,100);
  1911. break;
  1912. case IF_OPTIONS_VOLUME_DOWN_FINE:
  1913. Delta(p,(node*)p->Player,PLAYER_VOLUME,-3,0,100);
  1914. break;
  1915. case IF_OPTIONS_BRIGHTNESS_UP:
  1916. Delta(p,p->Color,COLOR_BRIGHTNESS,6,-128,127);
  1917. break;
  1918. case IF_OPTIONS_BRIGHTNESS_DOWN:
  1919. Delta(p,p->Color,COLOR_BRIGHTNESS,-6,-128,127);
  1920. break;
  1921. case IF_OPTIONS_CONTRAST_UP:
  1922. Delta(p,p->Color,COLOR_CONTRAST,6,-128,127);
  1923. break;
  1924. case IF_OPTIONS_CONTRAST_DOWN:
  1925. Delta(p,p->Color,COLOR_CONTRAST,-6,-128,127);
  1926. break;
  1927. case IF_OPTIONS_SATURATION_UP:
  1928. Delta(p,p->Color,COLOR_SATURATION,6,-128,127);
  1929. break;
  1930. case IF_OPTIONS_SATURATION_DOWN:
  1931. Delta(p,p->Color,COLOR_SATURATION,-6,-128,127);
  1932. break;
  1934. case IF_OPTIONS_SCREEN:
  1935. SetDisplayPower(!GetDisplayPower(),1);
  1936. break;
  1938. case IF_OPTIONS_AUDIO_STEREO_TOGGLE:
  1939. p->Player->Get(p->Player,PLAYER_STEREO,&i,sizeof(i));
  1940. i = i==STEREO_LEFT?STEREO_RIGHT:STEREO_LEFT;
  1941. p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
  1942. break;
  1944. case IF_OPTIONS_TOGGLE_VIDEO:
  1945. ToggleStream(p,PLAYER_VSTREAM,PACKET_VIDEO,0);
  1946. break;
  1948. case IF_OPTIONS_TOGGLE_SUBTITLE:
  1949. ToggleStream(p,PLAYER_SUBSTREAM,PACKET_SUBTITLE,1);
  1950. break;
  1952. case IF_OPTIONS_TOGGLE_AUDIO:
  1953. ToggleStream(p,PLAYER_ASTREAM,PACKET_AUDIO,0);
  1954. break;
  1956. case IF_OPTIONS_ZOOM_IN:
  1957. p->Player->Get(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  1958. if (f.Num <= 0) f.Num = f.Den = 1;
  1959. if (f.Den != 100)
  1960. {
  1961. f.Num = f.Num * 100 / f.Den;
  1962. f.Den = 100;
  1963. }
  1964. f.Num+=5;
  1965. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  1966. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  1967. break;
  1969. case IF_OPTIONS_ZOOM_OUT:
  1970. p->Player->Get(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  1971. if (f.Num <= 0) f.Num = f.Den = 1;
  1972. if (f.Den != 100)
  1973. {
  1974. f.Num = f.Num * 100 / f.Den;
  1975. f.Den = 100;
  1976. }
  1977. if (f.Num>5) f.Num-=5;
  1978. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  1979. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  1980. break;
  1982. case IF_OPTIONS_ZOOM_FIT:
  1983. p->Player->Get(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  1984. f.Num = f.Num == -1 ? -2:-1;
  1985. f.Den = 1;
  1986. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  1987. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  1988. break;
  1990. case IF_PLAY_FULLSCREEN:
  1991. if (p->Player->Get(p->Player,PLAYER_STREAMING,&b,sizeof(b))==ERR_NONE && b)
  1992. ToggleFullScreen(p,-1,0);
  1993. else
  1994. if (!(p->Player->Get(p->Player,PLAYER_FULLSCREEN,&b,sizeof(b))==ERR_NONE && b) &&
  1995. !(p->Player->Get(p->Player,PLAYER_PLAY,&b,sizeof(b))==ERR_NONE && b))
  1996. {
  1997. ToggleFullScreen(p,1,0);
  1998. Toggle(p,PLAYER_PLAY,1);
  1999. }
  2000. else
  2001. {
  2002. Toggle(p,PLAYER_PLAY,0);
  2003. ToggleFullScreen(p,0,0);
  2004. }
  2005. break;
  2007. case IF_MOVE_FFWD:
  2008. SetKeyInSeek(p);
  2009. p->Player->Set(p->Player,PLAYER_MOVEFFWD,NULL,0);
  2010. break;
  2012. case IF_MOVE_BACK:
  2013. SetKeyInSeek(p);
  2014. p->Player->Set(p->Player,PLAYER_MOVEBACK,NULL,0);
  2015. break;
  2017. case IF_NEXT2:
  2018. case IF_NEXT:
  2019. p->Player->Set(p->Player,PLAYER_NEXT,NULL,0);
  2020. break;
  2022. case IF_PREV_SMART:
  2023. case IF_PREV_SMART2:
  2024. p->Player->Set(p->Player,PLAYER_PREV,NULL,1);
  2025. break;
  2027. case IF_PREV:
  2028. p->Player->Set(p->Player,PLAYER_PREV,NULL,0);
  2029. break;
  2031. case IF_PLAYPAUSE:
  2032. case IF_PLAY:
  2033. p->Play = -1; // force button refresh
  2034. Toggle(p,PLAYER_PLAY,-1);
  2035. break;
  2037. case IF_FASTFORWARD:
  2038. p->FFwd = -1; // force button refresh
  2039. Toggle(p,PLAYER_FFWD,-1);
  2040. break;
  2042. case IF_FILE_BENCHMARK:
  2043. if (!ToggleFullScreen(p,1,0))
  2044. {
  2045. if (p->WndTrack)
  2046. SetTrackThumb(p->WndTrack,0);
  2047. WaitBegin();
  2048. }
  2049. UpdateWindow(p->Win.Wnd);
  2050. t = 0;
  2051. p->Player->Set(p->Player,PLAYER_BENCHMARK,&t,sizeof(t));
  2052. p->Bench = 1;
  2053. break;
  2055. case IF_STOP:
  2056. p->Player->Set(p->Player,PLAYER_STOP,NULL,0);
  2057. f.Num = 0;
  2058. f.Den = 1;
  2059. p->Player->Set(p->Player,PLAYER_PERCENT,&f,sizeof(f));
  2060. break;
  2062. case IF_FILE_OPENFILE:
  2063. p->CmdLineMode = 0;
  2065. Node = NodeCreate(OPENFILE_ID);
  2066. i = 0;
  2067. Node->Set(Node,OPENFILE_FLAGS,&i,sizeof(i));
  2068. i = MEDIA_CLASS;
  2069. Node->Set(Node,OPENFILE_CLASS,&i,sizeof(i));
  2071. UpdateHotKey(p,0,1);
  2072. i = ((win*)Node)->Popup((win*)Node,&p->Win);
  2073. NodeDelete(Node);
  2074. if (i==2)
  2075. {
  2076. UpdateWindow(p->Win.Wnd);
  2077. i=0;
  2078. p->Player->Set(p->Player,PLAYER_LIST_CURRIDX,&i,sizeof(i));
  2079. }
  2080. break;
  2082. case IF_FILE_CORETHEQUE:
  2083. WinPopupClass(CORETHEQUE_UI_ID,&p->Win);
  2085. p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0); 
  2086. break;
  2088. case IF_FILE_ABOUT:
  2089. WinPopupClass(ABOUT_ID,&p->Win);
  2090. break;
  2092. case IF_OPTIONS_SETTINGS:
  2093. UpdateHotKey(p,0,1);
  2094. p->AllKeysWarning = 1;
  2095. WinPopupClass(SETTINGS_ID,&p->Win);
  2096. p->AllKeysWarning = 0;
  2098. p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0); 
  2099. break;
  2101. case IF_FILE_PLAYLIST:
  2102. WinPopupClass(PLAYLIST_ID,&p->Win);
  2103. break;
  2105. case IF_FILE_MEDIAINFO:
  2106. WinPopupClass(MEDIAINFO_ID,&p->Win);
  2107. break;
  2109. case IF_FILE_EXIT:
  2110. // just to be sure to stop overlay update (WM_DESTROY comes after window is hidden)
  2111. BeforeExit(p);
  2112. DestroyWindow(p->Win.Wnd);
  2113. break;
  2115. case IF_OPTIONS_REPEAT:
  2116. Toggle(p,PLAYER_REPEAT,-1);
  2117. break;
  2119. case IF_OPTIONS_SHUFFLE:
  2120. Toggle(p,PLAYER_SHUFFLE,-1);
  2121. break;
  2123. case IF_OPTIONS_EQUALIZER:
  2124. p->Equalizer->Get(p->Equalizer,EQUALIZER_ENABLED,&b,sizeof(b));
  2125. b = !b;
  2126. p->Equalizer->Set(p->Equalizer,EQUALIZER_ENABLED,&b,sizeof(b));
  2127. //p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
  2128. break;
  2130. case IF_OPTIONS_SKIN:
  2132. Node = NodeCreate(OPENFILE_ID);
  2133. if (Node)
  2134. {
  2135. i = OPENFLAG_SINGLE;
  2136. Node->Set(Node,OPENFILE_FLAGS,&i,sizeof(i));
  2137. i = SKIN_CLASS;
  2138. Node->Set(Node,OPENFILE_CLASS,&i,sizeof(i));
  2139. i = ((win*)Node)->Popup((win*)Node,&p->Win);
  2140. NodeDelete(Node);
  2141. if (i==1)
  2142. {
  2143. p->SkinPath[0] = 0;
  2144. UpdateSkinFile(p);
  2145. }
  2146. }
  2147. break;
  2150. case IF_OPTIONS_FULLSCREEN:
  2151. p->FullScreen = -1; // force button refresh
  2152. ToggleFullScreen(p,-1,1);
  2153. break;
  2155. case IF_OPTIONS_MUTE:
  2156. p->Mute = -1; // force button refresh
  2157. if (p->Player->Get(p->Player,PLAYER_VOLUME,&i,sizeof(i))==ERR_NONE && i==0)
  2158. {
  2159. i = 1;
  2160. p->Player->Set(p->Player,PLAYER_VOLUME,&i,sizeof(i));
  2161. }
  2162. Toggle(p,PLAYER_MUTE,-1);
  2163. UpdateVolume(p);
  2164. break;
  2166. case IF_OPTIONS_VIDEO_DITHER:
  2167. p->Color->Get(p->Color,COLOR_DITHER,&b,sizeof(b));
  2168. b = !b;
  2169. p->Color->Set(p->Color,COLOR_DITHER,&b,sizeof(b));
  2170. break;
  2172. case IF_OPTIONS_ROTATE:
  2173. p->Player->Get(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
  2174. switch (i)
  2175. {
  2176. case 0: i = DIR_SWAPXY | DIR_MIRRORLEFTRIGHT; break;
  2177. case DIR_SWAPXY | DIR_MIRRORLEFTRIGHT: i = DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT; break;
  2178. case DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT: i = DIR_SWAPXY | DIR_MIRRORUPDOWN; break;
  2179. case DIR_SWAPXY | DIR_MIRRORUPDOWN: i = 0; break;
  2180. default: i = 0; break;
  2181. }
  2182. p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
  2183. p->Player->Get(p->Player,PLAYER_SKIN_DIR,&i,sizeof(i));
  2184. switch (i)
  2185. {
  2186. case 0: i = DIR_SWAPXY | DIR_MIRRORLEFTRIGHT; break;
  2187. case DIR_SWAPXY | DIR_MIRRORLEFTRIGHT: i = DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT; break;
  2188. case DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT: i = DIR_SWAPXY | DIR_MIRRORUPDOWN; break;
  2189. case DIR_SWAPXY | DIR_MIRRORUPDOWN: i = 0; break;
  2190. default: i = 0; break;
  2191. }
  2192. p->Player->Set(p->Player,PLAYER_SKIN_DIR,&i,sizeof(i));
  2193. break;
  2195. case IF_OPTIONS_ROTATE_GUI:
  2196. i = -1;
  2197. p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
  2198. break;
  2200. case IF_OPTIONS_ROTATE_0:
  2201. i = 0;
  2202. p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
  2203. break;
  2205. case IF_OPTIONS_ROTATE_270:
  2206. i = DIR_SWAPXY | DIR_MIRRORUPDOWN;
  2207. p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
  2208. break;
  2210. case IF_OPTIONS_ROTATE_180:
  2211. i = DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT;
  2212. p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
  2213. break;
  2215. case IF_OPTIONS_ROTATE_90:
  2216. i = DIR_SWAPXY | DIR_MIRRORLEFTRIGHT;
  2217. p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
  2218. break;
  2220. case IF_OPTIONS_ASPECT_AUTO:
  2221. f.Num = 0;
  2222. f.Den = 1;
  2223. p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
  2224. break;
  2226. case IF_OPTIONS_ASPECT_SQUARE:
  2227. f.Num = 1;
  2228. f.Den = 1;
  2229. p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
  2230. break;
  2232. case IF_OPTIONS_ASPECT_4_3_SCREEN:
  2233. f.Num = -4;
  2234. f.Den = 3;
  2235. p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
  2236. break;
  2238. case IF_OPTIONS_ASPECT_4_3_NTSC:
  2239. f.Num = 10;
  2240. f.Den = 11;
  2241. p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
  2242. break;
  2244. case IF_OPTIONS_ASPECT_4_3_PAL:
  2245. f.Num = 12;
  2246. f.Den = 11;
  2247. p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
  2248. break;
  2250. case IF_OPTIONS_ASPECT_16_9_SCREEN:
  2251. f.Num = -16;
  2252. f.Den = 9;
  2253. p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
  2254. break;
  2256. case IF_OPTIONS_ASPECT_16_9_NTSC:
  2257. f.Num = 40;
  2258. f.Den = 33;
  2259. p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
  2260. break;
  2262. case IF_OPTIONS_ASPECT_16_9_PAL:
  2263. f.Num = 16;
  2264. f.Den = 11;
  2265. p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
  2266. break;
  2268. case IF_OPTIONS_ZOOM_FIT_SCREEN:
  2269. f.Num = 0;
  2270. f.Den = 1;
  2271. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2272. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2273. break;
  2275. case IF_OPTIONS_ZOOM_STRETCH_SCREEN:
  2276. f.Num = -3;
  2277. f.Den = SCALE_ONE;
  2278. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2279. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2280. break;
  2282. case IF_OPTIONS_ZOOM_FILL_SCREEN:
  2283. f.Num = -4;
  2284. f.Den = SCALE_ONE;
  2285. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2286. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2287. break;
  2289. case IF_OPTIONS_VIEW_TITLEBAR:
  2290. p->TitleBar = !p->TitleBar;
  2291. UpdateTitleBar(p,1);
  2292. break;
  2294. case IF_OPTIONS_VIEW_TASKBAR:
  2295. p->TaskBar = !p->TaskBar;
  2296. UpdateTaskBar(p);
  2297. break;
  2299. case IF_OPTIONS_VIEW_TRACKBAR:
  2300. p->TrackBar = !p->TrackBar;
  2301. UpdateTrackBar(p,1);
  2302. break;
  2304. case IF_OPTIONS_ZOOM_50:
  2305. f.Num = 1;
  2306. f.Den = 2;
  2307. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2308. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2309. break;
  2311. case IF_OPTIONS_ZOOM_100:
  2312. f.Num = 1;
  2313. f.Den = 1;
  2314. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2315. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2316. break;
  2318. case IF_OPTIONS_ZOOM_FIT_110:
  2319. f.Num = -11;
  2320. f.Den = 10;
  2321. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2322. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2323. break;
  2325. case IF_OPTIONS_ZOOM_FIT_120:
  2326. f.Num = -12;
  2327. f.Den = 10;
  2328. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2329. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2330. break;
  2332. case IF_OPTIONS_ZOOM_FIT_130:
  2333. f.Num = -13;
  2334. f.Den = 10;
  2335. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2336. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2337. break;
  2339. case IF_OPTIONS_ZOOM_150:
  2340. f.Num = 3;
  2341. f.Den = 2;
  2342. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2343. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2344. break;
  2346. case IF_OPTIONS_ZOOM_200:
  2347. f.Num = 2;
  2348. f.Den = 1;
  2349. p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
  2350. p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
  2351. break;
  2353. case IF_OPTIONS_VIDEO_ZOOM_SMOOTH50:
  2354. Toggle(p,PLAYER_SMOOTH50,-1);
  2355. Toggle(p,PLAYER_SMOOTHALWAYS,0);
  2356. break;
  2358. case IF_OPTIONS_VIDEO_ZOOM_SMOOTHALWAYS:
  2359. Toggle(p,PLAYER_SMOOTHALWAYS,-1);
  2360. Toggle(p,PLAYER_SMOOTH50,0);
  2361. break;
  2363. case IF_OPTIONS_AUDIO_STEREO:
  2364. i = STEREO_NORMAL;
  2365. p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
  2366. break;
  2368. case IF_OPTIONS_AUDIO_STEREO_SWAPPED:
  2369. i = STEREO_SWAPPED;
  2370. p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
  2371. break;
  2373. case IF_OPTIONS_AUDIO_STEREO_JOINED:
  2374. i = STEREO_JOINED;
  2375. p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
  2376. break;
  2378. case IF_OPTIONS_AUDIO_STEREO_LEFT:
  2379. i = STEREO_LEFT;
  2380. p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
  2381. break;
  2383. case IF_OPTIONS_AUDIO_STEREO_RIGHT:
  2384. i = STEREO_RIGHT;
  2385. p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
  2386. break;
  2388. case IF_OPTIONS_AUDIO_PREAMP_INC:
  2389. p->Player->Get(p->Player,PLAYER_PREAMP,&i,sizeof(i));
  2390. i += 25;
  2391. if (i>200) i=200;
  2392. p->Player->Set(p->Player,PLAYER_PREAMP,&i,sizeof(i));
  2393. break;
  2395. case IF_OPTIONS_AUDIO_PREAMP_DEC:
  2396. p->Player->Get(p->Player,PLAYER_PREAMP,&i,sizeof(i));
  2397. i -= 25;
  2398. if (i<-200) i=-200;
  2399. p->Player->Set(p->Player,PLAYER_PREAMP,&i,sizeof(i));
  2400. break;
  2402. case IF_OPTIONS_AUDIO_PREAMP:
  2403. i = 0;
  2404. p->Player->Set(p->Player,PLAYER_PREAMP,&i,sizeof(i));
  2405. break;
  2407. case IF_OPTIONS_AUDIO_QUALITY_LOW:
  2408. i = 0;
  2409. p->Player->Set(p->Player,PLAYER_AUDIO_QUALITY,&i,sizeof(i));
  2410. break;
  2412. case IF_OPTIONS_AUDIO_QUALITY_MEDIUM:
  2413. i = 1;
  2414. p->Player->Set(p->Player,PLAYER_AUDIO_QUALITY,&i,sizeof(i));
  2415. break;
  2417. case IF_OPTIONS_AUDIO_QUALITY_HIGH:
  2418. i = 2;
  2419. p->Player->Set(p->Player,PLAYER_AUDIO_QUALITY,&i,sizeof(i));
  2420. break;
  2422. case IF_OPTIONS_VIDEO_QUALITY_LOWEST:
  2423. i = 0;
  2424. p->Player->Set(p->Player,PLAYER_VIDEO_QUALITY,&i,sizeof(i));
  2425. p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
  2426. break;
  2428. case IF_OPTIONS_VIDEO_QUALITY_LOW:
  2429. i = 1;
  2430. p->Player->Set(p->Player,PLAYER_VIDEO_QUALITY,&i,sizeof(i));
  2431. p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
  2432. break;
  2434. case IF_OPTIONS_VIDEO_QUALITY_NORMAL:
  2435. i = 2;
  2436. p->Player->Set(p->Player,PLAYER_VIDEO_QUALITY,&i,sizeof(i));
  2437. p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
  2438. break;
  2440. case IF_OPTIONS_SPEED_10:
  2441. f.Num = 1;
  2442. f.Den = 10;
  2443. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2444. break;
  2446. case IF_OPTIONS_SPEED_25:
  2447. f.Num = 1;
  2448. f.Den = 4;
  2449. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2450. break;
  2452. case IF_OPTIONS_SPEED_50:
  2453. f.Num = 1;
  2454. f.Den = 2;
  2455. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2456. break;
  2458. case IF_OPTIONS_SPEED_100:
  2459. f.Num = 1;
  2460. f.Den = 1;
  2461. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2462. break;
  2464. case IF_OPTIONS_SPEED_150:
  2465. f.Num = 3;
  2466. f.Den = 2;
  2467. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2468. break;
  2470. case IF_OPTIONS_SPEED_200:
  2471. f.Num = 2;
  2472. f.Den = 1;
  2473. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2474. break;
  2476. case IF_OPTIONS_SPEED_80:
  2477. f.Num = 8;
  2478. f.Den = 10;
  2479. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2480. break;
  2482. case IF_OPTIONS_SPEED_90:
  2483. f.Num = 9;
  2484. f.Den = 10;
  2485. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2486. break;
  2488. case IF_OPTIONS_SPEED_110:
  2489. f.Num = 11;
  2490. f.Den = 10;
  2491. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2492. break;
  2494. case IF_OPTIONS_SPEED_120:
  2495. f.Num = 12;
  2496. f.Den = 10;
  2497. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2498. break;
  2500. case IF_OPTIONS_SPEED_BENCHMARK:
  2501. f.Num = 0;
  2502. f.Den = 1;
  2503. p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
  2504. break;
  2506. case IF_OPTIONS_VIDEO_TURNOFF:
  2507. p->Player->Set(p->Player,PLAYER_VOUTPUTID,&Zero,sizeof(Zero));
  2508. break;
  2510. case IF_OPTIONS_AUDIO_TURNOFF:
  2511. p->Player->Set(p->Player,PLAYER_AOUTPUTID,&Zero,sizeof(Zero));
  2512. UpdateVolume(p);
  2513. break;
  2515. case IF_OPTIONS_SUBTITLE_STREAM_NONE:
  2516. i = MAXSTREAM;
  2517. p->Player->Set(p->Player,PLAYER_SUBSTREAM,&i,sizeof(i));
  2518. break;
  2519. }
  2521. if (Cmd >= IF_CHAPTER && Cmd < IF_CHAPTER+100)
  2522. {
  2523. tick_t Time = PlayerGetChapter(p->Player,Cmd-IF_CHAPTER,NULL,0);
  2524. if (Time>=0)
  2525. p->Player->Set(p->Player,PLAYER_POSITION,&Time,sizeof(tick_t));
  2526. }
  2528. if (Cmd >= IF_STREAM_AUDIO && Cmd < IF_STREAM_AUDIO+MAXSTREAM)
  2529. {
  2530. i = Cmd-IF_STREAM_AUDIO;
  2531. p->Player->Set(p->Player,PLAYER_ASTREAM,&i,sizeof(i));
  2532. p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
  2533. }
  2535. if (Cmd >= IF_STREAM_VIDEO && Cmd < IF_STREAM_VIDEO+MAXSTREAM)
  2536. {
  2537. i = Cmd-IF_STREAM_VIDEO;
  2538. p->Player->Set(p->Player,PLAYER_VSTREAM,&i,sizeof(i));
  2539. p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
  2540. }
  2542. if (Cmd >= IF_STREAM_SUBTITLE && Cmd < IF_STREAM_SUBTITLE+MAXSTREAM)
  2543. {
  2544. i = Cmd-IF_STREAM_SUBTITLE;
  2545. p->Player->Set(p->Player,PLAYER_SUBSTREAM,&i,sizeof(i));
  2546. p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
  2547. }
  2549. if (Cmd >= IF_VIDEO && Cmd < IF_VIDEO+ARRAYCOUNT(p->VOutput,int))
  2550. {
  2551. b = 0;
  2552. p->Player->Set(p->Player,PLAYER_VIDEO_ACCEL,&b,sizeof(b));
  2553. p->Player->Set(p->Player,PLAYER_VOUTPUTID,ARRAYBEGIN(p->VOutput,int)+(Cmd-IF_VIDEO),sizeof(int));
  2554. }
  2556. if (Cmd >= IF_VIDEOACCEL && Cmd < IF_VIDEOACCEL+ARRAYCOUNT(p->VOutput,int))
  2557. {
  2558. b = 1;
  2559. p->Player->Set(p->Player,PLAYER_VIDEO_ACCEL,&b,sizeof(b));
  2560. p->Player->Set(p->Player,PLAYER_VOUTPUTID,ARRAYBEGIN(p->VOutput,int)+(Cmd-IF_VIDEOACCEL),sizeof(int));
  2561. }
  2563. if (Cmd >= IF_AUDIO && Cmd < IF_AUDIO+ARRAYCOUNT(p->AOutput,int))
  2564. {
  2565. p->Player->Set(p->Player,PLAYER_AOUTPUTID,ARRAYBEGIN(p->AOutput,int)+(Cmd-IF_AUDIO),sizeof(int));
  2566. UpdateVolume(p);
  2567. }
  2569. if (p->Focus && p->Clipping)
  2570. UpdateClipping(p,0,1); // maybe overlapping window is gone
  2572. return ERR_INVALID_PARAM;
  2573. }
  2575. static int PlayerNotify(intface* p,int Id,int Value)
  2576. {
  2577. if (Id == PLAYER_TITLE)
  2578. {
  2579. p->TitleTimeWidth = 0;
  2580. if (Value)
  2581. p->TitleTime = -1;
  2582. if (p->WndTitle && !p->FullScreen)
  2583. InvalidateRect(p->WndTitle,NULL,1); // redraws timer too!
  2584. if (!p->Win.FullScreen && !p->Bench && p->InSeek && p->Capture)
  2585. PostMessage(p->Win.Wnd,MSG_PLAYER,PLAYER_PERCENT,Value);
  2586. }
  2587. else
  2588. if (Id == PLAYER_PERCENT)
  2589. {
  2590. if (!p->Win.FullScreen && !p->Bench && (!p->InSeek || !p->Capture))
  2591. PostMessage(p->Win.Wnd,MSG_PLAYER,PLAYER_PERCENT,Value);
  2592. }
  2593. else
  2594. PostMessage(p->Win.Wnd,MSG_PLAYER,Id,Value);
  2595. return ERR_NONE;
  2596. }
  2598. static int ErrorNotify(intface* p,int Param,int Param2)
  2599. {
  2600. const tchar_t* Msg = (const tchar_t*)Param2;
  2601. if (GetCurrentThreadId() != p->ThreadId)
  2602. PostMessage(p->Win.Wnd,MSG_ERROR,0,(LPARAM)tcsdup(Msg));
  2603. else
  2604. ShowError2(p,Msg);
  2605. return ERR_NONE;
  2606. }
  2608. static int KeyRotate(intface* p,int Code)
  2609. {
  2610. int i;
  2611. int Dir;
  2613. if (!QueryAdvanced(ADVANCED_KEYFOLLOWDIR))
  2614. return Code;
  2616. switch (Code)
  2617. {
  2618. case VK_UP: i=1; break;
  2619. case VK_RIGHT: i=2; break;
  2620. case VK_DOWN: i=3; break;
  2621. case VK_LEFT: i=4; break;
  2622. default: return Code;
  2623. }
  2625. p->Player->Get(p->Player,PLAYER_REL_DIR,&Dir,sizeof(Dir));
  2626. if (Dir & DIR_SWAPXY)
  2627. i += (Dir & DIR_MIRRORUPDOWN) ? 1:3;
  2628. else
  2629. i += (Dir & DIR_MIRRORUPDOWN) ? 2:0;
  2630. if (i>4) i-=4;
  2632. switch (i)
  2633. {
  2634. case 1: Code = VK_UP; break;
  2635. case 2: Code = VK_RIGHT; break;
  2636. case 3: Code = VK_DOWN; break;
  2637. case 4: Code = VK_LEFT; break;
  2638. }
  2640. return Code;
  2641. }
  2643. static void DefaultSkin(intface* p);
  2645. static NOINLINE void UpdatePosition(intface* p)
  2646. {
  2647. UpdateTrackPos(p);
  2648. UpdateTitleTime(p);
  2649. }
  2651. static const int SkinCmd[MAX_SKINITEM] =
  2652. {
  2653. 0,
  2654. 0,
  2655. 0,
  2656. 0,
  2657. 0,
  2658. IF_PLAY,
  2659. IF_STOP,
  2660. IF_NEXT,
  2661. IF_PREV,
  2662. IF_OPTIONS_FULLSCREEN,
  2663. IF_FASTFORWARD,
  2664. IF_FILE_PLAYLIST,
  2665. IF_FILE_OPENFILE,
  2666. IF_OPTIONS_MUTE,
  2667. IF_OPTIONS_REPEAT,
  2668. IF_SKIN0,
  2669. IF_SKIN1,
  2670. IF_OPTIONS_ROTATE,
  2671. 0,
  2672. IF_PLAY_FULLSCREEN,
  2673. IF_FILE_EXIT,
  2674. };
  2676. static bool_t Proc(intface* p, int Msg, uint32_t wParam, uint32_t lParam, int* Result)
  2677. {
  2678. tick_t t;
  2679. bool_t b;
  2680. int i,Key;
  2681. PAINTSTRUCT Paint;
  2682. notify Notify;
  2684. switch (Msg) 
  2685. {
  2686. case WM_CANCELMODE:
  2687. if (p->InSkin>0)
  2688. {
  2689. p->InSkin = 0;
  2690. ReleaseCapture();
  2691. }
  2693. if (p->InVol)
  2694. {
  2695. p->InVol = 0;
  2696. ReleaseCapture();
  2697. }
  2698. if (p->InSeek)
  2699. StopSeek(p);
  2700. if (IsOverlay(p))
  2701. {
  2702. //delayed clipping (don't want to turn off overlay, just because a toolbar button was pressed)
  2703. SetTimer(p->Win.Wnd,TIMER_CLIPPING2,CLIPPING2_CYCLE,NULL);
  2704. break;
  2705. }
  2706. // no break
  2707. #if !defined(TARGET_WINCE)
  2708. case WM_INITMENU:
  2709. #endif
  2710. UpdateClipping(p,1,1); // force clipping mode
  2711. break;
  2713. case WM_PAINT:
  2714. BeginPaint(p->Win.Wnd,&Paint);
  2715. if (p->Skin[p->SkinNo].Valid)
  2716. SkinDraw(&p->Skin[p->SkinNo],Paint.hdc,&p->SkinArea);
  2717. p->Player->Paint(p->Player,Paint.hdc,p->Offset.x,p->Offset.y);
  2718. EndPaint(p->Win.Wnd,&Paint);
  2719. break;
  2721. #if defined(TARGET_WINCE)
  2722. case WM_CTLCOLORSTATIC:
  2723. *Result = (LRESULT) GetSysColorBrush(COLOR_BTNFACE);
  2724. return 1;
  2725. #endif
  2727. case WM_SYSCHAR:
  2728. if (wParam == 13) //Alt+Enter
  2729. PostMessage(p->Win.Wnd,WM_COMMAND,IF_OPTIONS_FULLSCREEN,0);
  2730. break;
  2732. case WM_TIMER:
  2733. if (wParam == TIMER_TITLESCROLL)
  2734. TitleScroll(p);
  2736. if (wParam == TIMER_SLIDERINVOL)
  2737. UpdateVol(p);
  2739. if (wParam == TIMER_SLIDERINSEEK && !p->Win.FullScreen)
  2740. UpdatePosition(p);
  2742. if (wParam == TIMER_KEYINSEEK)
  2743. StopSeek(p);
  2745. if (wParam == TIMER_CLIPPING2 && ShowVideo(p) && !p->Clipping && IsOverlapped(p))
  2746. UpdateClipping(p,1,1);
  2748. if (wParam == TIMER_CLIPPING && ShowVideo(p) && p->Clipping)
  2749. UpdateClipping(p,0,1);
  2751. if (wParam == TIMER_INITING)
  2752. {
  2753. NodeRegSaveValue(0,REG_INITING,NULL,0,TYPE_INT);
  2754. KillTimer(p->Win.Wnd,TIMER_INITING);
  2755. }
  2757. if (wParam == TIMER_SLEEP && (p->Play>0 || p->FFwd>0))
  2758. SleepTimerReset();
  2760. break;
  2762. case WM_INITMENUPOPUP:
  2763. UpdateClipping(p,1,1); // force clipping mode
  2764. UpdateMenu(p);
  2765. break;
  2767. case WM_KEYUP:
  2768. #if defined(TARGET_WINCE)
  2769. if (!GetDisplayPower())
  2770. SetDisplayPower(0,1);
  2771. #endif
  2772. Key = WinKeyState(KeyRotate(p,wParam));
  2773. for (i=0;i<HOTKEYCOUNT;++i)
  2774. if (p->HotKey[i] && (p->HotKey[i] & ~HOTKEY_KEEP) == Key)
  2775. return 0;
  2777. if (p->AllKeys)
  2778. ForwardMenuButtons(&p->Win,Msg,wParam,lParam);
  2779. break;
  2781. case WM_KEYDOWN:
  2782. Key = WinKeyState(KeyRotate(p,wParam));
  2783. for (i=0;i<HOTKEYCOUNT;++i)
  2784. if (p->HotKey[i] && (p->HotKey[i] & ~HOTKEY_KEEP) == Key)
  2785. {
  2786. PostMessage(p->Win.Wnd,WM_COMMAND,HotKey[i],0);
  2787. return 0;
  2788. }
  2790. if (p->AllKeys)
  2791. ForwardMenuButtons(&p->Win,Msg,wParam,lParam);
  2792. break;
  2794. case WM_HOTKEY:
  2795. #if defined(TARGET_WINCE)
  2796. if ((LOWORD(lParam) & MOD_KEYUP))
  2797. {
  2798. if (!GetDisplayPower())
  2799. SetDisplayPower(0,1);
  2800. }
  2801. else
  2802. #endif
  2803. PostMessage(p->Win.Wnd,WM_COMMAND,wParam,0);
  2804. *Result = 0;
  2805. return 1;
  2807. case WM_MOUSEMOVE:
  2808. if (p->InSkin>0 && (wParam & MK_LBUTTON))
  2809. SkinMouse(&p->Skin[p->SkinNo],p->InSkin,(int16_t)LOWORD(lParam)-p->SkinArea.x,(int16_t)HIWORD(lParam)-p->SkinArea.y,p->Player,NULL,p->Win.Wnd,&p->SkinArea);
  2810. return 0;
  2812. case WM_LBUTTONUP:
  2813. if (p->InSkin>0)
  2814. {
  2815. int Cmd = 0;
  2816. SkinMouse(&p->Skin[p->SkinNo],p->InSkin,(int16_t)LOWORD(lParam)-p->SkinArea.x,(int16_t)HIWORD(lParam)-p->SkinArea.y,p->Player,&Cmd,p->Win.Wnd,&p->SkinArea);
  2817. if (p->InSeek)
  2818. StopSeek(p);
  2820. p->InSkin = 0;
  2821. if (p->Capture)
  2822. {
  2823. ReleaseCapture();
  2824. p->Capture = 0;
  2825. }
  2827. if (Cmd==SKIN_VOLUME)
  2828. UpdateVolume(p);
  2830. if (Cmd>0 && SkinCmd[Cmd]>0)
  2831. Command(p,SkinCmd[Cmd]);
  2832. }
  2833. *Result = 0;
  2834. return 1;
  2836. case WM_LBUTTONDBLCLK:
  2837. case WM_LBUTTONDOWN:
  2838. DEBUG_MSG(DEBUG_WIN,T("LBUTTON"));
  2839. if ((wParam & MK_LBUTTON) && p->Focus)
  2840. {
  2841. tchar_t URL[MAXPATH];
  2842. SetDisplayPower(1,0);
  2844. if (p->Skin[p->SkinNo].Valid && !p->FullScreen)
  2845. p->InSkin = SkinMouse(&p->Skin[p->SkinNo],0,(int16_t)LOWORD(lParam)-p->SkinArea.x,(int16_t)HIWORD(lParam)-p->SkinArea.y,p->Player,NULL,p->Win.Wnd,&p->SkinArea);
  2846. else
  2847. p->InSkin = -1;
  2849. if (p->InSkin>0)
  2850. {
  2851. SetCapture(p->Win.Wnd);
  2852. p->Capture = 1;
  2853. if (p->InSkin == SKIN_SEEK)
  2854. p->InSeek = 1;
  2855. }
  2856. else if (p->InSkin<0)
  2857. {
  2858. if (!p->FullScreen && p->Player->CommentByName(p->Player,-1,T("URL"),URL,TSIZEOF(URL)))
  2859. WinShowHTML(URL);
  2860. else
  2861. if (p->Player->Get(p->Player,PLAYER_SINGLECLICKFULLSCREEN,&b,sizeof(b))==ERR_NONE && !b)
  2862. {
  2863. if (Msg == WM_LBUTTONDBLCLK)
  2864. PostMessage(p->Win.Wnd,WM_COMMAND,IF_OPTIONS_FULLSCREEN,0);
  2865. PostMessage(p->Win.Wnd,WM_COMMAND,IF_PLAY,0);
  2866. }
  2867. else
  2868. PostMessage(p->Win.Wnd,WM_COMMAND,IF_PLAY_FULLSCREEN,0);
  2869. }
  2870. }
  2871. SetForegroundWindow(p->Win.Wnd); //sometimes wince suck (triple click in opendialog)
  2872. *Result = 0;
  2873. return 1;
  2875. case WM_MOVE:
  2876. Resize(p);
  2877. break;
  2879. case WM_SETTINGCHANGE:
  2880. if (wParam == SETTINGCHANGE_RESET) 
  2881. {
  2882. p->Player->Set(p->Player,PLAYER_RESETVIDEO,NULL,0);
  2884. if (p->VolResizeNeeded2)
  2885. {
  2886. ResizeVolume(p);
  2887. if (p->VolResizeNeeded2>1)
  2888. ShowVol(p,1);
  2889. p->VolResizeNeeded2 = 0;
  2890. }
  2891. }
  2892. break;
  2894. case WM_SIZE:
  2895. #ifdef MAXIMIZE_FULLSCREEN
  2896. if (wParam == SIZE_MAXIMIZED)
  2897. {
  2898. ShowWindow(p->Win.Wnd,SW_SHOWNORMAL);
  2899. ToggleFullScreen(p,1,1);
  2900. }
  2901. else
  2902. #endif
  2903. Resize(p);
  2904. break;
  2906. case WM_SETFOCUS:
  2907. if (!p->Focus || !p->WndVolBack || (HWND)wParam != p->WndVolBack)
  2908. {
  2909. DEBUG_MSG(DEBUG_WIN,T("SETFOCUS"));
  2910. p->Focus = 1;
  2911. DIASet(0,DIA_SIP);
  2912. if (p->Wait)
  2913. {
  2914. WaitBegin();
  2915. UpdateHotKey(p,1,0);
  2916. // clipping still needed
  2917. }
  2918. else
  2919. UpdateClipping(p,0,1); // turn off clipping when no overlapping windows
  2920. UpdateClippingTimer(p);
  2921. UpdateTitleScroll(p);
  2922. }
  2923. break;
  2925. case WM_KILLFOCUS:
  2926. if (!p->WndVolBack || (HWND)wParam != p->WndVolBack)
  2927. {
  2928. DEBUG_MSG(DEBUG_WIN,T("KILLFOCUS"));
  2929. p->Focus = 0;
  2930. if (!ShowVideo(p))
  2931. UpdateClipping(p,1,1); // force clipping mode
  2932. if (p->Wait)
  2933. WaitEnd();
  2934. }
  2935. break;
  2937. case WM_ACTIVATE:
  2938. if (!p->WndVolBack || (HWND)lParam != p->WndVolBack)
  2939. {
  2940. if (LOWORD(wParam)==WA_INACTIVE) 
  2941. {
  2942. #ifdef NDEBUG
  2943. Toggle(p,PLAYER_FOREGROUND,0);
  2944. ToggleFullScreen(p,0,0); // example ATI tweaks have problem
  2945. #endif
  2946. ShowVol(p,0);
  2947. if (p->InSeek) StopSeek(p);
  2948. SetDisplayPower(1,0);
  2949. }
  2950. else
  2951. {
  2952. ShowVol(p,1);
  2953. UpdateVolume(p);
  2954. Toggle(p,PLAYER_FOREGROUND,1);
  2955. if (p->ForceFullScreen)
  2956. PostMessage(p->Win.Wnd,MSG_PLAYER,PLAYER_FULLSCREEN,1);
  2957. }
  2958. }
  2959. break;
  2961. case WM_DESTROY:
  2962. BeforeExit(p);
  2963. PostQuitMessage(0);
  2965. SkinFree(p->Skin,NULL);
  2967. Context()->Error.Func = NULL;
  2968. ArrayClear(&p->VOutput);
  2969. ArrayClear(&p->AOutput);
  2970. break;
  2972. case MSG_ERROR:
  2973. ShowError2(p,(const tchar_t*)lParam);
  2974. free((tchar_t*)lParam);
  2975. return 1;
  2977. case MSG_PLAYER:
  2978. switch (wParam)
  2979. {
  2980. case PLAYER_EXIT_AT_END:
  2981. if (p->CmdLineMode)
  2982. PostMessage(p->Win.Wnd,WM_COMMAND,IF_FILE_EXIT,0);
  2983. break;
  2985. case PLAYER_PERCENT:
  2986. UpdatePosition(p);
  2987. break;
  2989. case PLAYER_LOADMODE:
  2990. if (p->Wait != (bool_t)lParam)
  2991. {
  2992. p->Wait = lParam;
  2993. if (p->Wait)
  2994. {
  2995. if (WaitBegin())
  2996. UpdateClipping(p,1,0);
  2997. }
  2998. else
  2999. WaitEnd();
  3000. }
  3001. break;
  3003. case PLAYER_FULLSCREEN:
  3004. p->ForceFullScreen = lParam;
  3005. if (GetForegroundWindow() == p->Win.Wnd || !lParam)
  3006. {
  3007. ToggleFullScreen(p,lParam,1);
  3008. p->ForceFullScreen = 0;
  3009. }
  3010. break;
  3012. case PLAYER_PLAY:
  3013. RefreshButton(p,PLAYER_PLAY,&p->Play,IF_PLAY,0,1);
  3014. RefreshButton(p,PLAYER_FFWD,&p->FFwd,IF_FASTFORWARD,4,1);
  3015. UpdateSleepTimer(p);
  3016. break;
  3018. case PLAYER_BENCHMARK:
  3019. if (p->Bench && p->Player->Get(p->Player,PLAYER_BENCHMARK,&t,sizeof(tick_t))==ERR_NONE)
  3020. {
  3021. p->Bench = 0;
  3022. ToggleFullScreen(p,0,0);
  3023. WaitEnd();
  3024. if (p->WndTrack)
  3025. SetTrackThumb(p->WndTrack,1);
  3027. UpdateWindow(p->Win.Wnd);
  3028. WinPopupClass(BENCHRESULT_ID,&p->Win);
  3029. }
  3030. break;
  3031. }
  3032. return 1;
  3034. case WM_COPYDATA:
  3035. ProcessCmdLine(p,(const tchar_t*)((COPYDATASTRUCT*)lParam)->lpData);
  3036. return 1;
  3038. case MSG_INIT:
  3039. SetForegroundWindow(p->Win.Wnd);
  3040. if (Context()->CmdLine[0] || NodeRegLoadValue(0,REG_INITING,&i,sizeof(i),TYPE_INT))
  3041. {
  3042. b = 1; // last time crashed -> discard saved playlist
  3043. p->Player->Set(p->Player,PLAYER_DISCARDLIST,&b,sizeof(b));
  3044. }
  3046. #ifdef NDEBUG
  3047. i = 1;
  3048. NodeRegSaveValue(0,REG_INITING,&i,sizeof(int),TYPE_INT);
  3049. SetTimer(p->Win.Wnd,TIMER_INITING,INITING_CYCLE,NULL);
  3050. #endif
  3052. Context_Wnd(p->Win.Wnd);
  3054. if (Context()->CmdLine[0])
  3055. {
  3056. p->Player->Get(p->Player,PLAYER_PLAYATOPEN_FULL,&b,sizeof(b));
  3057. if (!b)
  3058. {
  3059. UpdateWindow(p->Win.Wnd); //http connection may take a while
  3060. if (p->Win.WndTB)
  3061. UpdateWindow(p->Win.WndTB);
  3062. }
  3064. ProcessCmdLine(p,Context()->CmdLine);
  3065. }
  3067. if (LangStr(LANG_ID,LANG_DEFAULT)[0]==0 &&
  3068. LangStr(LANG_ID,Context()->Lang)[0]==0)
  3069. ShowMessage(NULL,T("Language files (*.txt,*.tgz) are missing!"));
  3071. return 1;
  3073. case WM_CREATE:
  3075. WinTitle(&p->Win,Context()->ProgramName);
  3077. p->ThreadId = GetCurrentThreadId();
  3078. p->Player = (player*)Context()->Player;
  3079. p->Color = NodeEnumObject(NULL,COLOR_ID);
  3080. p->Equalizer = NodeEnumObject(NULL,EQUALIZER_ID);
  3081. p->Focus = 0;
  3082. p->Clipping = 0;
  3084. Notify.This = p;
  3085. Notify.Func = (notifyfunc)PlayerNotify;
  3086. if (p->Player)
  3087. p->Player->Set(p->Player,PLAYER_NOTIFY,&Notify,sizeof(Notify));
  3089. Context()->Error.This = p;
  3090. Context()->Error.Func = ErrorNotify;
  3092. WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_STREAM,0);
  3093. WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_STREAM,0);
  3094. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STREAM,0);
  3095. WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_DEVICE,0);
  3096. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_DEVICE,0);
  3097. WinMenuEnable(&p->Win,1,IF_OPTIONS_ORIENTATION_FULLSCREEN,0);
  3098. WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_QUALITY,0);
  3100. if (!NodeEnumClass(NULL,CORETHEQUE_UI_ID))
  3101. WinMenuDelete(&p->Win,0,IF_FILE_CORETHEQUE);
  3103. if (IsAutoRun(p,Context()->CmdLine))
  3104. DefaultSkin(p);
  3106. SkinLoad(p->Skin,p->Win.Wnd,p->SkinPath);
  3108. if (!p->Skin[0].Valid)
  3109. CreateButtons(p);
  3110. UpdateSkin(p,0);
  3111. UpdateTrackBar(p,0);
  3112. UpdateTitleBar(p,0);
  3113. CreateVolumeTrack(p);
  3114. CreateDeviceMenu(p);
  3115. Resize(p);
  3117. // first finish window creation and postpone loading playlist and etc... 
  3118. PostMessage(p->Win.Wnd,MSG_INIT,0,0);
  3120. UpdateHotKey(p,1,0);
  3121. break;
  3122. }
  3124. return 0;
  3125. }
  3127. static const datatable Params[] =
  3128. {
  3129. { IF_TITLEBAR, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  3130. { IF_TRACKBAR, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  3131. { IF_TASKBAR, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  3132. { IF_SKINNO, TYPE_INT,  DF_SETUP|DF_HIDDEN },
  3133. { IF_SKINPATH, TYPE_STRING,DF_SETUP|DF_HIDDEN },
  3134. #if defined(TARGET_WINCE)
  3135. { IF_ALLKEYS, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  3136. #endif
  3138. DATATABLE_END(INTERFACE_ID)
  3139. };
  3141. static int Enum( intface* p, int* No, datadef* Param )
  3142. {
  3143. if (NodeEnumTable(No,Param,Params)==ERR_NONE)
  3144. return ERR_NONE;
  3146. if (*No>=0 && *No<HOTKEYCOUNT)
  3147. {
  3148. memset(Param,0,sizeof(datadef));
  3149. Param->No = HotKey[*No];
  3150. Param->Type = TYPE_HOTKEY;
  3151. Param->Size = sizeof(int);
  3152. Param->Flags = DF_SETUP;
  3153. #if defined(TARGET_WINCE)
  3154. if (*No==0) Param->Flags |= DF_GAP;
  3155. #endif
  3156. Param->Class = INTERFACE_ID;
  3157. Param->Name = LangStr(INTERFACE_ID,Param->No);
  3158. return ERR_NONE;
  3159. }
  3160. return ERR_INVALID_PARAM;
  3161. }
  3163. static int Get(intface* p,int No,void* Data,int Size)
  3164. {
  3165. int Result = ERR_INVALID_PARAM;
  3166. int i;
  3168. for (i=0;i<HOTKEYCOUNT;++i)
  3169. if (HotKey[i]==No)
  3170. {
  3171. GETVALUE(p->HotKey[i],int); 
  3172. break;
  3173. }
  3175. switch (No)
  3176. {
  3177. case IF_TRACKBAR: GETVALUE(p->TrackBar,bool_t); break;
  3178. case IF_TITLEBAR: GETVALUE(p->TitleBar,bool_t); break;
  3179. case IF_TASKBAR: GETVALUE(p->TaskBar,bool_t); break;
  3180. case IF_SKINNO: GETVALUE(p->SkinNo,int); break;
  3181. case IF_SKINPATH: GETSTRING(p->SkinPath); break;
  3182. case IF_ALLKEYS: GETVALUE(p->AllKeys,bool_t); break;
  3183. }
  3184. return Result;
  3185. }
  3187. static int UpdateSkin(intface* p,bool_t Others)
  3188. {
  3189. if (!p->Player)
  3190. return ERR_NONE;
  3192. if (p->SkinNo>0 && !p->Skin[p->SkinNo].Valid)
  3193. p->SkinNo=0;
  3195. if (Others)
  3196. {
  3197. if (p->Skin[p->SkinNo].Valid)
  3198. SkinUpdate(&p->Skin[p->SkinNo],p->Player,p->Win.Wnd,&p->SkinArea);
  3200. ShowVol(p,1);
  3201. UpdateTrackBar(p,1);
  3202. InvalidateRect(p->Win.Wnd,NULL,0);
  3203. p->ClientRect.right = -1;
  3204. Resize(p);
  3205. }
  3206. RefreshButton(p,PLAYER_REPEAT,NULL,0,0,0);
  3207. RefreshButton(p,PLAYER_PLAY,NULL,0,0,0);
  3208. RefreshButton(p,PLAYER_FFWD,NULL,0,0,0);
  3209. RefreshButton(p,PLAYER_MUTE,NULL,0,0,0);
  3210. RefreshButton(p,PLAYER_FULLSCREEN,NULL,0,0,0);
  3211. if (p->TitleBrush)
  3212. {
  3213. DeleteObject(p->TitleBrush);
  3214. p->TitleBrush = NULL;
  3215. }
  3216. if (p->Skin[p->SkinNo].Valid)
  3217. {
  3218. p->TitleBrush = CreateSolidBrush(p->Skin[p->SkinNo].Item[SKIN_TITLE].ColorFace);
  3219. p->TitleFace = p->Skin[p->SkinNo].Item[SKIN_TITLE].ColorFace;
  3220. p->TitleText = p->Skin[p->SkinNo].Item[SKIN_TITLE].ColorText;
  3221. }
  3222. else
  3223. {
  3224. p->TitleBrush = NULL;
  3225. p->TitleFace = GetSysColor(COLOR_BTNFACE);
  3226. p->TitleText = GetSysColor(COLOR_BTNTEXT);
  3227. }
  3228. return ERR_NONE;
  3229. }
  3231. static int UpdateAllKeys(intface* p)
  3232. {
  3233. if (!p->AllKeys && p->AllKeysWarning)
  3234. {
  3235. int i;
  3236. for (i=0;i<HOTKEYCOUNT;++i)
  3237. if (p->HotKey[i] && WinNoHotKey(p->HotKey[i]))
  3238. {
  3239. ShowMessage(LangStr(p->Win.Node.Class,NODE_NAME),LangStr(INTERFACE_ID,IF_ALLKEYS_WARNING2));
  3240. break;
  3241. }
  3242. }
  3243. return ERR_NONE;
  3244. }
  3246. static void SetHotKey(intface* p,int i,int Key)
  3247. {
  3248. if (p->Focus && p->HotKey[i] && !p->AllKeys)
  3249. WinUnRegisterHotKey(&p->Win,HotKey[i]);
  3251. if (!p->AllKeys && p->AllKeysWarning && WinNoHotKey(Key))
  3252. ShowMessage(LangStr(p->Win.Node.Class,NODE_NAME),LangStr(INTERFACE_ID,IF_ALLKEYS_WARNING));
  3254. p->HotKey[i] = Key;
  3256. if (p->Focus && p->HotKey[i] && !p->AllKeys && !WinEssentialKey(p->HotKey[i]))
  3257. WinRegisterHotKey(&p->Win,HotKey[i],p->HotKey[i]);
  3258. }
  3260. static int Set(intface* p,int No,const void* Data,int Size)
  3261. {
  3262. int Result = ERR_INVALID_PARAM;
  3263. int i,j;
  3265. for (i=0;i<HOTKEYCOUNT;++i)
  3266. if (HotKey[i]==No)
  3267. {
  3268. int Key = *(int*)Data;
  3269. SetHotKey(p,i,0);
  3270. if (Key)
  3271. {
  3272. for (j=0;j<HOTKEYCOUNT;++j)
  3273. if ((p->HotKey[j] & ~HOTKEY_KEEP) == (Key & ~HOTKEY_KEEP))
  3274. SetHotKey(p,j,0);
  3275. SetHotKey(p,i,Key);
  3276. }
  3277. Result = ERR_NONE;
  3278. break;
  3279. }
  3281. switch (No)
  3282. {
  3283. case IF_TRACKBAR: SETVALUE(p->TrackBar,bool_t,UpdateTrackBar(p,1)); break;
  3284. case IF_TITLEBAR: SETVALUE(p->TitleBar,bool_t,UpdateTitleBar(p,1)); break;
  3285. case IF_TASKBAR: SETVALUE(p->TaskBar,bool_t,UpdateTaskBar(p)); break;
  3286. case IF_SKINNO: SETVALUE(p->SkinNo,int,UpdateSkin(p,1)); break;
  3287. case IF_SKINPATH: SETSTRING(p->SkinPath); Result = UpdateSkinFile(p); break;
  3288. case IF_ALLKEYS: SETVALUECMP(p->AllKeys,bool_t,UpdateAllKeys(p),EqBool); break;
  3289. }
  3290. return Result;
  3291. }
  3293. static void DefaultSkin(intface* p)
  3294. {
  3295. tchar_t* s;
  3296. GetModuleFileName(GetModuleHandle(NULL),p->SkinPath,MAXPATH);
  3297. s = tcsrchr(p->SkinPath,'\');
  3298. if (s) s[1]=0;
  3299. tcscat_s(p->SkinPath,TSIZEOF(p->SkinPath),T("skin.xml"));
  3300. p->SkinNo = 0;
  3301. }
  3303. static int Create(intface* p)
  3304. {
  3305. int Key;
  3306. DefaultSkin(p);
  3308. p->Win.WinWidth = 360;
  3309. p->Win.WinHeight = 240;
  3310. p->Win.Proc = Proc;
  3311. p->Win.Command = (wincommand)Command;
  3312. p->Win.MenuDef = MenuDef;
  3313. p->Win.Node.Enum = Enum;
  3314. p->Win.Node.Get = Get;
  3315. p->Win.Node.Set = Set;
  3317. p->Vol = -1;
  3318. p->TaskBar = 1;
  3319. p->TitleBar = 1;
  3320. p->TrackBar = 1;
  3321. p->MenuPreAmp = -1;
  3322. p->MenuStreams = 0;
  3323. p->MenuAStream = -1;
  3324. p->MenuVStream = -1;
  3325. p->MenuSubStream = -1;
  3327. Key = VK_RIGHT;
  3328. Set(p,IF_MOVE_FFWD,&Key,sizeof(Key));
  3329. Key = VK_LEFT;
  3330. Set(p,IF_MOVE_BACK,&Key,sizeof(Key));
  3331. Key = VK_UP;
  3332. Set(p,IF_OPTIONS_VOLUME_UP,&Key,sizeof(Key));
  3333. Key = VK_DOWN;
  3334. Set(p,IF_OPTIONS_VOLUME_DOWN,&Key,sizeof(Key));
  3335. Key = VK_RETURN;
  3336. Set(p,QueryPlatform(PLATFORM_TYPENO) == TYPE_SMARTPHONE?IF_PLAY_FULLSCREEN:IF_PLAY,&Key,sizeof(Key));
  3337. Key = 0xB0; //VK_MEDIA_NEXT_TRACK;
  3338. Set(p,IF_NEXT2,&Key,sizeof(Key));
  3339. Key = 0xB1; //VK_MEDIA_PREV_TRACK;
  3340. Set(p,IF_PREV_SMART2,&Key,sizeof(Key));
  3341. Key = 0xB2; //VK_MEDIA_STOP;
  3342. Set(p,IF_STOP,&Key,sizeof(Key));
  3343. Key = 0xB3; //VK_MEDIA_PLAY_PAUSE;
  3344. Set(p,IF_PLAYPAUSE,&Key,sizeof(Key));
  3345. #if defined(TARGET_WIN32)
  3346. Key = VK_SPACE;
  3347. Set(p,IF_PLAY,&Key,sizeof(Key));
  3348. #endif
  3350. return ERR_NONE;
  3351. }
  3353. static const nodedef IntFace =
  3354. {
  3355. sizeof(intface)|CF_GLOBAL|CF_SETTINGS,
  3356. INTERFACE_ID,
  3357. WIN_CLASS,
  3358. PRI_MAXIMUM+570,
  3359. (nodecreate)Create,
  3360. };
  3362. static const nodedef Skin =
  3363. {
  3364. 0,
  3365. SKIN_CLASS,
  3366. NODE_CLASS,
  3367. PRI_MAXIMUM,
  3368. };
  3370. void Interface_Init()
  3371. {
  3372. NodeRegisterClass(&IntFace);
  3373. NodeRegisterClass(&Skin);
  3374. }
  3376. void Interface_Done()
  3377. {
  3378. NodeUnRegisterClass(INTERFACE_ID);
  3379. NodeUnRegisterClass(SKIN_CLASS);
  3380. }
  3382. #endif