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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
Main.cpp
资源名称：playa-0.3.3src.zip　[点击查看]
上传用户：lusi_8715
上传日期：2007-01-08
资源大小：199k
文件大小：47k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

Main.cpp：源码内容
  1. /**************************************************************************************
  2.  *                                                                                    *
  3.  * This application contains code from OpenDivX and is released as a "Larger Work"    *
  4.  * under that license. Consistant with that license, this application is released     *
  5.  * under the GNU General Public License.                                              *
  6.  *                                                                                    *
  7.  * The OpenDivX license can be found at: http://www.projectmayo.com/opendivx/docs.php *
  8.  * The GPL can be found at: http://www.gnu.org/copyleft/gpl.html                      *
  9.  *                                                                                    *
  10.  * Copyright (c) 2001 - Project Mayo                                                  *
  11.  *                                                                                    *
  12.  * Authors: Damien Chavarria <adrc at projectmayo.com>                                *
  13.  *                                                                                    *
  14.  **************************************************************************************/
  16. #include "debug.h"
  18. #include "Skin.h"
  19. #include "Playback.h"
  20. #include "Playlist.h"
  21. #include "DirDialog.h"
  22. #include "SkinList.h"
  23. #include "Resizer.h"
  25. #ifdef WIN32
  26. #include "../build/win32/ressources.h"
  27. #include "../build/win32/resource.h"
  28. #endif
  30. #include <math.h>
  31. #include <commctrl.h>
  32. #include <windows.h>
  33. #include <windowsx.h>
  35. /*
  36.  * Intervals for the timers
  37.  */
  39. #define TIMER_ID     1
  40. #define TIMER_RATE 100
  42. /*
  43.  * Variables
  44.  *
  45.  * Please regroup that in a struct...
  46.  *
  47.  *
  48.  */
  50. DWORD anonymous;
  51. HWND  hwndDisplay;
  53. #ifdef _DEBUG__
  54. FILE *debug_file;
  55. #endif
  57. int       action  = ACTION_NONE;
  58. DWORD     count = 0;
  59. DWORD     use_subtitles         = 1;
  60. DWORD     no_resize             = 0;
  61. char      skinPath[256];
  62. UINT      uTimerID;
  63. RECT      clientRect;
  64. RECT      windowRect, fullwindowRect;
  65. int       moveX = 0, moveY = 0;
  66. Skin     *skin;
  67. Playback *playback;
  68. Playlist *playlist;
  69. CDirDialog *dirChooser;
  70. SkinList   *skinList;
  71. Resizer   *resizer;
  72. char      Name[] = "The "Playa"";
  73. char     *RecentFiles[5];
  74. HWND      hwnd, about, urlW = NULL;
  75. HMENU     popupMenu;
  76. HACCEL    hAccel;
  77. POINT     pt2;
  78. POINT     oldPt;
  79. HINSTANCE hInstance;
  80. int showing_cursor;
  82. options_t options, tmpOptions;
  84. /*
  85.  * needed definitions
  86.  */
  88. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  89. void OpenFileForPlaying(HWND hwnd, char *filename, int type);
  91. /*
  92.  * Save and load options
  93.  */
  95. void LoadOptions() {
  97. HKEY     key;
  98. DWORD created, size;
  99. LONG     result;
  100. DWORD  type, i;
  101. char      file[256], name[5];
  103. /*
  104.  * Put the default options
  105.  *
  106.  */
  108. options.change_fullscreen_res = 0;
  109. options.loop                  = 1;
  110. options.maintain_aspect_ratio = 1;
  111. options.on_top                = 1;
  112. options.use_bilinear          = 0;
  114. /*
  115.  * Init the recent file list 
  116.  */
  118. for(i=0; i < 5; i++) {
  120. RecentFiles[i] = NULL;
  121. }
  123. /*
  124.  * Open the registry key
  125.  */
  127. result = RegCreateKeyEx(HKEY_CURRENT_USER, "Software\DivXNetworks\ThePlaya",
  128.                   0, "CONFIG", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, 
  129. NULL, &key, &created);
  131. if(result != ERROR_SUCCESS) {
  133. MessageBox(NULL, "Couldn't load options", "", MB_OK);
  134. return;
  135. }
  137. switch(created) {
  139. case REG_CREATED_NEW_KEY:
  141. /*
  142.  * First time launch (we keep the default)
  143.  * 
  144.  */
  146. break;
  148. case REG_OPENED_EXISTING_KEY:
  150. /*
  151.  * We can read the values
  152.    */
  154. size = 4;
  155. result = RegQueryValueEx(key, "UseBilinear", 0, &type, (BYTE *)&options.use_bilinear, &size);
  156. size = 4;
  157. result = RegQueryValueEx(key, "MaintainAspectRatio", 0, &type, (BYTE *)&options.maintain_aspect_ratio, &size);
  158. size = 4;
  159. result = RegQueryValueEx(key, "ChangeFullscreenRes", 0, &type, (BYTE *)&options.change_fullscreen_res, &size);
  160. size = 4;
  161. result = RegQueryValueEx(key, "UseSubtitles", 0, &type, (BYTE *)&use_subtitles, &size);
  163. size = 4;
  164. result = RegQueryValueEx(key, "Loop", 0, &type, (BYTE *)&options.loop, &size);
  165. size = 4;
  166. result = RegQueryValueEx(key, "OnTop", 0, &type, (BYTE *)&options.on_top, &size);
  168. size = 256;
  169. result = RegQueryValueEx(key, "SkinPath", 0, &type, (BYTE *)skinPath, &size);
  171. /*
  172.  * And the recent files
  173.  */
  175. for(i=0; i < 5; i++) {
  177. sprintf(name, "File%d", i+1);
  179. size = 256;
  180. result = RegQueryValueEx(key, name, 0, &type, (BYTE *)&file, &size);
  182. if(result == ERROR_SUCCESS) {
  184. RecentFiles[i] = (char *) malloc(size);
  185. strncpy(RecentFiles[i], file, size);
  186. }
  187. }
  189. break;
  191. default:
  192. break;
  193. }
  195. RegCloseKey(key);
  197. }
  199. void SaveOptions() {
  201. HKEY     key;
  202. LONG     result;
  203. DWORD created, i;
  204. char      name[5];
  206. /*
  207.  * Try to open the registry key
  208.  */
  210. result = RegCreateKeyEx(HKEY_CURRENT_USER, "Software\DivXNetworks\ThePlaya",
  211.               0, "CONFIG", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, 
  212.               NULL, &key, &created);
  214. if(result != ERROR_SUCCESS) {
  216. MessageBox(NULL, "Couldn't save options", "", MB_OK);
  218. RegCloseKey(key);
  219. return;
  220. }
  222. RegSetValueEx(key, "UseBilinear", 0, REG_DWORD, (BYTE *) &options.use_bilinear, 4);
  223. RegSetValueEx(key, "MaintainAspectRatio", 0, REG_DWORD, (BYTE *) &options.maintain_aspect_ratio, 4);
  224. RegSetValueEx(key, "ChangeFullscreenRes", 0, REG_DWORD, (BYTE *) &options.change_fullscreen_res, 4);
  225. RegSetValueEx(key, "UseSubtitles", 0, REG_DWORD, (BYTE *) &use_subtitles, 4);
  226. RegSetValueEx(key, "Loop", 0, REG_DWORD, (BYTE *) &options.loop, 4);
  227. RegSetValueEx(key, "OnTop", 0, REG_DWORD, (BYTE *) &options.on_top, 4);
  229. if(strcmp(skinPath, "Default") != 0)
  230. RegSetValueEx(key, "SkinPath", 0, REG_SZ, (BYTE *) skinPath, strlen(skinPath));
  231. else 
  232. RegSetValueEx(key, "SkinPath", 0, REG_SZ, (BYTE *) "Default", strlen("Default"));
  234. /*
  235.  * The recent file list
  236.  */
  238. for(i=0; i < 5; i++) {
  240. if(RecentFiles[i] != NULL) {
  242. sprintf(name, "File%d", i+1);
  243. RegSetValueEx(key, name, 0, REG_SZ, 
  244.       (BYTE *) RecentFiles[i], strlen(RecentFiles[i]));
  245. }
  246. }
  248. RegCloseKey(key);
  249. }
  251. void Cleanup()
  252. {
  253. DWORD i;
  255. for(i=0; i < 5; i++) {
  257. if(RecentFiles[i] != NULL) {
  259. free(RecentFiles[i]);
  260. }
  261. }
  263. DestroyMenu(popupMenu);
  265. delete playback;
  266. delete skinList;
  267. delete resizer;
  268. delete playlist;
  270. }
  273. /*******************************************************************************************/
  276. static BOOL APIENTRY PreferencesGeneralDlgProc( HWND hDlg, UINT message, UINT wParam, LONG lParam) {
  278. switch(message) {
  279. case WM_INITDIALOG:
  281. SetWindowPos(hDlg, HWND_TOP, 15, 35, 0, 0, SWP_NOSIZE);
  283.     CheckDlgButton(hDlg, IDC_CHECK_LOOP, tmpOptions.loop);
  284.     CheckDlgButton(hDlg, IDC_CHECK_ON_TOP, tmpOptions.on_top);
  286. return TRUE;
  288.   case WM_COMMAND:
  290.         switch (wParam)
  291. {
  292. case IDC_CHECK_LOOP:
  294. tmpOptions.loop = tmpOptions.loop ? 0 : 1;
  295. break;
  297. case IDC_CHECK_ON_TOP:
  299. tmpOptions.on_top = tmpOptions.on_top ? 0 : 1;
  300. break;
  301. }
  303. case WM_DESTROY:
  304. return TRUE;
  305. }
  307. return FALSE;
  308. }
  310. static BOOL APIENTRY PreferencesVideoDlgProc( HWND hDlg, UINT message, UINT wParam, LONG lParam) {
  312. switch(message) {
  313. case WM_INITDIALOG:
  315. SetWindowPos(hDlg, HWND_TOP, 15, 35, 0, 0, SWP_NOSIZE);
  317. CheckDlgButton(hDlg, IDC_CHECK_MAINTAIN, tmpOptions.maintain_aspect_ratio);
  318.     CheckDlgButton(hDlg, IDC_CHECK_BILINEAR, tmpOptions.use_bilinear);
  320.     CheckDlgButton(hDlg, IDC_CHECK_CHANGE_RES, !tmpOptions.change_fullscreen_res);
  322. return TRUE;
  324. case WM_COMMAND:
  326. switch (wParam)
  327. {
  328. case IDC_CHECK_MAINTAIN:
  330. tmpOptions.maintain_aspect_ratio = tmpOptions.maintain_aspect_ratio ? 0 : 1;
  331. break;
  333. case IDC_CHECK_BILINEAR:
  335. tmpOptions.use_bilinear = tmpOptions.use_bilinear ? 0 : 1;
  336. break;
  338. case IDC_CHECK_CHANGE_RES:
  340. tmpOptions.change_fullscreen_res = tmpOptions.change_fullscreen_res ? 0 : 1;
  341. break;
  342. }
  344. case WM_DESTROY:
  345. return TRUE;
  346. }
  348. return FALSE;
  349. }
  351. /*
  352.  * List of the preferences tab
  353.  *
  354.  */
  356. static struct prefsTabs {
  357. LPTSTR rsrc;
  358. char *name;
  359. DLGPROC dProc;
  360. } tabs[]={
  361. { MAKEINTRESOURCE(IDD_PREFS_GENERAL), "General", PreferencesGeneralDlgProc},
  362. { MAKEINTRESOURCE(IDD_PREFS_VIDEO), "Video", PreferencesVideoDlgProc },
  363. };
  365. /*
  366.  * Main preferences DlgProc
  367.  *
  368.  */
  370. static BOOL APIENTRY PreferencesDlgProc( HWND hDlg, UINT message, UINT wParam, LONG lParam) {
  372. DWORD i;
  374. switch(message) {
  375. case WM_INITDIALOG:
  376. {
  377. HWND tab = GetDlgItem(hDlg, IDC_TAB);
  379. memcpy(&tmpOptions, &options, sizeof(options_t));
  381. for(i = 0; i < (sizeof tabs/sizeof tabs[0]); i++) {
  383. TC_ITEM ti;
  385. ti.mask = TCIF_TEXT;
  386. ti.pszText = tabs[i].name;
  388. TabCtrl_InsertItem(tab, i, &ti);
  389. }
  391. hwndDisplay = CreateDialogParam(hInstance, tabs[0].rsrc, hDlg, tabs[0].dProc, (LPARAM)NULL);
  392. ShowWindow(hwndDisplay, SW_SHOW);
  394. return TRUE;
  395. }
  397. case WM_NOTIFY: {
  398. NMHDR *nm = (LPNMHDR)lParam;
  400. switch(nm->code) {
  401. case TCN_SELCHANGE:
  402. {
  403. int iTab = TabCtrl_GetCurSel(nm->hwndFrom);
  405. if (iTab>=0) {
  406. if (hwndDisplay) DestroyWindow(hwndDisplay);
  407. hwndDisplay = CreateDialogParam(hInstance, tabs[iTab].rsrc, hDlg, tabs[iTab].dProc, NULL);
  408. }
  410. ShowWindow(hwndDisplay, SW_SHOW);
  411. }
  412. return TRUE;
  413. }
  414. }break;
  417.   case WM_COMMAND:
  419.         switch (wParam)
  420. {
  421.   case IDC_PREFS_OK:
  423.   /*
  424.    * Save the options changes
  425.    */
  427.   memcpy(&options, &tmpOptions, sizeof(options_t));
  429.   /*
  430.    * And apply them
  431.    */
  433.   CheckMenuItem(popupMenu, (UINT)ID_BILINEAR,     options.use_bilinear ? MF_CHECKED : MF_UNCHECKED);
  434.   CheckMenuItem(popupMenu, (UINT)ID_ASPECT_RATIO, options.maintain_aspect_ratio ? MF_CHECKED : MF_UNCHECKED);
  435.   CheckMenuItem(popupMenu, (UINT)ID_LOOP, options.loop ? MF_CHECKED : MF_UNCHECKED);
  436.      CheckMenuItem(popupMenu, (UINT)ID_ON_TOP, options.on_top ? MF_CHECKED : MF_UNCHECKED);
  438.   playback->SetBilinear(options.use_bilinear);
  439.   playback->SetChangeFullscreenRes(options.change_fullscreen_res);
  440.   playback->SetLoop(options.loop);
  442.   /*
  443.    * And end the dialog
  444.    */
  445.   
  446.   EndDialog(hDlg, TRUE);
  447.   return TRUE;
  448.   break;
  450.   case IDC_PREFS_CANCEL:
  452.   EndDialog(hDlg, TRUE);
  453.   break;
  455.   default:
  456.   return 0;
  457. }
  458. break;
  461. case WM_DESTROY:
  462. return TRUE;
  463. }
  465. return FALSE;
  466. }
  468. /*******************************************************************************************/
  470. /*
  471.  * Properties dialog box message function
  472.  *
  473.  */
  475. int APIENTRY PropDlgProc (HWND hDlg, WORD wMsg, LONG wParam, LONG lParam)
  476. {
  477.   switch (wMsg)
  478.     {
  479.       case WM_INITDIALOG:
  481.   char freq[20];
  482.   char channels[2];
  483.   char video_size[20];
  484.   char duration[20];
  485.   char total_size[50];
  486.   DWORD time, hours, minutes, seconds;
  488.   _ultoa(playback->audioCodec->GetFormat()->nSamplesPerSec, freq, 10);
  489.   _ultoa(playback->audioCodec->GetFormat()->nChannels, channels, 10);
  491.   sprintf(video_size, "%dx%d", playback->decaps->Width(), playback->decaps->Height());
  492.   sprintf(total_size, "%d bytes", playback->decaps->input->getSize());
  494.   time = playback->decaps->TotalFrames()/playback->decaps->FrameRate();
  496.   hours   = time/3600;
  497.   minutes = (time - hours*3600)/60;
  498.   seconds = (time - hours*3600 - minutes*60)/60;
  500.   sprintf(duration, "%.2d:%.2d:%.2d", hours, minutes, seconds);
  502.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_FILENAME), playback->decaps->input->getFilename());
  503.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_FILE_TYPE), playback->decaps->input->http ? "HTTP Download" : "Local File.");
  504.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_FILE_SIZE), total_size);
  505.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_DURATION), duration);
  507.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_VIDEO_CODEC), playback->videoBuffer->codec->GetCodecName());
  508.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_VIDEO_SIZE), video_size);
  510.   switch(playback->videoBuffer->codec->GetVideoMode()) {
  512.   case VIDEO_MODE_RGB16:
  513.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_VIDEO_MODE), "16 bpp");
  514.   break;
  516.   case VIDEO_MODE_RGB24:
  517.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_VIDEO_MODE), "24 bpp");
  518.   break;
  520.   case VIDEO_MODE_RGB32:
  521.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_VIDEO_MODE), "32 bpp");
  522.   break;
  523.   }
  525.   if(playback->audioRenderer != NULL) {
  526.      
  527.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_AUDIO_CODEC), playback->audioCodec->GetCodecName());
  528.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_AUDIO_FREQUENCY), freq);
  529.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_AUDIO_CHANNELS), channels);
  530.   }
  531.   else {
  533.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_AUDIO_CODEC),     "Not Available");
  534.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_AUDIO_FREQUENCY), "Not Available");
  535.   SetWindowText(GetDlgItem(hDlg, IDC_STATIC_AUDIO_CHANNELS),  "Not Available");
  536.   }
  538.   return (0);
  539. break;
  541.       case WM_SYSCOMMAND:
  542.         if (wParam == SC_CLOSE)
  543.           {
  544.           EndDialog (hDlg, TRUE);
  545.           return (TRUE);
  546.           }
  547.         break;
  549.   case WM_COMMAND:
  551.         switch (wParam)
  552. {
  553.   case IDB_PROPERTIES_OK:
  555.   EndDialog(hDlg, TRUE);
  556.   return TRUE;
  557.   break;
  559.   default:
  560.   return 0;
  561. }
  562. break;
  563. }
  565.   return FALSE;
  566. }
  568. /*
  569.  * About dialog box message function
  570.  *
  571.  */
  573. int APIENTRY AboutDlgProc (HWND hDlg, WORD wMsg, LONG wParam, LONG lParam)
  574. {
  575.   int first = 0;
  577.   switch (wMsg)
  578.     {
  579.       case WM_INITDIALOG:
  580.         return (0);
  581. break;
  583.       case WM_SYSCOMMAND:
  584.         if (wParam == SC_CLOSE)
  585.           {
  586.           EndDialog (hDlg, TRUE);
  587.           return (TRUE);
  588.           }
  589.         break;
  591.   case WM_COMMAND:
  593.         switch (wParam)
  594. {
  595.   case IDB_ABOUT_OK:
  597.   EndDialog(hDlg, TRUE);
  598.   return TRUE;
  599.   break;
  601.   default:
  602.   return 0;
  603. }
  604. break;
  605. }
  607.   return FALSE;
  608. }
  610. /*
  611.  * Buffering dialog box message function
  612.  *
  613.  */
  615. DWORD WINAPI OpenHTTPThreadFunc( LPVOID lpData)
  616. {
  617. char *url;
  619. url = (char *) lpData;
  620. OpenFileForPlaying(hwnd, url, INPUT_TYPE_HTTP);
  622. return 0;
  623. }
  625. int APIENTRY BuffDlgProc (HWND hDlg, WORD wMsg, LONG wParam, LONG lParam)
  626. {
  627.   DWORD id = 0;
  629.   switch (wMsg)
  630.     {
  631.       case WM_INITDIALOG:
  633.   SetTimer(hDlg, 0xF8, 100, NULL);
  635.   urlW = hDlg;
  637.   return (0);
  638. break;
  640.       case WM_SYSCOMMAND:
  641.         if (wParam == SC_CLOSE)
  642.           {
  644. urlW = NULL;
  646.             EndDialog (hDlg, TRUE);
  647.             return (TRUE);
  648.           }
  649.         break;
  651.   case WM_COMMAND:
  653.         switch (wParam)
  654. {
  655.   case IDB_ABOUT_OK:
  657.   EndDialog(hDlg, TRUE);
  658.   return TRUE;
  659.   break;
  661.   default:
  662.   return 0;
  663. }
  664. break;
  666.   case WM_TIMER:
  668.   if(playback) {
  670.   DWORD progress = playback->GetBufferingState();
  672.   SendMessage(GetDlgItem(hDlg, IDC_PROGRESS), PBM_SETPOS, (WPARAM) progress, 0);
  674.   if(progress == 100) {
  676.   EndDialog(hDlg, TRUE);
  677.   return TRUE;
  678.   }
  679.   }
  681.   break;
  682. }
  684.   return FALSE;
  685. }
  688. /*
  689.  * Skin Browser Message Function
  690.  *
  691.  */
  693. int APIENTRY SkinBrowserDlgProc (HWND hDlg, WORD wMsg, LONG wParam, LONG lParam)
  694. {
  695.   int first = 0;
  697.   switch (wMsg)
  698.     {
  699.       case WM_INITDIALOG:
  701.   int nItem, i;
  702.   
  703.   /*
  704.    * Init the list of skins
  705.    */
  708.   SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_ADDSTRING, 0, (LONG) "[Default Skin]");
  709.   SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_SETCURSEL, 0, 0); 
  710.   
  711.   if(skinList->skinsDir != NULL) {
  713.   SendMessage(GetDlgItem(hDlg, IDC_COMBO_DIR), CB_ADDSTRING, 0, (LONG)skinList->skinsDir);
  714.       SendMessage(GetDlgItem(hDlg, IDC_COMBO_DIR), CB_SETCURSEL, 0, 0);
  715.   }
  717.   skinList->Scan();
  719.   for(i=0; i < skinList->getNumberOfSkins(); i++) {
  720.   
  721.   SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_ADDSTRING, 0, (LONG) skinList->getSkinInfo(i)->name);
  723.   if(strcmp(skinList->getSkinInfo(i)->directory, skinPath) == 0) {
  725.   SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_SETCURSEL, 0, 0); 
  726.   }
  727.   }
  729.   return (0);
  730. break;
  732.       case WM_SYSCOMMAND:
  733.         if (wParam == SC_CLOSE)
  734.           {
  735.           EndDialog (hDlg, TRUE);
  736.           return (TRUE);
  737.           }
  738.         break;
  740.   case WM_COMMAND:
  742.     switch (LOWORD(wParam))  {
  743.   
  744.           case IDC_SKIN_LIST: 
  745.               
  746.   switch (HIWORD(wParam)) { 
  747.                   
  748.   case LBN_SELCHANGE:
  749.   
  750.   int nItem;
  752.   nItem = SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_GETCURSEL, 0, 0); 
  754.   if(nItem < skinList->getNumberOfSkins()) {
  755.   
  756.   RECT rect;
  758.   skin->Load(skinList->getSkinInfo(nItem)->directory, hwnd);
  760.   strcpy(skinPath, skinList->getSkinInfo(nItem)->directory);
  762.   GetClientRect(hwnd, &rect);
  763.   InvalidateRect(hwnd, &rect, TRUE); 
  764.     UpdateWindow(hwnd);
  765.   }
  766.   else {
  767.   
  768.   RECT rect;
  770.   skin->LoadDefault(hInstance, hwnd);
  772.   strcpy(skinPath, "Default");
  774.   GetClientRect(hwnd, &rect);
  775.   InvalidateRect(hwnd, &rect, TRUE); 
  776.     UpdateWindow(hwnd);
  778.   }
  780.   break;
  781.   }
  782. }
  784.         switch (wParam)
  785. {
  786.   case IDB_SKINS_OK:
  788.   EndDialog(hDlg, TRUE);
  789.   return TRUE;
  790.   break;
  791.   
  792.   case ID_SKINS_CANCEL:
  794.   EndDialog(hDlg, TRUE);
  795.   return TRUE;
  796.   break;
  798.   case IDC_CHANGE_DIR:
  800.   dirChooser = new CDirDialog();
  802.   if(dirChooser->DoBrowse()) {
  804. skinList->SetDir(dirChooser->m_strPath);
  806. SendMessage(GetDlgItem(hDlg, IDC_COMBO_DIR), CB_RESETCONTENT, 0, 0);
  807. SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_RESETCONTENT, 0, 0);
  809. SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_ADDSTRING, 0, (LONG) "[Default Skin]");
  810. SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_SETCURSEL, 0, 0); 
  812. if(skinList->skinsDir != NULL) {
  814.   SendMessage(GetDlgItem(hDlg, IDC_COMBO_DIR), CB_ADDSTRING, 0, (LONG)skinList->skinsDir);
  815.       SendMessage(GetDlgItem(hDlg, IDC_COMBO_DIR), CB_SETCURSEL, 0, 0);
  816.   }
  818.   skinList->Scan();
  820.   for(i=0; i < skinList->getNumberOfSkins(); i++) {
  821.   
  822.   SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_ADDSTRING, 0, (LONG) skinList->getSkinInfo(i)->name);
  824.   if(strcmp(skinList->getSkinInfo(i)->directory, skinPath) == 0) {
  826.   SendMessage(GetDlgItem(hDlg, IDC_SKIN_LIST), LB_SETCURSEL, 0, 0); 
  827.   }
  828.   }
  830.   }
  831.   break;
  833.   default:
  834.   return 0;
  835. }
  836. break;
  837. }
  839.   return FALSE;
  840. }
  842. /*
  843.  * Open URL dialog box message function
  844.  *
  845.  */
  847. int APIENTRY UrlDlgProc (HWND hDlg, WORD wMsg, LONG wParam, LONG lParam)
  848. {
  850.   switch (wMsg)
  851.     {
  852.       case WM_INITDIALOG:
  854.   SendMessage(GetDlgItem(hDlg, IDC_RADIO_HTTP), BM_SETCHECK, BST_CHECKED, 0);
  856.   EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_USERNAME), FALSE);
  857.   EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_PASSWORD), FALSE);
  858.   EnableWindow(GetDlgItem(hDlg, IDC_CHECK_ANONYMOUS),     FALSE);
  859.   EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_SERVER),   FALSE);
  860.   EnableWindow(GetDlgItem(hDlg, IDC_COMBO_FTP),           FALSE);
  861.   EnableWindow(GetDlgItem(hDlg, IDC_EDIT_USERNAME),       FALSE);
  862.   EnableWindow(GetDlgItem(hDlg, IDC_EDIT_PASSWORD),       FALSE);
  864.   return (0);
  865. break;
  867.       case WM_SYSCOMMAND:
  869.         if (wParam == SC_CLOSE) {
  871.             EndDialog (hDlg, TRUE);
  872.             return (TRUE);
  873.         }
  874.         break;
  876.   case WM_COMMAND:
  878.         switch (wParam)
  879. {
  881. case IDC_RADIO_HTTP:
  883.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_USERNAME), FALSE);
  884.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_PASSWORD), FALSE);
  885.     EnableWindow(GetDlgItem(hDlg, IDC_CHECK_ANONYMOUS),     FALSE);
  886.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_SERVER),   FALSE);
  887.     EnableWindow(GetDlgItem(hDlg, IDC_COMBO_FTP),           FALSE);
  888.     EnableWindow(GetDlgItem(hDlg, IDC_EDIT_USERNAME),       FALSE);
  889.     EnableWindow(GetDlgItem(hDlg, IDC_EDIT_PASSWORD),       FALSE);
  891.     EnableWindow(GetDlgItem(hDlg, IDC_COMBO_HTTP),  TRUE);
  892.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_HTTP), TRUE);
  893. break;
  895. case IDC_RADIO_FTP:
  897.     EnableWindow(GetDlgItem(hDlg, IDC_CHECK_ANONYMOUS),     TRUE);
  898.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_SERVER),   TRUE);
  899.     EnableWindow(GetDlgItem(hDlg, IDC_COMBO_FTP),    TRUE);
  901.     EnableWindow(GetDlgItem(hDlg, IDC_COMBO_HTTP),  FALSE);
  902.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_HTTP), FALSE);
  904. anonymous = 1;
  905.     CheckDlgButton(hDlg, IDC_CHECK_ANONYMOUS, TRUE);
  906. break;
  908. case IDC_CHECK_ANONYMOUS:
  910. anonymous = anonymous ? 0 : 1;
  912. if(anonymous) {
  914.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_USERNAME), FALSE);
  915.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_PASSWORD), FALSE);
  916.     EnableWindow(GetDlgItem(hDlg, IDC_EDIT_USERNAME),       FALSE);
  917.     EnableWindow(GetDlgItem(hDlg, IDC_EDIT_PASSWORD),       FALSE);
  918. }
  919. else {
  921.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_USERNAME), TRUE);
  922.     EnableWindow(GetDlgItem(hDlg, IDC_STATIC_FTP_PASSWORD), TRUE);
  923.     EnableWindow(GetDlgItem(hDlg, IDC_EDIT_USERNAME),       TRUE);
  924.     EnableWindow(GetDlgItem(hDlg, IDC_EDIT_PASSWORD),       TRUE);
  925. }
  927. break;
  929. case IDB_URL_OK:
  931. DWORD http;
  932. EndDialog(hDlg, TRUE);
  934. if(SendMessage(GetDlgItem(hDlg, IDC_RADIO_HTTP), BM_GETCHECK, 0, 0) == BST_CHECKED) {
  936. char  *url;
  937. DWORD id, size;
  939. /*
  940.  * HTTP
  941.  */
  943. url = (char *) malloc(256);
  945. size = SendMessage(GetDlgItem(hDlg, IDC_COMBO_HTTP), EM_GETLINE, 0, (LONG)(LPVOID)url);
  946. *(url + size) = '';
  948. if(strstr(url, "http://") != NULL) {
  950. CreateThread( NULL, 0, OpenHTTPThreadFunc, (LPVOID) url, 0, &id );
  952. DialogBox (hInstance, (LPCSTR)MAKEINTRESOURCE(IDD_BUFFERING),
  953.       hwnd, (DLGPROC)BuffDlgProc);
  955. return 0;
  956. }
  957. }
  958. else {
  960. char  *url;
  961. DWORD id, size;
  963. /*
  964.  * FTP
  965.  */
  967. url = (char *) malloc(256);
  969. size = SendMessage(GetDlgItem(hDlg, IDC_COMBO_FTP), EM_GETLINE, 0, (LONG)(LPVOID)url);
  970. *(url + size) = '';
  972. if(strstr(url, "ftp://") != NULL) {
  974. if(anonymous) {
  976. CreateThread( NULL, 0, OpenHTTPThreadFunc, (LPVOID) url, 0, &id );
  978. DialogBox (hInstance, (LPCSTR)MAKEINTRESOURCE(IDD_BUFFERING),
  979.       hwnd, (DLGPROC)BuffDlgProc);
  981. return 0;
  982. }
  983. else {
  985. /*
  986.  * Not implemented yet.
  987.  *
  988.  */
  990. }
  991. }
  992. }
  993.   
  994. return TRUE;
  995. break;
  997. case IDB_URL_CANCEL:
  999. EndDialog(hDlg, TRUE);
  1000. return TRUE;
  1001. break;
  1003. default:
  1004.   return 0;
  1005. }
  1006. break;
  1007. }
  1009.   return FALSE;
  1010. }
  1012. /*
  1013.  * Main function
  1014.  */
  1016. int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow)
  1017. { 
  1018. POINT pt;
  1019.     MSG Msg;
  1020.     WNDCLASS W;
  1021. DWORD i;
  1023. hInstance = hInst;
  1025. oldPt.x = 0;
  1026. oldPt.y = 0;
  1027. showing_cursor = 1;
  1029. /*
  1030.  * Open the log file
  1031.  */
  1033. #ifdef _DEBUG_
  1035. debug_file = fopen("c:\playa.txt", "wt");
  1037. #endif
  1039. /*
  1040.  * Load the options
  1041.  *
  1042.  */
  1044.     strcpy(skinPath, "Default");
  1045. LoadOptions();
  1047. /*
  1048.      * init the video subsystem 
  1049.      *
  1050.      */
  1052.    playback = new Playback();
  1053.    playlist = new Playlist();
  1054.    skinList = new SkinList();
  1055.    resizer  = new Resizer();
  1057.    playback->SetLoop(options.loop);
  1059.    clientRect.left   = 0;
  1060.    clientRect.right  = DEFAULT_SKIN_WIDTH;
  1061.    clientRect.top    = 0;
  1062.    clientRect.bottom = DEFAULT_SKIN_HEIGHT;
  1063.    
  1064.    windowRect.left   = 0;
  1065.    windowRect.right  = DEFAULT_SKIN_WIDTH;
  1066.    windowRect.top    = 0;
  1067.    windowRect.bottom = DEFAULT_SKIN_HEIGHT;
  1069.    AdjustWindowRect(&windowRect, WS_OVERLAPPEDWINDOW, 0);
  1072.    /*
  1073.     * Window Class
  1074.     */
  1076.    memset(&W, 0, sizeof(WNDCLASS));
  1077.    
  1078.    W.style         = CS_HREDRAW | CS_VREDRAW | CS_PARENTDC;
  1079.    W.lpfnWndProc   = WndProc;
  1080.    W.hInstance     = hInst;
  1081.    W.hbrBackground = (HBRUSH)(0);
  1082.    W.hCursor       = LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURSOR1));
  1083.    W.hIcon         = LoadIcon(hInst, MAKEINTRESOURCE(IDB_ICON));
  1084.    W.lpszClassName = Name;
  1085.    W.lpszMenuName  = NULL;
  1088.    RegisterClass(&W);
  1090.    /*
  1091.     * Load the menu and change 
  1092. * it for recent file list
  1093.     */
  1095.    HMENU             menu;
  1096.    MENUITEMINFO itemInfo;
  1098.    popupMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_MENU1));
  1100.    menu = GetSubMenu(popupMenu, 0);
  1101.    menu = GetSubMenu(menu, 5);
  1102.    
  1103.    if(RecentFiles[0] != NULL) {
  1105.    RemoveMenu(menu, 0, MF_BYPOSITION);
  1106.    
  1107. /*
  1108.  * Now add the files
  1109.  */
  1110.    
  1111.    for(i=0; i < 5; i++) {
  1112.    
  1113.    if(RecentFiles[i] != NULL) {
  1115.    itemInfo.cbSize = sizeof(MENUITEMINFO);
  1116.    itemInfo.fMask  = MIIM_DATA | MIIM_TYPE | MIIM_ID;
  1117.    itemInfo.fType  = MFT_STRING;
  1118.    itemInfo.dwTypeData = RecentFiles[i];
  1119.    itemInfo.cch = strlen(RecentFiles[i]);
  1120.    itemInfo.wID = ID_RECENT_FILE1 + i;
  1121.    
  1122.    InsertMenuItem(menu, GetMenuItemCount(menu), TRUE, &itemInfo);
  1123. }
  1124.    }
  1125.    }
  1128.    /*
  1129.     * Create the main window
  1130.     *
  1131.     */
  1133.    hwnd = CreateWindow( Name, Name, WS_OVERLAPPEDWINDOW, 100, 30, 
  1134. windowRect.right - windowRect.left, 
  1135. windowRect.bottom - windowRect.top, 
  1136. NULL, NULL, hInst, NULL);
  1137.    
  1138.    /*
  1139.     * Set the window Rgn
  1140.     *
  1141.     */
  1143. GetClientRect(hwnd, &clientRect);
  1144. GetWindowRect(hwnd, &windowRect);
  1146. pt.x = clientRect.left;
  1147. pt.y = clientRect.top;
  1149. ClientToScreen(hwnd, &pt);
  1151. pt2.x = clientRect.right;
  1152. pt2.y = clientRect.bottom;
  1154. ClientToScreen(hwnd, &pt2);
  1156. SetWindowRgn(hwnd, CreateRectRgn( pt.x  - windowRect.left, 
  1157.      pt.y  - windowRect.top,
  1158.   (windowRect.right - windowRect.left) - (windowRect.right - pt2.x),
  1159.   (windowRect.bottom - windowRect.top) - (windowRect.bottom - pt2.y)), TRUE); 
  1160.    /*
  1161.     * Register for Drag n' Drop
  1162.     */
  1164.    DragAcceptFiles(hwnd, TRUE);
  1166.    /*
  1167.     * And Start TIMER
  1168.     *
  1169.     */
  1171. SetTimer(hwnd, TIMER_ID, TIMER_RATE, NULL);
  1173. /*
  1174.  * Load Accelerators
  1175.  */
  1177. hAccel = LoadAccelerators(hInst, MAKEINTRESOURCE(IDR_ACCELERATOR));
  1179. /*
  1180.  * Set the icon
  1181.  */
  1183. SetClassLong(hwnd, GCL_HICON, (LONG) LoadIcon(hInst, MAKEINTRESOURCE(IDB_ICON))); 
  1184.  
  1185. /*
  1186.  * Menu items 
  1187.  */
  1189. CheckMenuItem(popupMenu, (UINT)ID_BILINEAR,     options.use_bilinear ? MF_CHECKED : MF_UNCHECKED);
  1190. CheckMenuItem(popupMenu, (UINT)ID_ASPECT_RATIO, options.maintain_aspect_ratio ? MF_CHECKED : MF_UNCHECKED);
  1191. CheckMenuItem(popupMenu, (UINT)ID_LOOP, options.loop ? MF_CHECKED : MF_UNCHECKED);
  1192. CheckMenuItem(popupMenu, (UINT)ID_ON_TOP, options.on_top ? MF_CHECKED : MF_UNCHECKED);
  1194.    /*
  1195.     * Loads the skin
  1196.     *
  1197.     */
  1199.    skin = new Skin(hInst, hwnd);
  1201.    if(strcmp(skinPath, "Default") == 0) {
  1203.    skin->LoadDefault(hInst, hwnd);
  1204.    }
  1205.    else {
  1207.    skin->Load(skinPath, hwnd);
  1208.    }
  1210.    /*
  1211.     * now The buttons
  1212.     */
  1214. ShowWindow(hwnd, nCmdShow);
  1215. UpdateWindow(hwnd);
  1217. GetWindowRect(hwnd, &windowRect);
  1219. if(options.on_top)
  1220. SetWindowPos(hwnd, (HWND) -1,  windowRect.left, windowRect.top, windowRect.right - windowRect.left, windowRect.bottom - windowRect.top, TRUE);
  1222.    while (TRUE)
  1223.     {
  1225.    /*
  1226. * Get the messages
  1227. */
  1229.    if (!GetMessage(&Msg, NULL, 0, 0))
  1230. return (int) Msg.wParam;
  1232. if (!TranslateAccelerator(hwnd, hAccel, &Msg)) {
  1234. TranslateMessage(&Msg); 
  1235. DispatchMessage(&Msg); 
  1236. } 
  1237. else {
  1238.            
  1239. TranslateMessage(&Msg);
  1240.        DispatchMessage(&Msg);
  1241. }
  1242.    }
  1244.    return Msg.wParam;
  1245. }
  1247. /*
  1248.  * Opens a specified file for playing
  1249.  */
  1251. void OpenFileForPlaying(HWND hwnd, char *filename, int type) {
  1253. skin->Display(hwnd, playback);
  1255. RECT rect, windowrect;
  1257. playback->Close();
  1259. if(playback->Open(filename, type, hwnd)) {
  1261. /*
  1262.  * First resize the window
  1263.  */
  1266. if(playback->OK()) {
  1268. DWORD i;
  1270. GetWindowRect(hwnd, &windowrect); 
  1271. rect.left   = windowrect.left;
  1272. rect.top    = windowrect.top;
  1273. rect.right  = playback->Width() + 15;
  1274. rect.bottom = playback->Height() + 115 + 22 + (playback->has_subtitles && use_subtitles ? 50 : 0);
  1276. MoveWindow( hwnd, rect.left, rect.top, rect.right, rect.bottom, TRUE);
  1278. /*
  1279.  * Update flags
  1280.  */
  1282. playback->SetBilinear(options.use_bilinear);
  1283. playback->SetChangeFullscreenRes(options.change_fullscreen_res);
  1284. playback->SetUseSubtitles(use_subtitles);
  1286. /*
  1287.  * Update recent file list
  1288.  */
  1290. DWORD insert = 1;
  1292. for(i=0; i < 5; i++) {
  1294. if(RecentFiles[i] != NULL && strcmp(RecentFiles[i], filename) == 0) {
  1295. insert = 0;
  1296. }
  1297. }
  1299. if(insert && strstr(filename, "http://") == NULL && strstr(filename, "ftp://") == NULL) {
  1301. for(i=4; i > 0; i--) {
  1303. RecentFiles[i] = RecentFiles[i - 1];
  1304. }
  1306. RecentFiles[0] = (char *) malloc(strlen(filename) + 1);
  1307. strncpy(RecentFiles[0], filename, strlen(filename));
  1308. RecentFiles[0][strlen(filename)] = '';
  1309. }
  1311. /*
  1312.  * And update the menu
  1313.  */
  1315. HMENU menu, sub;
  1317. menu = GetSubMenu(popupMenu, 0);
  1319. /*
  1320.  * The subtitles and Properties menus
  1321.  */
  1323. EnableMenuItem(menu, (UINT)ID_PROPERTIES, MF_ENABLED);
  1325. if(playback->has_subtitles) {
  1327. sub = GetSubMenu(menu, 17);
  1328. RemoveMenu(sub, 0, MF_BYPOSITION);
  1330. MENUITEMINFO subitemInfo;
  1332.     subitemInfo.cbSize = sizeof(MENUITEMINFO);
  1333. subitemInfo.fMask  = MIIM_DATA | MIIM_TYPE | MIIM_ID;
  1334. subitemInfo.fType  = MFT_STRING;
  1335. subitemInfo.dwTypeData = "Use Subtitles";
  1336. subitemInfo.cch = 13;
  1337. subitemInfo.wID = ID_SUBTITLES;
  1338.    
  1339.     InsertMenuItem(sub, 0, TRUE, &subitemInfo);
  1340.     CheckMenuItem(sub, (UINT)ID_SUBTITLES, use_subtitles ? MF_CHECKED : MF_UNCHECKED);
  1341. }
  1342. else {
  1344. sub = GetSubMenu(menu, 17);
  1345. RemoveMenu(sub, 0, MF_BYPOSITION);
  1347. MENUITEMINFO subitemInfo;
  1349.     subitemInfo.cbSize = sizeof(MENUITEMINFO);
  1350. subitemInfo.fMask  = MIIM_DATA | MIIM_TYPE | MIIM_ID;
  1351. subitemInfo.fType  = MFT_STRING;
  1352. subitemInfo.dwTypeData = "None Available";
  1353. subitemInfo.cch = 14;
  1354. subitemInfo.wID = ID_NONE_SUB;
  1355.    
  1356.     InsertMenuItem(sub, 0, TRUE, &subitemInfo);
  1357. EnableMenuItem(sub, (UINT)ID_NONE_SUB, MF_GRAYED);
  1358. }
  1361. /*
  1362.  * And the recent file list
  1363.  */
  1365. menu = GetSubMenu(menu, 5);
  1367. if(RecentFiles[0] != NULL) {
  1369. DWORD count;
  1370. MENUITEMINFO itemInfo;
  1372. count = GetMenuItemCount(menu);
  1374. for(i=0; i < count; i++) {
  1376. RemoveMenu(menu, 0, MF_BYPOSITION);
  1377. }
  1379. /*
  1380.  * Now add the files
  1381.  */
  1382.    
  1383.     for(i=0; i < 5; i++) {
  1384.    
  1385.    if(RecentFiles[i] != NULL) {
  1387.   itemInfo.cbSize = sizeof(MENUITEMINFO);
  1388.   itemInfo.fMask  = MIIM_DATA | MIIM_TYPE | MIIM_ID;
  1389.   itemInfo.fType  = MFT_STRING;
  1390.   itemInfo.dwTypeData = RecentFiles[i];
  1391.   itemInfo.cch = strlen(RecentFiles[i]);
  1392.   itemInfo.wID = ID_RECENT_FILE1 + i;
  1393.    
  1394.   InsertMenuItem(menu, GetMenuItemCount(menu), TRUE, &itemInfo);
  1395.    }
  1396.    }
  1397. }
  1399. /*
  1400.    * Then play
  1401.  */
  1403. playback->Play();
  1404. }
  1405. }
  1406. else {
  1408. /*
  1409.  * File couldn't be opened
  1410.  * so we may have to close the
  1411.  * buffering window...
  1412.  */
  1414. if(urlW != NULL) {
  1415. EndDialog(urlW, 0);
  1416. urlW = NULL;
  1417. }
  1419. MessageBox(NULL, "The location you selected could not be opened", "Error", MB_OK);
  1420. }
  1421. }
  1423. /*
  1424.  * Opens a file:
  1425.  */
  1427. void fileOpen(HWND hwnd)
  1428. {
  1429. OPENFILENAME ofn;
  1430. char szFile[260];
  1432. /*
  1433.  * shows a file selector
  1434.  */
  1436. ZeroMemory(&ofn, sizeof(OPENFILENAME));
  1437.     ZeroMemory(szFile, 260);
  1439. ofn.lStructSize = sizeof(OPENFILENAME);
  1440. ofn.hwndOwner = hwnd;
  1441. ofn.lpstrFile = szFile;
  1442. ofn.nMaxFile = sizeof(szFile);
  1444. ofn.lpstrFilter = "All*.*AVI Files*.AVI";
  1445. ofn.nFilterIndex = 2;
  1446. ofn.lpstrFileTitle = "";
  1447. ofn.nMaxFileTitle = 0;
  1448. ofn.lpstrInitialDir = NULL;
  1449. ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
  1451. if (GetOpenFileName(&ofn) == TRUE) {
  1453. OpenFileForPlaying(hwnd, ofn.lpstrFile, INPUT_TYPE_FILE);
  1454. }
  1455. }
  1457. /*
  1458.  * Handles events
  1459.  */
  1461. LRESULT CALLBACK WndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
  1462. { 
  1463. int xPos, yPos;
  1465. switch(Message) {
  1467. case WM_DESTROY:
  1469. #ifdef _DEBUG__
  1470. fclose(debug_file);
  1471. #endif
  1472. SaveOptions();
  1473. playback->Close();
  1475. Cleanup();
  1477. PostQuitMessage(0);
  1478. return TRUE;
  1479. break;
  1481. case WM_SYSCOMMAND:
  1482.         
  1483. if (wParam == SC_CLOSE)
  1484.           {
  1485. #ifdef _DEBUG__
  1486. fclose(debug_file);
  1487. #endif
  1488. SaveOptions();
  1489. playback->Close();
  1491. Cleanup();
  1493. PostQuitMessage(0);
  1494. return (TRUE);
  1495.           }
  1496.         break;
  1498. case WM_COMMAND :
  1499.     
  1500. switch(LOWORD(wParam)) {
  1502. case ID_SUBTITLES:
  1504. RECT  wrect;
  1505. HMENU menu;
  1507. menu = GetSubMenu(popupMenu, 0);
  1508. menu = GetSubMenu(menu, 17);
  1510. if(playback != NULL) {
  1512. GetWindowRect(hwnd, &wrect);
  1514. if(use_subtitles) {
  1516. use_subtitles = 0;
  1517. wrect.bottom -= 50;
  1519. MoveWindow(hwnd, wrect.left, wrect.top, wrect.right - wrect.left, wrect.bottom - wrect.top, TRUE);
  1520. CheckMenuItem(menu, (UINT)ID_SUBTITLES, MF_UNCHECKED);
  1522. playback->SetUseSubtitles(use_subtitles);
  1523. }
  1524. else {
  1526. use_subtitles = 1;
  1527. wrect.bottom += 50;
  1529. CheckMenuItem(menu, (UINT)ID_SUBTITLES, MF_CHECKED);
  1530. MoveWindow(hwnd, wrect.left, wrect.top, wrect.right - wrect.left, wrect.bottom - wrect.top, TRUE);
  1532. playback->SetUseSubtitles(use_subtitles);
  1533. }
  1534. }
  1536. break;
  1538. case ID_RECENT_FILE1:
  1540. OpenFileForPlaying(hwnd, RecentFiles[0], INPUT_TYPE_FILE);
  1541. break;
  1543. case ID_RECENT_FILE2:
  1545. OpenFileForPlaying(hwnd, RecentFiles[1], INPUT_TYPE_FILE);
  1546. break;
  1548. case ID_RECENT_FILE3:
  1550. OpenFileForPlaying(hwnd, RecentFiles[2], INPUT_TYPE_FILE);
  1551. break;
  1553. case ID_RECENT_FILE4:
  1555. OpenFileForPlaying(hwnd, RecentFiles[3], INPUT_TYPE_FILE);
  1556. break;
  1558. case ID_RECENT_FILE5:
  1560. OpenFileForPlaying(hwnd, RecentFiles[4], INPUT_TYPE_FILE);
  1561. break;
  1563. case ID_MENU_ABOUT:
  1565.             DialogBox (hInstance, (LPCSTR)MAKEINTRESOURCE(IDD_ABOUT_DIALOG),
  1566.                         hwnd, (DLGPROC)AboutDlgProc);
  1568. break;
  1570. case ID_SKIN_BROWSER:
  1572.             DialogBox (hInstance, (LPCSTR)MAKEINTRESOURCE(IDD_SKIN_BROWSER),
  1573.                              hwnd, (DLGPROC)SkinBrowserDlgProc);
  1575. break;
  1577. case ID_MENU_OPTIONS:
  1579.             DialogBox (hInstance, (LPCSTR)MAKEINTRESOURCE(IDD_PREFS),
  1580.                              hwnd, (DLGPROC)PreferencesDlgProc);
  1581. break;
  1583. case ID_OPEN_URL:
  1585.             DialogBox (hInstance, (LPCSTR)MAKEINTRESOURCE(IDD_URL_DIALOG),
  1586.                              hwnd, (DLGPROC)UrlDlgProc);
  1587. break;
  1589. case ID_PROPERTIES:
  1591. DialogBox (hInstance, (LPCSTR)MAKEINTRESOURCE(IDD_PROPERTIES),
  1592.                        hwnd, (DLGPROC)PropDlgProc);
  1593. break;
  1595. case ID_OPEN_FILE:
  1596. fileOpen(hwnd);
  1597. break;
  1599. case ID_ON_TOP:
  1601. RECT r;
  1603. options.on_top = options.on_top == 1 ? 0 : 1;
  1604. CheckMenuItem(popupMenu, (UINT)wParam, options.on_top ? MF_CHECKED : MF_UNCHECKED);
  1606. GetWindowRect(hwnd, &r);
  1608. SetWindowPos(hwnd, options.on_top ? (HWND) -1 : (HWND) 1,  r.left, r.top, r.right - r.left, r.bottom - r.top, TRUE);
  1610. if(!options.on_top)
  1611. SetWindowPos(hwnd, HWND_TOP,  r.left, r.top, r.right - r.left, r.bottom - r.top, TRUE);
  1613. break;
  1615. case ID_LOOP:
  1617. options.loop = options.loop == 1 ? 0 : 1;
  1618. CheckMenuItem(popupMenu, (UINT)wParam, options.loop ? MF_CHECKED : MF_UNCHECKED);
  1620. playback->SetLoop(options.loop);
  1622. break;
  1624. case ID_PREVIOUS:
  1626. playback->Rewind();
  1627. break;
  1629. case ID_STOP:
  1631. playback->Stop(TRUE);
  1632. break;
  1634. case ID_PLAY:
  1636. if(playback->OK()) {
  1638. if(playback->isPaused()) {
  1639. playback->Pause();
  1640. }
  1641. else {
  1642. playback->Play();
  1643. }
  1644. }
  1645. else {
  1647. /*
  1648.  * Load files
  1649.  */
  1651. fileOpen(hwnd);
  1652. }
  1654. break;
  1656. case ID_PAUSE:
  1658. if(playback->OK()) {
  1660. playback->Pause();
  1661. }
  1663. break;
  1665. case ID_NEXT:
  1667. playback->FastForward();
  1668. break;
  1671. case ID_EXIT:
  1673. SaveOptions();
  1674.     DestroyWindow(hwnd);
  1675. break;
  1677. case ID_FULLSCREEN:
  1679. GetWindowRect(hwnd, &fullwindowRect);
  1681. count          = 0;
  1682. showing_cursor = 1;
  1684. playback->SetChangeFullscreenRes(options.change_fullscreen_res);
  1685. playback->Fullscreen(TRUE);
  1686. break;
  1688. case ID_ORIGINAL_SIZE:
  1690. if(playback->isPlaying()) {
  1692. RECT src;
  1694. GetWindowRect(hwnd, &windowRect);
  1696. src.left    = 0;
  1697. src.right   = playback->Width() + 7;
  1698. src.top     = 0;
  1699. src.bottom  = playback->Height() + 110;
  1701. AdjustWindowRect(&src, WS_OVERLAPPEDWINDOW, 0);
  1703. MoveWindow( hwnd, windowRect.left, 
  1704. windowRect.top, 
  1705. src.right - src.left, 
  1706. src.bottom - src.top, TRUE);
  1707. }
  1708. break;
  1710. case ID_HALF_SIZE:
  1712. if(playback->isPlaying()) {
  1714. RECT src;
  1716. GetWindowRect(hwnd, &windowRect);
  1718. src.left    = 0;
  1719. src.right   = playback->Width()/2 + 7;
  1720. src.top     = 0;
  1721. src.bottom  = playback->Height()/2 + 110;
  1723. AdjustWindowRect(&src, WS_OVERLAPPEDWINDOW, 0);
  1725. MoveWindow( hwnd, windowRect.left, 
  1726. windowRect.top, 
  1727. src.right - src.left, 
  1728. src.bottom - src.top, TRUE);
  1729. }
  1730. break;
  1732. case ID_DOUBLE_SIZE:
  1734. if(playback->isPlaying()) {
  1736. RECT src;
  1738. GetWindowRect(hwnd, &windowRect);
  1740. src.left    = 0;
  1741. src.right   = playback->Width()*2 + 7;
  1742. src.top     = 0;
  1743. src.bottom  = playback->Height()*2 + 110;
  1745. AdjustWindowRect(&src, WS_OVERLAPPEDWINDOW, 0);
  1747. MoveWindow( hwnd, windowRect.left, 
  1748. windowRect.top, 
  1749. src.right - src.left, 
  1750. src.bottom - src.top, TRUE);
  1751. }
  1752. break;
  1754. case ID_BILINEAR:
  1756. options.use_bilinear = options.use_bilinear == 1 ? 0 : 1;
  1757. CheckMenuItem(popupMenu, (UINT)wParam, options.use_bilinear ? MF_CHECKED : MF_UNCHECKED);
  1759. playback->SetBilinear(options.use_bilinear);
  1761. break;
  1763. case ID_ASPECT_RATIO:
  1765. options.maintain_aspect_ratio = options.maintain_aspect_ratio == 1 ? 0 : 1;
  1766. CheckMenuItem(popupMenu, (UINT)wParam, options.maintain_aspect_ratio ? MF_CHECKED : MF_UNCHECKED);
  1767. break;
  1768. }
  1769. break;
  1771. /*
  1772.  * Timer
  1773.  *
  1774.  */
  1776. case WM_TIMER:
  1778. if(playback && playback->isPlaying() && !playback->fullscreen) {
  1780. if(action != ACTION_PROGRESS_CURSOR) {
  1781. skin->SetProgressValue(hwnd, playback->GetProgress());
  1782. }
  1784. /*
  1785.  * Do time display here
  1786.  */
  1787. }
  1789. if(playback->isInFullscreen() && showing_cursor) {
  1791. count++;
  1793. /*
  1794.  * We wait for 2 secs
  1795.  */ 
  1797. if(count >= 20) {
  1799. ShowCursor(0);
  1800. showing_cursor = 0;
  1801. }
  1802. }
  1805. break;
  1807. /*
  1808.  * Key Press
  1809.  *
  1810.  */
  1812. case WM_KEYUP:
  1814. switch(wParam) {
  1816. case VK_ESCAPE:
  1818. if(playback->fullscreen) {
  1820. RECT rect;
  1822. playback->Fullscreen(FALSE);
  1823. ShowCursor(1);
  1825. /*
  1826.  * We need to resize the window to it's original size
  1827.  */
  1829. MoveWindow(hwnd, fullwindowRect.left, fullwindowRect.top, fullwindowRect.right - fullwindowRect.left, 
  1830.    fullwindowRect.bottom - fullwindowRect.top, TRUE);
  1832. GetClientRect(hwnd, &rect);
  1833. InvalidateRect(hwnd, &rect, TRUE); 
  1834.   UpdateWindow(hwnd);
  1836. Sleep(100);
  1838. GetClientRect(hwnd, &rect);
  1839. InvalidateRect(hwnd, &rect, TRUE); 
  1840.   UpdateWindow(hwnd);
  1841. }
  1842. break;
  1844. default:
  1845. break;
  1846. }
  1847. break;
  1849. case WM_LBUTTONDOWN:
  1851. xPos = LOWORD(lParam); 
  1852. yPos = HIWORD(lParam);
  1854. action = skin->GetAction(xPos, yPos);
  1855. skin->SetActionStart(hwnd, action);
  1857. if(action == ACTION_RESIZE) {
  1859. POINT pt;
  1861. pt.x = xPos;
  1862. pt.y = yPos;
  1864. ClientToScreen(hwnd, &pt);
  1866. moveX = pt.x;
  1867. moveY = pt.y;
  1869. GetWindowRect(hwnd, &windowRect);
  1871. SetCapture(hwnd);
  1873. resizer->Start(&pt);
  1874. }
  1876. if(action == ACTION_NONE) {
  1878. /*
  1879.  * We are moving the window
  1880.  */
  1882. action = ACTION_MOVING;
  1884. moveX = xPos;
  1885. moveY = yPos;
  1887. GetWindowRect(hwnd, &windowRect);
  1889. SetCapture(hwnd);
  1891. if(!playback->isPaused())
  1892. playback->Pause();
  1893. }
  1895. if(action == ACTION_VOLUME_CURSOR || action == ACTION_PROGRESS_CURSOR) {
  1897. moveX = xPos;
  1898. }
  1900. break;
  1902. case WM_LBUTTONUP:
  1904. skin->SetActionEnd(hwnd, action);
  1906. switch(action) {
  1908. case ACTION_MENU:
  1910. HMENU menu;
  1912. POINT pt;
  1914. pt.x = pt.y = 0;
  1915. ClientToScreen(hwnd, &pt);
  1917. xPos = pt.x + LOWORD(lParam); 
  1918. yPos = pt.y + HIWORD(lParam);
  1920. menu = GetSubMenu(popupMenu, 0);
  1922. TrackPopupMenu( menu, 0, xPos, yPos, 0, hwnd, NULL);
  1923. break;
  1925. case ACTION_CLOSE:
  1927. SaveOptions();
  1929. PostQuitMessage(0);
  1930. break;
  1932. case ACTION_MINIMIZE:
  1934. ShowWindow(hwnd, SW_MINIMIZE);
  1935. break;
  1937. case ACTION_STOP:
  1939. playback->Stop(TRUE);
  1940. break;
  1942. case ACTION_PLAY:
  1944. if(playback->OK()) {
  1946. if(playback->isPaused()) {
  1947. playback->Pause();
  1948. }
  1949. else {
  1950. playback->Play();
  1951. }
  1952. }
  1953. else {
  1955. /*
  1956.  * Load files
  1957.  */
  1959. fileOpen(hwnd);
  1960. }
  1961. break;
  1963. case ACTION_PAUSE:
  1965. if(playback->OK()) {
  1967. if(playback->isPaused()) {
  1969. playback->NextFrame();
  1970. }
  1971. else {
  1972. playback->Pause();
  1973. }
  1974. }
  1975. break;
  1977. case ACTION_FORWARD:
  1979. playback->FastForward();
  1980. break;
  1982. case ACTION_REWIND:
  1984. playback->Rewind();
  1985. break;
  1987. case ACTION_LOAD:
  1988. {
  1989. fileOpen(hwnd);
  1990. }
  1991. break;
  1993. case ACTION_PROGRESS_CURSOR:
  1995. playback->Seek(skin->GetProgress());
  1996. break;
  1998. case ACTION_VOLUME_CURSOR:
  2000. playback->SetVolume(skin->GetVolume());
  2001. break;
  2003. case ACTION_VOLUME_BAR:
  2005. moveX = LOWORD(lParam); 
  2006. skin->SetVolumeCursorX(hwnd, moveX);
  2008. playback->SetVolume(skin->GetVolume());
  2010. break;
  2012. case ACTION_PROGRESS_BAR:
  2014. moveX = LOWORD(lParam); 
  2015. skin->SetProgressCursorX(hwnd, moveX);
  2016. playback->Seek(skin->GetProgress());
  2017. break;
  2019. case ACTION_NONE:
  2020. default:
  2021. break;
  2022. }
  2024. if(action == ACTION_MOVING) {
  2026. ReleaseCapture();
  2027. RECT rect;
  2029. GetWindowRect(hwnd, &rect);
  2031. SetWindowPos(hwnd, HWND_TOPMOST, rect.left, rect.top, 
  2032.  rect.right - rect.left, rect.bottom - rect.top, 
  2033.  SWP_SHOWWINDOW | SWP_NOZORDER | SWP_NOACTIVATE);
  2035. if(playback->isPaused())
  2036. playback->Pause();
  2038. if(playback->isPlaying()) {
  2040. GetClientRect(hwnd, &rect);
  2041. InvalidateRect(hwnd, &rect, TRUE); 
  2042.   UpdateWindow(hwnd);
  2043. }
  2044. }
  2046. if(action == ACTION_RESIZE) {
  2048. POINT pt;
  2050. ReleaseCapture();
  2051. resizer->Stop();
  2053. xPos = LOWORD(lParam);
  2054. yPos = HIWORD(lParam);
  2056. pt.x = xPos;
  2057. pt.y = yPos;
  2059. if(xPos > 32768 || yPos > 32768)
  2060. return 0;
  2062. ClientToScreen(hwnd, &pt);
  2064. if(windowRect.right + (pt.x - moveX) - windowRect.left >= skin->DefaultWidth() &&
  2065.    windowRect.bottom + (pt.y - moveY) - windowRect.top >= skin->DefaultHeight()) {
  2067. MoveWindow( hwnd, windowRect.left, 
  2068. windowRect.top, 
  2069. windowRect.right + (pt.x - moveX) - windowRect.left, 
  2070. windowRect.bottom + (pt.y - moveY) - windowRect.top, TRUE);
  2072. }
  2073. else {
  2075. RECT r;
  2077. r.left   = 0;
  2078. r.right  = DEFAULT_SKIN_WIDTH;
  2079. r.top    = 0;
  2080. r.bottom = DEFAULT_SKIN_HEIGHT;
  2082. AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
  2084. if(windowRect.right + (pt.x - moveX) - windowRect.left >= skin->DefaultWidth()) {
  2086. MoveWindow( hwnd, windowRect.left, 
  2087. windowRect.top, 
  2088. windowRect.right + (pt.x - moveX) - windowRect.left, 
  2089. r.bottom - r.top + 2, TRUE);
  2091. }
  2092. else {
  2094. if(windowRect.bottom + (pt.y - moveY) - windowRect.top >= skin->DefaultHeight()) {
  2096. MoveWindow( hwnd, windowRect.left, 
  2097. windowRect.top, 
  2098. r.right - r.left + 2, 
  2099. windowRect.bottom + (pt.y - moveY) - windowRect.top, TRUE);
  2100. }
  2101. else {
  2103. MoveWindow( hwnd, windowRect.left, 
  2104. windowRect.top, 
  2105. r.right - r.left + 2, 
  2106. r.bottom - r.top + 2, TRUE);
  2107. }
  2108. }
  2109. }
  2111. moveX = pt.x;
  2112. moveY = pt.y;
  2113. }
  2115. action = ACTION_NONE;
  2117. break;
  2119. case WM_MOUSEMOVE:
  2121. count = 0;
  2123. if(playback->isInFullscreen() && !showing_cursor) {
  2125. ShowCursor(1);
  2126. showing_cursor = 1;
  2127. }
  2129. if(action == ACTION_MOVING) {
  2131. RECT   r;
  2132. POINT pt;
  2134. xPos = LOWORD(lParam); 
  2135. yPos = HIWORD(lParam);
  2137. GetClientRect(hwnd, &r);
  2139. if(xPos > 16768) {
  2141. xPos = 1;
  2142. }
  2143. else {
  2144. if(xPos >= (r.right - r.left))
  2145. xPos = r.right - r.left - 1;
  2146. }
  2148. if(yPos > 16768) {
  2150. yPos = 1;
  2151. }
  2152. else {
  2154. if(yPos >= (r.bottom - r.top))
  2155. yPos = r.bottom - r.top - 1;
  2156. }
  2158. pt.x = xPos;
  2159. pt.y = yPos;
  2161. ClientToScreen(hwnd, &pt);
  2163. MoveWindow( hwnd, pt.x - moveX, 
  2164. pt.y - moveY - 22, 
  2165. windowRect.right - windowRect.left, 
  2166. windowRect.bottom - windowRect.top, TRUE);
  2167. }
  2169. if(action == ACTION_RESIZE) {
  2171. POINT pt;
  2173. pt.x = LOWORD(lParam);
  2174. pt.y = HIWORD(lParam);
  2176. resizer->Draw(hwnd, &pt);
  2178.   
  2179. }
  2181. if(action == ACTION_VOLUME_CURSOR) {
  2183. moveX = LOWORD(lParam); 
  2184. skin->SetVolumeCursorX(hwnd, moveX);
  2186. playback->SetVolume(skin->GetVolume());
  2187. }
  2189. if(action == ACTION_PROGRESS_CURSOR) {
  2191. moveX = LOWORD(lParam); 
  2192. skin->SetProgressCursorX(hwnd, moveX);
  2193. }
  2195. break;
  2197. case WM_RBUTTONDOWN:
  2199. if(!playback->fullscreen) {
  2201. HMENU menu;
  2202. POINT pt1;
  2203. int   x, y;
  2205. pt1.x = pt1.y = 0;
  2206. ClientToScreen(hwnd, &pt1);
  2208. x = pt1.x + LOWORD(lParam); 
  2209. y = pt1.y + HIWORD(lParam);
  2211. menu = GetSubMenu(popupMenu, 0);
  2213. TrackPopupMenu( menu, 0, x, y, 0, hwnd, NULL);
  2214. }
  2215. break;
  2217. case WM_SIZE:
  2219. RECT  clientRect, windowRect;
  2220. POINT other_pt;
  2222. GetClientRect(hwnd, &clientRect);
  2223. GetWindowRect(hwnd, &windowRect);
  2225. other_pt.x = clientRect.left;
  2226. other_pt.y = clientRect.top;
  2228. ClientToScreen(hwnd, &other_pt);
  2230. pt2.x = clientRect.right;
  2231. pt2.y = clientRect.bottom;
  2233. ClientToScreen(hwnd, &pt2);
  2235.     SetWindowRgn(hwnd, CreateRectRgn( other_pt.x  - windowRect.left, 
  2236.      other_pt.y  - windowRect.top,
  2237.   (windowRect.right - windowRect.left) - (windowRect.right - pt2.x),
  2238.   (windowRect.bottom - windowRect.top) - (windowRect.bottom - pt2.y)), TRUE); 
  2240. break;
  2242. case WM_PAINT:
  2244. skin->UpdateSize(hwnd);
  2245. skin->Display(hwnd, playback);
  2246. return 0;
  2247. break;
  2249. case WM_DROPFILES:
  2251. char lpFilename[256];
  2253. if(DragQueryFile( (HDROP) wParam, 0, lpFilename, 256) > 0)  {
  2255. OpenFileForPlaying(hwnd, lpFilename, INPUT_TYPE_FILE);
  2256. }
  2257. break;
  2259. }
  2261.   return DefWindowProc(hwnd, Message, wParam, lParam);
  2262. }