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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
Skin.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：29k
源码类别：

VC书籍

开发平台：

Visual C++

Skin.cpp：源码内容
  1. /**************************************************************************************
  2.  *                                                                                    *
  3.  *                                                                                    *
  4.  **************************************************************************************/
  7. #include "Skin.h"
  10. /*
  11.  * Constructor : 装载缺省的外壳
  12.  *
  13.  */
  16. Skin::Skin(HINSTANCE hInstance, HWND hwnd)
  17. {
  19. this->LoadDefault(hInstance, hwnd);
  21. if(this->skin == NULL ||this->controls == NULL) {
  22. MessageBox(NULL, "Cannot load default skin!", "Error", MB_OK);
  23. }
  26. this->menuButton.left   = 2;
  27. this->menuButton.right  = 14;
  28. this->menuButton.top    = 3;
  29. this->menuButton.bottom = 14;
  31. this->minimizeButton.left   = 266;
  32. this->minimizeButton.right  = 278;
  33. this->minimizeButton.top    = 3;
  34. this->minimizeButton.bottom = 14;
  36. this->closeButton.left   = 283;
  37. this->closeButton.right  = 295;
  38. this->closeButton.top    = 3;
  39. this->closeButton.bottom = 14;
  41. this->rewindButton.left   = 15;
  42. this->rewindButton.right  = 15+29;
  43. this->rewindButton.top    = 343;
  44. this->rewindButton.bottom = 360;
  46. this->stopButton.left   = 52;
  47. this->stopButton.right  = 52+29;
  48. this->stopButton.top    = 343;
  49. this->stopButton.bottom = 360;
  51. this->playButton.left   = 89;
  52. this->playButton.right  = 89+29;
  53. this->playButton.top    = 343;
  54. this->playButton.bottom = 360;
  56. this->pauseButton.left   = 126;
  57. this->pauseButton.right  = 126+29;
  58. this->pauseButton.top    = 343;
  59. this->pauseButton.bottom = 360;
  61. this->forwardButton.left   = 263;
  62. this->forwardButton.right  = 300;
  63. this->forwardButton.top    = 343;
  64. this->forwardButton.bottom = 360;
  66. this->loadButton.left   = 236;
  67. this->loadButton.right  = 263+44;
  68. this->loadButton.top    = 343;
  69. this->loadButton.bottom = 360;
  71. this->progressBar.left   = 12;
  72. this->progressBar.right  = 281;
  73. this->progressBar.top    = 325;
  74. this->progressBar.bottom = 332;
  76. this->volumeBar.left   = 212;
  77. this->volumeBar.right  = 273;
  78. this->volumeBar.top    = 296;
  79. this->volumeBar.bottom = 304;
  81. this->progressCursor.left   = 15;
  82. this->progressCursor.right  = 43;
  83. this->progressCursor.top    = 321;
  84. this->progressCursor.bottom = 336;
  86. this->volumeCursor.left   = 250;
  87. this->volumeCursor.right  = 270;
  88. this->volumeCursor.top    = 293;
  89. this->volumeCursor.bottom = 307;
  91. this->volume   = 100;
  92. this->progress = 0.0;
  94. this->compactMode = 0;
  95. }
  99. Skin::~Skin()
  100. {
  101. DeleteObject((HGDIOBJ) this->skin); 
  103. DeleteObject((HGDIOBJ) this->controls); 
  104. DeleteObject((HGDIOBJ) this->bottom); 
  105. DeleteObject((HGDIOBJ) this->logo); 
  106. }
  110. BOOL Skin::isInsideRect(int x, int y, RECT rect)
  111. {
  112. return (x > rect.left && x < rect.right && y > rect.top && y < rect.bottom);
  113. }
  117. int Skin::LoadDefault(HINSTANCE hInstance, HWND hwnd) {
  119. HDC   dc, sdc, ddc;
  120. DWORD i;
  122. this->skin     = LoadBitmap(hInstance, MAKEINTRESOURCE(ID_SKIN)); 
  123. this->controls = LoadBitmap(hInstance, MAKEINTRESOURCE(ID_CONTROLS));
  124. this->logo     = LoadBitmap(hInstance, MAKEINTRESOURCE(ID_LOGO));
  126. dc = GetDC(hwnd);
  128. this->bottom = CreateCompatibleBitmap(dc, 256, 115);
  130. sdc = CreateCompatibleDC(dc);
  131. SelectObject(sdc, this->skin);
  133. ddc = CreateCompatibleDC(dc);
  134. SelectObject(ddc, this->bottom);
  137. for(i=0; i < 256; i++) {
  139. BitBlt(ddc, i, 0, 1, 115, sdc, 200, 260, SRCCOPY);
  140. }
  142. ReleaseDC(hwnd, dc);
  143. DeleteDC(sdc);
  144. DeleteDC(ddc);
  146. this->skinColor = 0;
  148. return 1;
  149. }
  154. int Skin::Load(char *directory, HWND hwnd) {
  156. HDC   dc, sdc, ddc;
  157. DWORD i;
  159. if(directory != NULL) {
  161. char *mainc, *logoc, *controlsc;
  163. mainc     = (char *) new char[strlen(directory) + 10];
  164. strcpy(mainc, directory);
  166. logoc     = (char *) new char[strlen(directory) + 10];
  167. strcpy(logoc, directory);
  169. controlsc = (char *) new char[strlen(directory) + 20];
  170. strcpy(controlsc, directory);
  172. if(this->skin)
  173. DeleteObject((HGDIOBJ) this->skin);
  175. if(this->controls)
  176. DeleteObject((HGDIOBJ) this->controls);
  178. if(this->logo)
  179. DeleteObject((HGDIOBJ) this->logo);
  181. this->skin =     (HBITMAP) LoadImage(NULL, strcat(mainc, "\main.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
  182. this->logo =     (HBITMAP) LoadImage(NULL, strcat(logoc, "\logo.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
  183. this->controls = (HBITMAP) LoadImage(NULL, strcat(controlsc, "\controls.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
  185. free(mainc);
  186. free(logoc);
  187. free(controlsc);
  189. if(this->skin == 0 || this->logo == 0 || this->controls == 0) {
  191. this->LoadDefault(GetModuleHandle(NULL), hwnd);
  192. }
  193. else {
  196. dc = GetDC(hwnd);
  198. sdc = CreateCompatibleDC(dc);
  199. SelectObject(sdc, this->skin);
  201. ddc = CreateCompatibleDC(dc);
  202. SelectObject(ddc, this->bottom);
  205. for(i=0; i < 256; i++) {
  207. BitBlt(ddc, i, 0, 1, 115, sdc, 200, 260, SRCCOPY);
  208. }
  210. ReleaseDC(hwnd, dc);
  211. DeleteDC(sdc);
  212. DeleteDC(ddc);
  215. SkinFile *skinFile = new SkinFile(directory);
  217. this->skinColor = skinFile->getColor("background");
  219. skinFile->Close();
  220. }
  221. }
  223. return 1;
  224. }
  228. int Skin::GetDefaultWidth()
  229. {
  230. return DEFAULT_SKIN_WIDTH;
  231. }
  235. int Skin::GetDefaultHeight()
  236. {
  237. return DEFAULT_SKIN_HEIGHT;
  238. }
  241. int Skin::SetVolume(HWND hwnd, int new_volume)
  242. {
  243. int          sizeX, sizeY;
  244. RECT         clientRect;
  248. GetClientRect(hwnd, &clientRect);
  250. sizeX = clientRect.right - clientRect.left;
  251. sizeY = clientRect.bottom - clientRect.top;
  253. this->volume = new_volume;
  255. this->volumeCursor.left   = 215 + (sizeX - DEFAULT_SKIN_WIDTH) + 35*this->volume/100;
  256. this->volumeCursor.right  = 235 + (sizeX - DEFAULT_SKIN_WIDTH) + 35*this->volume/100;
  257. this->volumeCursor.top    = 293 + (sizeY - DEFAULT_SKIN_HEIGHT);
  258. this->volumeCursor.bottom = 307 + (sizeY - DEFAULT_SKIN_HEIGHT);
  260. return 1;
  261. }
  263. int Skin::SetProgress(HWND hwnd, double new_progress)
  264. {
  265. int          sizeX, sizeY;
  266. RECT         clientRect;
  270. GetClientRect(hwnd, &clientRect);
  272. sizeX = clientRect.right - clientRect.left;
  273. sizeY = clientRect.bottom - clientRect.top;
  275. this->progress = new_progress;
  277. this->progressCursor.left   =  15 + (int)((double)(sizeX - DEFAULT_SKIN_WIDTH + 263 - 28)*this->progress)/100;
  278. this->progressCursor.right  =  43 + (int)((double)(sizeX - DEFAULT_SKIN_WIDTH + 263 - 28)*this->progress)/100;
  279. this->progressCursor.top    =  321 + (sizeY - DEFAULT_SKIN_HEIGHT);
  280. this->progressCursor.bottom =  336 + (sizeY - DEFAULT_SKIN_HEIGHT);
  282. return 1;
  283. }
  285. int Skin::SetVolumeCursorX(HWND hwnd, int x)
  286. {
  287. int  the_volume;
  288. int  sizeX, sizeY;
  289. RECT clientRect;
  290. HDC          hdc, bdc;
  292. hdc = GetDC(hwnd);
  293. bdc = CreateCompatibleDC(hdc);
  294.  
  295. if(hdc == NULL || bdc == NULL) {
  297. return 0;
  298. }
  300. SelectObject(bdc, this->skin);
  304. GetClientRect(hwnd, &clientRect);
  306. sizeX = clientRect.right - clientRect.left;
  307. sizeY = clientRect.bottom - clientRect.top;
  309. if(x < volumeBar.left)
  310. the_volume = 0;
  311. else {
  312. if(x > volumeBar.right)
  313. the_volume = 100;
  314. else {
  316. the_volume = (x - volumeBar.left)*100/(volumeBar.right - volumeBar.left);
  317. }
  318. }
  320. SetVolume(hwnd, the_volume);
  322. BitBlt(hdc, volumeBar.left, volumeBar.top - 5, (volumeBar.right - volumeBar.left), (volumeBar.bottom - volumeBar.top) + 10, 
  323.    bdc, 212, 291, SRCCOPY);
  325. SelectObject(bdc, this->controls);
  327. BitBlt(hdc, volumeCursor.left, volumeCursor.top, (volumeCursor.right - volumeCursor.left), (volumeCursor.bottom - volumeCursor.top), 
  328.    bdc, 32, 45, SRCCOPY);
  330. DeleteDC(bdc);
  331. ReleaseDC(hwnd, hdc);
  333. return 1;
  334. }
  336. int Skin::SetProgressCursorX(HWND hwnd, int x)
  337. {
  338. int  the_progress;
  339. int  sizeX, sizeY, i;
  340. RECT clientRect;
  341. HDC  hdc, bdc;
  343. hdc = GetDC(hwnd);
  344. bdc = CreateCompatibleDC(hdc);
  345.  
  346. if(hdc == NULL || bdc == NULL) {
  348. return 0;
  349. }
  351. SelectObject(bdc, this->skin);
  355. GetClientRect(hwnd, &clientRect);
  357. sizeX = clientRect.right - clientRect.left;
  358. sizeY = clientRect.bottom - clientRect.top;
  360. if(x < progressBar.left)
  361. the_progress = 0;
  362. else {
  363. if(x > progressBar.right)
  364. the_progress = 100;
  365. else {
  367. the_progress = (x - progressBar.left)*100/(progressBar.right - progressBar.left);
  368. }
  369. }
  371. SetProgress(hwnd, the_progress);
  373. BitBlt(hdc, 0, 320 + (sizeY - DEFAULT_SKIN_HEIGHT), 200, 20, bdc, 0, 320, SRCCOPY);
  375. for(i=0; i < (sizeX - DEFAULT_SKIN_WIDTH); i++) {
  377. BitBlt(hdc, 200 + i, 320 + (sizeY - DEFAULT_SKIN_HEIGHT), 1, 20, bdc, 200, 320, SRCCOPY);
  378. }
  380. BitBlt(hdc, 200 + (sizeX - DEFAULT_SKIN_WIDTH), 320 + (sizeY - DEFAULT_SKIN_HEIGHT), 100, 20, bdc, 200, 320, SRCCOPY);
  383. SelectObject(bdc, this->controls);
  385. BitBlt(hdc, progressCursor.left, progressCursor.top, (progressCursor.right - progressCursor.left), (progressCursor.bottom - progressCursor.top), 
  386.    bdc, 2, 45, SRCCOPY);
  388. DeleteDC(bdc);
  389. ReleaseDC(hwnd, hdc);
  391. return 1;
  392. }
  394. int Skin::SetProgressValue(HWND hwnd, double progress)
  395. {
  396. int  sizeX, sizeY;
  397. RECT clientRect;
  398. HDC  hdc, bdc;
  400. if(progress != this->progress) {
  402. hdc = GetDC(this->hwnd);
  403. bdc = CreateCompatibleDC(hdc);
  404.  
  405. if(hdc == NULL) {
  407. return 0;
  408. }
  410. SelectObject(bdc, this->skin);
  413. GetClientRect(hwnd, &clientRect);
  415. sizeX = clientRect.right - clientRect.left;
  416. sizeY = clientRect.bottom - clientRect.top;
  418. BitBlt(hdc, progressCursor.left, progressCursor.top, 
  419.   (progressCursor.right - progressCursor.left), 
  420.   (progressCursor.bottom - progressCursor.top), 
  421.   bdc, 200, 321, SRCCOPY);
  423. SetProgress(hwnd, progress);
  428. SelectObject(bdc, this->controls);
  430. BitBlt(hdc, progressCursor.left, progressCursor.top, 
  431.   (progressCursor.right - progressCursor.left), 
  432.   (progressCursor.bottom - progressCursor.top), 
  433.   bdc, 2, 45, SRCCOPY);
  435. DeleteDC(bdc);
  436. ReleaseDC(hwnd, hdc);
  437. }
  439. return 1;
  440. }
  444. RECT *Skin::GetVideoRect()
  445. {
  446. if(this->hwnd) {
  448. GetClientRect(this->hwnd, &this->videoRect);
  450. if(this->compactMode) {
  452. return &this->videoRect;
  453. }
  454. else {
  456. this->videoRect.left    = 7;
  457. this->videoRect.right  -= 15;
  458. this->videoRect.top     = 22;
  459. this->videoRect.bottom -= 115;
  461. return &this->videoRect;
  462. }
  463. }
  465. return &this->videoRect;
  466. }
  470. int Skin::SetCompact(int compact)
  471. {
  472. this->compactMode = compact;
  474. return 0;
  475. }
  479. int Skin::GetProgress()
  480. {
  481. return (int) this->progress;
  482. }
  484. int Skin::GetVolume()
  485. {
  486. return this->volume;
  487. }
  491. Skin::Display(HWND hwnd, MediaPlayback *playback)
  492. {
  493. HDC          hdc, bdc;
  494. PAINTSTRUCT  ps;
  495. int          sizeX, sizeY, i;
  496. RECT         clientRect;
  497. HBRUSH       brush, oldBrush;
  499. /*
  500.    * 得到窗口的大小等信息
  501.  */
  503. GetClientRect(hwnd, &clientRect);
  505. sizeX = clientRect.right - clientRect.left;
  506. sizeY = clientRect.bottom - clientRect.top;
  508. this->hwnd = hwnd;
  510. if(!playback->IsInFullscreen() || playback->desktopMode) {
  512. hdc  = BeginPaint(hwnd, &ps);
  514. if(this->compactMode) {
  516. /*
  517.  * 简单显示logo
  518.  */
  520. bdc  = CreateCompatibleDC(hdc);
  521. SelectObject(bdc, this->logo);
  523. if(playback->IsOverlay()) {
  525. brush = CreateSolidBrush(DD_OVERLAY_COLORREF); 
  527. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  528. Rectangle(hdc, 0, 0, sizeX, sizeY); 
  530. SelectObject(hdc, oldBrush);
  531. DeleteObject((HGDIOBJ) brush);
  532. }
  533. else {
  534. if(!playback->IsPlaying()) {
  536. brush = CreateSolidBrush(this->skinColor); 
  538. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  539. Rectangle(hdc, 0, 0, DEFAULT_SKIN_WIDTH + (sizeX - DEFAULT_SKIN_WIDTH), 
  540.   DEFAULT_SKIN_HEIGHT + (sizeY - DEFAULT_SKIN_HEIGHT)); 
  542. SelectObject(bdc, this->logo);
  544. if(sizeY > LOGO_HEIGHT)
  545. BitBlt(hdc, (sizeX - LOGO_WIDTH)/2, (sizeY - LOGO_HEIGHT)/2, LOGO_WIDTH, LOGO_HEIGHT, bdc, 0, 0, SRCCOPY);
  547. SelectObject(hdc, oldBrush);
  548. DeleteObject((HGDIOBJ) brush);
  549. }
  550. }
  552. DeleteDC(bdc);
  553. }
  554. else {
  556. /*
  557.  * 绘制标准外壳
  558.  */
  560. bdc  = CreateCompatibleDC(hdc);
  561. SelectObject(bdc, this->skin);
  563. if(hdc == NULL || bdc == NULL) {
  565. return 0;
  566. }
  568. /*
  569.  * 首先复制背景
  570.    */
  572. /*
  573.  * 标题
  574.  */
  576. BitBlt(hdc, 0, 0, 21, 22, bdc, 0, 0, SRCCOPY);
  578. for(i = 0; i < (sizeX - DEFAULT_SKIN_WIDTH) / 2; i++) {
  580. BitBlt(hdc, 21 + i, 0, 1, 22, bdc, 21, 0, SRCCOPY);
  581. }
  583. BitBlt(hdc, 21 + (sizeX - DEFAULT_SKIN_WIDTH) / 2, 0, 240, 22, bdc, 21, 0, SRCCOPY);
  585. for(i = 0; i < (sizeX - DEFAULT_SKIN_WIDTH) / 2 + ((sizeX - DEFAULT_SKIN_WIDTH) % 2); i++) {
  587. BitBlt(hdc, 261 + (sizeX - DEFAULT_SKIN_WIDTH) / 2 + i, 0, 1, 22, bdc, 261, 0, SRCCOPY);
  588. }
  590. BitBlt(hdc, 261 + (sizeX - DEFAULT_SKIN_WIDTH), 0, 39, 22, bdc, 261, 0, SRCCOPY);
  592. /*
  593.  * 播放面积
  594.  *
  595.  */
  597. for(i=0; i < 238 + (sizeY - DEFAULT_SKIN_HEIGHT); i++) {
  599. BitBlt(hdc, 0, 22 + i, 7, 1, bdc, 0, 22, SRCCOPY);
  600. BitBlt(hdc, 292 + (sizeX - DEFAULT_SKIN_WIDTH), 22 + i, 8, 1, bdc, 292, 22, SRCCOPY);
  601. }
  603. /*
  604.  * 底
  605.  */
  607. BitBlt(hdc, 0, 260 + (sizeY - DEFAULT_SKIN_HEIGHT), 200, 115, bdc, 0, 260, SRCCOPY);
  608. BitBlt(hdc, 200 + (sizeX - DEFAULT_SKIN_WIDTH), 260 + (sizeY - DEFAULT_SKIN_HEIGHT), 100, 115, bdc, 200, 260, SRCCOPY);
  610. SelectObject(bdc, this->bottom);
  612. if(sizeX - DEFAULT_SKIN_WIDTH > 0) {
  614. int pass = (sizeX - DEFAULT_SKIN_WIDTH) / 256;
  616. for(i=0; i < pass; i++) {
  618. BitBlt(hdc, 200 + i*256, 260 + (sizeY - DEFAULT_SKIN_HEIGHT), 256, 115, bdc, 0, 0, SRCCOPY);
  619. }
  621. BitBlt(hdc, 200 + pass*256, 260 + (sizeY - DEFAULT_SKIN_HEIGHT), (sizeX - DEFAULT_SKIN_WIDTH) - pass*256, 115, bdc, 0, 0, SRCCOPY);
  622. }
  624. /*
  625.  * 某些信息
  626.  */
  628. if(playback->HasVideo() && !this->compactMode) {
  630. HFONT font, oldFont;
  631. DWORD time, total;
  632. char  buffer[24];
  633. DWORD h, m, s, ht, mt, st;
  634. char *file;
  636. font = CreateFont(13, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial");
  637. oldFont = (HFONT) SelectObject(hdc, (HGDIOBJ) font);
  639. SetBkMode(hdc, TRANSPARENT);
  641. if(strrchr(playback->GetFilename(), '\') != NULL) {
  643. file = strrchr(playback->GetFilename(), '\')+1;
  644. }
  645. else {
  647. file = playback->GetFilename();
  648. }
  650. TextOut(hdc, 20, 282 + (sizeY - DEFAULT_SKIN_HEIGHT), file, strlen(file));
  652. time = playback->GetActualTime();
  653. total = playback->GetTotalTime();
  655. h = time / 3600;
  656. m = (time - h*3600) / 60;
  657. s = (time - h*3600 - m*60);
  659. ht = total / 3600;
  660. mt = (total - ht*3600) / 60;
  661. st = (total - ht*3600 - mt*60);
  663. sprintf(buffer, "%.2d:%.2d:%.2d / %.2d:%.2d:%.2d", h, m, s, ht, mt, st);
  665. TextOut(hdc, 20, 296 + (sizeY - DEFAULT_SKIN_HEIGHT), buffer, strlen(buffer));
  667. SelectObject(hdc, (HGDIOBJ) oldFont);
  668. DeleteObject((HGDIOBJ)font);
  669. }
  671. /*
  672.  * 控件
  673.  *
  674.  */
  676. SelectObject(bdc, this->controls);
  678. BitBlt(hdc, progressCursor.left, progressCursor.top, (progressCursor.right - progressCursor.left), (progressCursor.bottom - progressCursor.top), 
  679.    bdc, 2, 45, SRCCOPY);
  681. BitBlt(hdc, volumeCursor.left, volumeCursor.top, (volumeCursor.right - volumeCursor.left), (volumeCursor.bottom - volumeCursor.top), 
  682.    bdc, 32, 45, SRCCOPY);
  684. /*
  685.  * 时间信息
  686.  */
  688. if(!playback->desktopMode) {
  690. if(!playback->IsPlaying() && !playback->IsPaused()) {
  692. brush = CreateSolidBrush(this->skinColor); 
  694. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  695. Rectangle(hdc, 7, 22, 292 + (sizeX - DEFAULT_SKIN_WIDTH), 260 + (sizeY - DEFAULT_SKIN_HEIGHT)); 
  697. SelectObject(bdc, this->logo);
  699. if(sizeY > LOGO_HEIGHT + 135 + 22)
  700. BitBlt(hdc, (sizeX - LOGO_WIDTH)/2, 50 + (sizeY - DEFAULT_SKIN_HEIGHT)/2, LOGO_WIDTH, LOGO_HEIGHT, bdc, 0, 0, SRCCOPY);
  702. SelectObject(hdc, oldBrush);
  703. DeleteObject((HGDIOBJ) brush);
  704. }
  705. else {
  707. if(playback->IsOverlay()) {
  709. brush = CreateSolidBrush(DD_OVERLAY_COLORREF);
  711. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  712. Rectangle(hdc, 7, 22, 292 + (sizeX - DEFAULT_SKIN_WIDTH), 260 + (sizeY - DEFAULT_SKIN_HEIGHT)); 
  714. SelectObject(hdc, oldBrush);
  715. DeleteObject((HGDIOBJ) brush);
  716. }
  717. }
  719. if(playback->IsPaused()) {
  721. if(playback->IsOverlay()) {
  723. brush = CreateSolidBrush(DD_OVERLAY_COLORREF);
  725. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  726. Rectangle(hdc, 7, 22, 292 + (sizeX - DEFAULT_SKIN_WIDTH), 260 + (sizeY - DEFAULT_SKIN_HEIGHT)); 
  728. SelectObject(hdc, oldBrush);
  729. DeleteObject((HGDIOBJ) brush);
  730. }
  731. else {
  732. brush = CreateSolidBrush(0); 
  733.  
  734. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  735. Rectangle(hdc, 7, 22, 292 + (sizeX - DEFAULT_SKIN_WIDTH), 260 + (sizeY - DEFAULT_SKIN_HEIGHT)); 
  737. SelectObject(hdc, oldBrush);
  738. DeleteObject((HGDIOBJ) brush);
  739. }
  740. }
  741. }
  743. DeleteDC(bdc);
  744. }
  746. EndPaint(hwnd, &ps); 
  747. }
  748. else {
  750. if(playback->IsOverlay() && playback->HasVideo()) {
  752. RECT *fullRects;
  754. fullRects = playback->videoRenderer->GetFullscreenRects();
  756. if(fullRects != NULL) {
  758. GetClientRect(hwnd, &clientRect);
  760. hdc  = BeginPaint(hwnd, &ps);
  762. brush = CreateSolidBrush(0);
  763. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  765. Rectangle(hdc, fullRects[0].left, fullRects[0].top, fullRects[0].left + fullRects[0].right + 50, fullRects[0].top + fullRects[0].bottom); 
  766. Rectangle(hdc, fullRects[2].left, fullRects[2].top, fullRects[2].left + fullRects[2].right + 50, fullRects[2].top + fullRects[2].bottom + 50); 
  768. DeleteObject((HGDIOBJ) brush);
  770. brush = CreateSolidBrush(DD_OVERLAY_COLORREF_FULLSCREEN);
  772. (HBRUSH) SelectObject(hdc, brush);
  774. Rectangle(hdc, fullRects[1].left, fullRects[1].top, fullRects[1].left + fullRects[1].right + 50, fullRects[1].top + fullRects[1].bottom); 
  776. SelectObject(hdc, oldBrush);
  777. DeleteObject((HGDIOBJ) brush);
  779. EndPaint(hwnd, &ps); 
  780. }
  781. }
  782. else {
  784. if(playback->HasVideo()) {
  786. hdc  = BeginPaint(hwnd, &ps);
  788. brush = CreateSolidBrush(0);
  789. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  791. Rectangle(hdc, 0, 0, sizeX, sizeY); 
  793. SelectObject(hdc, oldBrush);
  794. DeleteObject((HGDIOBJ) brush);
  796. EndPaint(hwnd, &ps); 
  797. }
  798. }
  799. }
  801. return 1;
  802. }
  805. /*
  806.  * 显示FPS
  807.  *
  808.  */
  810. int Skin::DisplayFps(HWND hwnd, MediaPlayback *playback)
  811. {
  812. HDC          hdc, bdc;
  813. int          sizeX, sizeY;
  814. RECT         clientRect;
  816. if(playback) {
  820. GetClientRect(hwnd, &clientRect);
  822. sizeX = clientRect.right - clientRect.left;
  823. sizeY = clientRect.bottom - clientRect.top;
  825. hdc  = GetDC(hwnd);
  826. bdc  = CreateCompatibleDC(hdc);
  828. SelectObject(bdc, this->skin);
  830. BitBlt(hdc, 0, 260 + (sizeY - DEFAULT_SKIN_HEIGHT), 200, 40, bdc, 0, 260, SRCCOPY);
  832. char msg[10];
  833. sprintf(msg, "%3.f FPS", playback->GetCurrentFps());
  835. SetBkMode(hdc, TRANSPARENT);
  836. TextOut(hdc, 15, 280 + (sizeY - DEFAULT_SKIN_HEIGHT), msg, 7);
  838. DeleteDC(bdc);
  839. ReleaseDC(hwnd, hdc);
  840. }
  842. return 1;
  843. }
  847. int   Skin::DrawTime(HWND hwnd, MediaPlayback *playback) {
  849. HDC          hdc, bdc, ddc;
  850. int          sizeX, sizeY;
  851. RECT         clientRect;
  852. HFONT        font, oldFont;
  853. HBITMAP      buff;
  855. if(hwnd) {
  858. GetClientRect(hwnd, &clientRect);
  860. sizeX = clientRect.right - clientRect.left;
  861. sizeY = clientRect.bottom - clientRect.top;
  863. hdc  = GetDC(hwnd);
  864. bdc  = CreateCompatibleDC(hdc);
  866. ddc  = CreateCompatibleDC(hdc);
  867. buff = CreateCompatibleBitmap(hdc, 106, 28);
  869. SelectObject(bdc, this->skin);
  870. SelectObject(ddc, buff);
  872. BitBlt(ddc, 0, 0, 106, 28, bdc, 17, 280, SRCCOPY);
  874. HFONT font, oldFont;
  875. DWORD time, total;
  876. char  buffer[24];
  877. DWORD h, m, s, ht, mt, st;
  878. char *file;
  880. if(strrchr(playback->GetFilename(), '\') != NULL) {
  882. file = strrchr(playback->GetFilename(), '\')+1;
  883. }
  884. else {
  886. file = playback->GetFilename();
  887. }
  890. font = CreateFont(13, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial");
  891. oldFont = (HFONT) SelectObject(ddc, (HGDIOBJ) font);
  893. SetBkMode(ddc, TRANSPARENT);
  894. TextOut(ddc, 3, 2, file, strlen(file));
  896. time = playback->GetActualTime();
  897. total = playback->GetTotalTime();
  899. h = time / 3600;
  900. m = (time - h*3600) / 60;
  901. s = (time - h*3600 - m*60);
  903. ht = total / 3600;
  904. mt = (total - ht*3600) / 60;
  905. st = (total - ht*3600 - mt*60);
  907. sprintf(buffer, "%.2d:%.2d:%.2d / %.2d:%.2d:%.2d", h, m, s, ht, mt, st);
  909. TextOut(ddc, 3, 16, buffer, strlen(buffer));
  911. SelectObject(ddc, (HGDIOBJ) oldFont);
  912. DeleteObject((HGDIOBJ)font);
  914. BitBlt(hdc, 17, 280 + (sizeY - DEFAULT_SKIN_HEIGHT), 106, 28, ddc, 0, 0, SRCCOPY);
  916. DeleteObject((HGDIOBJ) buff);
  918. DeleteDC(bdc);
  919. DeleteDC(ddc);
  920. ReleaseDC(hwnd, hdc);
  921. }
  923. return 0;
  924. }
  927. int   Skin::DrawBufferingState(HWND hwnd, DWORD state)
  928. {
  929. HDC          hdc, bdc;
  930. int          sizeX, sizeY;
  931. RECT         clientRect;
  932. HFONT        font, oldFont;
  934. if(hwnd && state > 0) {
  938. GetClientRect(hwnd, &clientRect);
  940. sizeX = clientRect.right - clientRect.left;
  941. sizeY = clientRect.bottom - clientRect.top;
  943. hdc  = GetDC(hwnd);
  944. bdc  = CreateCompatibleDC(hdc);
  946. SelectObject(bdc, this->skin);
  948. BitBlt(hdc, 17, 280 + (sizeY - DEFAULT_SKIN_HEIGHT), 106, 28, bdc, 17, 280, SRCCOPY);
  950. font = CreateFont(12, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial");
  951. oldFont = (HFONT) SelectObject(hdc, (HGDIOBJ) font);
  954. SetBkMode(hdc, TRANSPARENT);
  955. TextOut(hdc, 20, 282 + (sizeY - DEFAULT_SKIN_HEIGHT), "Buffering...", 12);
  957. SelectObject(hdc, (HGDIOBJ) oldFont);
  958. DeleteObject((HGDIOBJ)font);
  960. MoveToEx(hdc, 20, 295 + (sizeY - DEFAULT_SKIN_HEIGHT), NULL);
  961. LineTo(hdc, 120, 295 + (sizeY - DEFAULT_SKIN_HEIGHT));
  962. LineTo(hdc, 120, 305 + (sizeY - DEFAULT_SKIN_HEIGHT));
  963. LineTo(hdc, 20, 305 + (sizeY - DEFAULT_SKIN_HEIGHT));
  964. LineTo(hdc, 20, 295 + (sizeY - DEFAULT_SKIN_HEIGHT));
  966. Rectangle(hdc, 20, 295 + (sizeY - DEFAULT_SKIN_HEIGHT), 20 + state, 305 + (sizeY - DEFAULT_SKIN_HEIGHT));
  968. DeleteDC(bdc);
  969. ReleaseDC(hwnd, hdc);
  970. }
  972. return 1;
  973. }
  978. int Skin::UpdateSize(HWND hwnd)
  979. {
  981. int          sizeX, sizeY;
  982. RECT         clientRect;
  986. GetClientRect(hwnd, &clientRect);
  988. sizeX = clientRect.right - clientRect.left;
  989. sizeY = clientRect.bottom - clientRect.top;
  991. this->menuButton.left   = 2;
  992. this->menuButton.right  = 14;
  993. this->menuButton.top    = 3;
  994. this->menuButton.bottom = 14;
  996. this->minimizeButton.left   = 266 + (sizeX - DEFAULT_SKIN_WIDTH);
  997. this->minimizeButton.right  = 278 + (sizeX - DEFAULT_SKIN_WIDTH);
  998. this->minimizeButton.top    = 3;
  999. this->minimizeButton.bottom = 14;
  1001. this->closeButton.left   = 283 + (sizeX - DEFAULT_SKIN_WIDTH);
  1002. this->closeButton.right  = 295 + (sizeX - DEFAULT_SKIN_WIDTH);
  1003. this->closeButton.top    = 3;
  1004. this->closeButton.bottom = 14;
  1006. this->rewindButton.left   = 15;
  1007. this->rewindButton.right  = 15+29;
  1008. this->rewindButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1009. this->rewindButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1011. this->stopButton.left   = 52;
  1012. this->stopButton.right  = 52+29;
  1013. this->stopButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1014. this->stopButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1016. this->playButton.left   = 89;
  1017. this->playButton.right  = 89+29;
  1018. this->playButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1019. this->playButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1021. this->pauseButton.left   = 126;
  1022. this->pauseButton.right  = 126+29;
  1023. this->pauseButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1024. this->pauseButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1026. this->forwardButton.left   = 163;
  1027. this->forwardButton.right  = 192;
  1028. this->forwardButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1029. this->forwardButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1031. this->loadButton.left   = 236 + (sizeX - DEFAULT_SKIN_WIDTH);
  1032. this->loadButton.right  = 236 + 44 + (sizeX - DEFAULT_SKIN_WIDTH);
  1033. this->loadButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1034. this->loadButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1036. this->resizeButton.left   = 282 + (sizeX - DEFAULT_SKIN_WIDTH);
  1037. this->resizeButton.right  = 282 + 15 + (sizeX - DEFAULT_SKIN_WIDTH);
  1038. this->resizeButton.top    = 357 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1039. this->resizeButton.bottom = 357 + 15 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1041. this->progressBar.left   = 12;
  1042. this->progressBar.right  = 281 + (sizeX - DEFAULT_SKIN_WIDTH);
  1043. this->progressBar.top    = 325 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1044. this->progressBar.bottom = 332 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1046. this->volumeBar.left   = 212 + (sizeX - DEFAULT_SKIN_WIDTH);
  1047. this->volumeBar.right  = 273 + (sizeX - DEFAULT_SKIN_WIDTH);
  1048. this->volumeBar.top    = 296 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1049. this->volumeBar.bottom = 304 + (sizeY - DEFAULT_SKIN_HEIGHT);
  1051. SetVolume(hwnd, this->volume);
  1052. SetProgress(hwnd, this->progress);
  1054. return 1;
  1055. }
  1059. int Skin::SetActionStart(HWND hwnd, int action)
  1060. {
  1061. HDC          hdc, bdc;
  1063. hdc = GetDC(hwnd);
  1064. bdc = CreateCompatibleDC(hdc);
  1065.  
  1066. if(hdc == NULL || bdc == NULL) {
  1068. return 0;
  1069. }
  1071. SelectObject(bdc, this->controls);
  1073. switch(action) {
  1075. case ACTION_REWIND:
  1077. BitBlt(hdc, rewindButton.left, rewindButton.top, (rewindButton.right - rewindButton.left), (rewindButton.bottom - rewindButton.top),
  1078.    bdc, 2, 26, SRCCOPY);
  1079. break;
  1081. case ACTION_STOP:
  1083. BitBlt(hdc, stopButton.left, stopButton.top, (stopButton.right - stopButton.left), (stopButton.bottom - stopButton.top),
  1084.    bdc, 33, 26, SRCCOPY);
  1085. break;
  1087. case ACTION_PLAY:
  1089. BitBlt(hdc, playButton.left, playButton.top, (playButton.right - playButton.left), (playButton.bottom - playButton.top),
  1090.    bdc, 64, 26, SRCCOPY);
  1091. break;
  1093. case ACTION_PAUSE:
  1095. BitBlt(hdc, pauseButton.left, pauseButton.top, (pauseButton.right - pauseButton.left), (pauseButton.bottom - pauseButton.top),
  1096.    bdc, 95, 26, SRCCOPY);
  1097. break;
  1099. case ACTION_FORWARD:
  1101. BitBlt(hdc, forwardButton.left, forwardButton.top, (forwardButton.right - forwardButton.left), (forwardButton.bottom - forwardButton.top),
  1102.    bdc, 126, 26, SRCCOPY);
  1103. break;
  1105. case ACTION_LOAD:
  1107. BitBlt(hdc, loadButton.left, loadButton.top, (loadButton.right - loadButton.left), (loadButton.bottom - loadButton.top),
  1108.    bdc, 157, 26, SRCCOPY);
  1109. break;
  1111. default:
  1112. break;
  1113. }
  1115. DeleteDC(bdc);
  1116. ReleaseDC(hwnd, hdc);
  1118. return 1;
  1119. }
  1121. int Skin::SetActionEnd(HWND hwnd, int action)
  1122. {
  1123. HDC          hdc, bdc;
  1125. hdc = GetDC(hwnd);
  1126. bdc = CreateCompatibleDC(hdc);
  1127.  
  1128. if(hdc == NULL || bdc == NULL) {
  1130. return 0;
  1131. }
  1133. SelectObject(bdc, this->skin);
  1135. switch(action) {
  1137. case ACTION_REWIND:
  1139. BitBlt(hdc, rewindButton.left, rewindButton.top, (rewindButton.right - rewindButton.left), (rewindButton.bottom - rewindButton.top),
  1140.    bdc, 15, 343, SRCCOPY);
  1141. break;
  1143. case ACTION_STOP:
  1145. BitBlt(hdc, stopButton.left, stopButton.top, (stopButton.right - stopButton.left), (stopButton.bottom - stopButton.top),
  1146.    bdc, 52, 343, SRCCOPY);
  1147. break;
  1149. case ACTION_PLAY:
  1151. BitBlt(hdc, playButton.left, playButton.top, (playButton.right - playButton.left), (playButton.bottom - playButton.top),
  1152.    bdc, 89, 343, SRCCOPY);
  1153. break;
  1155. case ACTION_PAUSE:
  1157. BitBlt(hdc, pauseButton.left, pauseButton.top, (pauseButton.right - pauseButton.left), (pauseButton.bottom - pauseButton.top),
  1158.    bdc, 126, 343, SRCCOPY);
  1159. break;
  1161. case ACTION_FORWARD:
  1163. BitBlt(hdc, forwardButton.left, forwardButton.top, (forwardButton.right - forwardButton.left), (forwardButton.bottom - forwardButton.top),
  1164.    bdc, 163, 343, SRCCOPY);
  1165. break;
  1167. case ACTION_LOAD:
  1169. BitBlt(hdc, loadButton.left, loadButton.top, (loadButton.right - loadButton.left), (loadButton.bottom - loadButton.top),
  1170.    bdc, 236, 343, SRCCOPY);
  1171. break;
  1173. default:
  1174. break;
  1175. }
  1177. DeleteDC(bdc);
  1178. ReleaseDC(hwnd, hdc);
  1180. return 1;
  1181. }
  1185. int Skin::GetAction(int x, int y)
  1186. {
  1187. if(isInsideRect(x, y, this->menuButton))
  1188. return ACTION_MENU;
  1190. if(isInsideRect(x, y, this->minimizeButton))
  1191. return ACTION_MINIMIZE;
  1193. if(isInsideRect(x, y, this->closeButton))
  1194. return ACTION_CLOSE;
  1196. if(isInsideRect(x, y, this->rewindButton))
  1197. return ACTION_REWIND;
  1199. if(isInsideRect(x, y, this->stopButton))
  1200. return ACTION_STOP;
  1202. if(isInsideRect(x, y, this->playButton))
  1203. return ACTION_PLAY;
  1205. if(isInsideRect(x, y, this->pauseButton))
  1206. return ACTION_PAUSE;
  1208. if(isInsideRect(x, y, this->forwardButton))
  1209. return ACTION_FORWARD;
  1211. if(isInsideRect(x, y, this->loadButton))
  1212. return ACTION_LOAD;
  1214. if(isInsideRect(x, y, this->resizeButton))
  1215. return ACTION_RESIZE;
  1217. if(isInsideRect(x, y, this->volumeCursor))
  1218. return ACTION_VOLUME_CURSOR;
  1220. if(isInsideRect(x, y, this->progressCursor))
  1221. return ACTION_PROGRESS_CURSOR;
  1223. if(isInsideRect(x, y, this->volumeBar))
  1224. return ACTION_VOLUME_BAR;
  1226. if(isInsideRect(x, y, this->progressBar))
  1227. return ACTION_PROGRESS_BAR;
  1229. return ACTION_NONE;
  1230. }