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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

Skin.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.  **************************************************************************************/
  17. #include "Skin.h"
  19. /*
  20.  * Class Functions
  21.  *
  22.  */
  24. /*
  25.  * Constructor : Loads the default skin
  26.  *
  27.  */
  29. Skin::Skin(HINSTANCE hInstance, HWND hwnd)
  30. {
  32. this->LoadDefault(hInstance, hwnd);
  34. if(this->skin == NULL ||this->controls == NULL) {
  35. MessageBox(NULL, "Cannot load default skin!", "Error", MB_OK);
  36. }
  38. /*
  39.    * Default values for the rects
  40.  */
  42. this->menuButton.left   = 2;
  43. this->menuButton.right  = 14;
  44. this->menuButton.top    = 3;
  45. this->menuButton.bottom = 14;
  47. this->minimizeButton.left   = 266;
  48. this->minimizeButton.right  = 278;
  49. this->minimizeButton.top    = 3;
  50. this->minimizeButton.bottom = 14;
  52. this->closeButton.left   = 283;
  53. this->closeButton.right  = 295;
  54. this->closeButton.top    = 3;
  55. this->closeButton.bottom = 14;
  57. this->rewindButton.left   = 15;
  58. this->rewindButton.right  = 15+29;
  59. this->rewindButton.top    = 343;
  60. this->rewindButton.bottom = 360;
  62. this->stopButton.left   = 52;
  63. this->stopButton.right  = 52+29;
  64. this->stopButton.top    = 343;
  65. this->stopButton.bottom = 360;
  67. this->playButton.left   = 89;
  68. this->playButton.right  = 89+29;
  69. this->playButton.top    = 343;
  70. this->playButton.bottom = 360;
  72. this->pauseButton.left   = 126;
  73. this->pauseButton.right  = 126+29;
  74. this->pauseButton.top    = 343;
  75. this->pauseButton.bottom = 360;
  77. this->forwardButton.left   = 263;
  78. this->forwardButton.right  = 300;
  79. this->forwardButton.top    = 343;
  80. this->forwardButton.bottom = 360;
  82. this->loadButton.left   = 236;
  83. this->loadButton.right  = 263+44;
  84. this->loadButton.top    = 343;
  85. this->loadButton.bottom = 360;
  87. this->progressBar.left   = 12;
  88. this->progressBar.right  = 281;
  89. this->progressBar.top    = 325;
  90. this->progressBar.bottom = 332;
  92. this->volumeBar.left   = 212;
  93. this->volumeBar.right  = 273;
  94. this->volumeBar.top    = 296;
  95. this->volumeBar.bottom = 304;
  97. this->progressCursor.left   = 15;
  98. this->progressCursor.right  = 43;
  99. this->progressCursor.top    = 321;
  100. this->progressCursor.bottom = 336;
  102. this->volumeCursor.left   = 250;
  103. this->volumeCursor.right  = 270;
  104. this->volumeCursor.top    = 293;
  105. this->volumeCursor.bottom = 307;
  107. this->volume   = 100;
  108. this->progress = 0.0;
  109. }
  111. /*
  112.  * Destructor
  113.  *
  114.  */
  116. Skin::~Skin()
  117. {
  118. DeleteObject((HGDIOBJ) this->skin); 
  120. DeleteObject((HGDIOBJ) this->controls); 
  121. DeleteObject((HGDIOBJ) this->bottom); 
  122. DeleteObject((HGDIOBJ) this->logo); 
  123. }
  125. /*
  126.  * Returns TRUE if the point is
  127.  * inside the given rect...
  128.  *
  129.  */
  131. BOOL Skin::isInsideRect(int x, int y, RECT rect)
  132. {
  133. return (x > rect.left && x < rect.right && y > rect.top && y < rect.bottom);
  134. }
  136. /*
  137.  * loads the Default Skin
  138.  *
  139.  */
  141. int Skin::LoadDefault(HINSTANCE hInstance, HWND hwnd) {
  143. HDC   dc, sdc, ddc;
  144. DWORD i;
  146. this->skin     = LoadBitmap(hInstance, MAKEINTRESOURCE(ID_SKIN)); 
  147. this->controls = LoadBitmap(hInstance, MAKEINTRESOURCE(ID_CONTROLS));
  148. this->logo     = LoadBitmap(hInstance, MAKEINTRESOURCE(ID_LOGO));
  150. dc = GetDC(hwnd);
  152. this->bottom = CreateCompatibleBitmap(dc, 256, 115);
  154. sdc = CreateCompatibleDC(dc);
  155. SelectObject(sdc, this->skin);
  157. ddc = CreateCompatibleDC(dc);
  158. SelectObject(ddc, this->bottom);
  161. for(i=0; i < 256; i++) {
  163. BitBlt(ddc, i, 0, 1, 115, sdc, 200, 260, SRCCOPY);
  164. }
  166. ReleaseDC(hwnd, dc);
  167. DeleteDC(sdc);
  168. DeleteDC(ddc);
  170. this->skinColor = 0;
  172. return 1;
  173. }
  176. /*
  177.  * Loads a new skin
  178.  *
  179.  */
  181. int Skin::Load(char *directory, HWND hwnd) {
  183. HDC   dc, sdc, ddc;
  184. DWORD i;
  186. if(directory != NULL) {
  188. char *mainc, *logoc, *controlsc;
  190. mainc     = (char *) malloc(strlen(directory) + 10);
  191. strcpy(mainc, directory);
  193. logoc     = (char *) malloc(strlen(directory) + 10);
  194. strcpy(logoc, directory);
  196. controlsc = (char *) malloc(strlen(directory) + 20);
  197. strcpy(controlsc, directory);
  199. if(this->skin)
  200. DeleteObject((HGDIOBJ) this->skin);
  202. if(this->controls)
  203. DeleteObject((HGDIOBJ) this->controls);
  205. if(this->logo)
  206. DeleteObject((HGDIOBJ) this->logo);
  208. this->skin =     (HBITMAP) LoadImage(NULL, strcat(mainc, "\main.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
  209. this->logo =     (HBITMAP) LoadImage(NULL, strcat(logoc, "\logo.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
  210. this->controls = (HBITMAP) LoadImage(NULL, strcat(controlsc, "\controls.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
  212. free(mainc);
  213. free(logoc);
  214. free(controlsc);
  216. /*
  217.  * Do some cache
  218.  *
  219.  */
  221. dc = GetDC(hwnd);
  223. sdc = CreateCompatibleDC(dc);
  224. SelectObject(sdc, this->skin);
  226. ddc = CreateCompatibleDC(dc);
  227. SelectObject(ddc, this->bottom);
  230. for(i=0; i < 256; i++) {
  232. BitBlt(ddc, i, 0, 1, 115, sdc, 200, 260, SRCCOPY);
  233. }
  235. ReleaseDC(hwnd, dc);
  236. DeleteDC(sdc);
  237. DeleteDC(ddc);
  239. /*
  240.  * Now load the background color from the config.txt file
  241.  */
  243. SkinFile *skinFile = new SkinFile(directory);
  245. this->skinColor = skinFile->getColor("background");
  247. skinFile->Close();
  249. }
  251. return 1;
  252. }
  254. /*
  255.  * Return Default Width
  256.  *
  257.  */
  259. int Skin::DefaultWidth()
  260. {
  261. return DEFAULT_SKIN_WIDTH;
  262. }
  264. /*
  265.  * Return Default Width
  266.  *
  267.  */
  270. int Skin::DefaultHeight()
  271. {
  272. return DEFAULT_SKIN_HEIGHT;
  273. }
  275. /*
  276.  * Set volume and Progress
  277.  * (for display only!)
  278.  *
  279.  */
  281. int Skin::SetVolume(HWND hwnd, int new_volume)
  282. {
  283. int          sizeX, sizeY;
  284. RECT         clientRect;
  286. /*
  287.    * Get some info about the
  288.  * window size and all.
  289.  */
  291. GetClientRect(hwnd, &clientRect);
  293. sizeX = clientRect.right - clientRect.left;
  294. sizeY = clientRect.bottom - clientRect.top;
  296. this->volume = new_volume;
  298. this->volumeCursor.left   = 215 + (sizeX - DEFAULT_SKIN_WIDTH) + 35*this->volume/100;
  299. this->volumeCursor.right  = 235 + (sizeX - DEFAULT_SKIN_WIDTH) + 35*this->volume/100;
  300. this->volumeCursor.top    = 293 + (sizeY - DEFAULT_SKIN_HEIGHT);
  301. this->volumeCursor.bottom = 307 + (sizeY - DEFAULT_SKIN_HEIGHT);
  303. return 1;
  304. }
  306. int Skin::SetProgress(HWND hwnd, double new_progress)
  307. {
  308. int          sizeX, sizeY;
  309. RECT         clientRect;
  311. /*
  312.    * Get some info about the
  313.  * window size and all.
  314.  */
  316. GetClientRect(hwnd, &clientRect);
  318. sizeX = clientRect.right - clientRect.left;
  319. sizeY = clientRect.bottom - clientRect.top;
  321. this->progress = new_progress;
  323. this->progressCursor.left   =  15 + (int)((double)(sizeX - DEFAULT_SKIN_WIDTH + 263 - 28)*this->progress)/100;
  324. this->progressCursor.right  =  43 + (int)((double)(sizeX - DEFAULT_SKIN_WIDTH + 263 - 28)*this->progress)/100;
  325. this->progressCursor.top    =  321 + (sizeY - DEFAULT_SKIN_HEIGHT);
  326. this->progressCursor.bottom =  336 + (sizeY - DEFAULT_SKIN_HEIGHT);
  328. return 1;
  329. }
  331. int Skin::SetVolumeCursorX(HWND hwnd, int x)
  332. {
  333. int  the_volume;
  334. int  sizeX, sizeY;
  335. RECT clientRect;
  336. HDC          hdc, bdc;
  338. hdc = GetDC(hwnd);
  339. bdc = CreateCompatibleDC(hdc);
  340.  
  341. if(hdc == NULL || bdc == NULL) {
  343. MessageBox(NULL, "Cannot get appropriate DCs!", "Error", MB_OK);
  344. }
  346. SelectObject(bdc, this->skin);
  348. /*
  349.    * Get some info about the
  350.  * window size and all.
  351.  */
  353. GetClientRect(hwnd, &clientRect);
  355. sizeX = clientRect.right - clientRect.left;
  356. sizeY = clientRect.bottom - clientRect.top;
  358. if(x < volumeBar.left)
  359. the_volume = 0;
  360. else {
  361. if(x > volumeBar.right)
  362. the_volume = 100;
  363. else {
  365. the_volume = (x - volumeBar.left)*100/(volumeBar.right - volumeBar.left);
  366. }
  367. }
  369. SetVolume(hwnd, the_volume);
  371. BitBlt(hdc, volumeBar.left, volumeBar.top - 5, (volumeBar.right - volumeBar.left), (volumeBar.bottom - volumeBar.top) + 10, 
  372.    bdc, 212, 291, SRCCOPY);
  374. SelectObject(bdc, this->controls);
  376. BitBlt(hdc, volumeCursor.left, volumeCursor.top, (volumeCursor.right - volumeCursor.left), (volumeCursor.bottom - volumeCursor.top), 
  377.    bdc, 32, 45, SRCCOPY);
  379. DeleteDC(bdc);
  380. ReleaseDC(hwnd, hdc);
  382. return 1;
  383. }
  385. int Skin::SetProgressCursorX(HWND hwnd, int x)
  386. {
  387. int  the_progress;
  388. int  sizeX, sizeY, i;
  389. RECT clientRect;
  390. HDC  hdc, bdc;
  392. hdc = GetDC(hwnd);
  393. bdc = CreateCompatibleDC(hdc);
  394.  
  395. if(hdc == NULL || bdc == NULL) {
  397. MessageBox(NULL, "Cannot get appropriate DCs!", "Error", MB_OK);
  398. }
  400. SelectObject(bdc, this->skin);
  402. /*
  403.    * Get some info about the
  404.  * window size and all.
  405.  */
  407. GetClientRect(hwnd, &clientRect);
  409. sizeX = clientRect.right - clientRect.left;
  410. sizeY = clientRect.bottom - clientRect.top;
  412. if(x < progressBar.left)
  413. the_progress = 0;
  414. else {
  415. if(x > progressBar.right)
  416. the_progress = 100;
  417. else {
  419. the_progress = (x - progressBar.left)*100/(progressBar.right - progressBar.left);
  420. }
  421. }
  423. SetProgress(hwnd, the_progress);
  425. BitBlt(hdc, 0, 320 + (sizeY - DEFAULT_SKIN_HEIGHT), 200, 20, bdc, 0, 320, SRCCOPY);
  427. for(i=0; i < (sizeX - DEFAULT_SKIN_WIDTH); i++) {
  429. BitBlt(hdc, 200 + i, 320 + (sizeY - DEFAULT_SKIN_HEIGHT), 1, 20, bdc, 200, 320, SRCCOPY);
  430. }
  432. BitBlt(hdc, 200 + (sizeX - DEFAULT_SKIN_WIDTH), 320 + (sizeY - DEFAULT_SKIN_HEIGHT), 100, 20, bdc, 200, 320, SRCCOPY);
  435. SelectObject(bdc, this->controls);
  437. BitBlt(hdc, progressCursor.left, progressCursor.top, (progressCursor.right - progressCursor.left), (progressCursor.bottom - progressCursor.top), 
  438.    bdc, 2, 45, SRCCOPY);
  440. DeleteDC(bdc);
  441. ReleaseDC(hwnd, hdc);
  443. return 1;
  444. }
  446. int Skin::SetProgressValue(HWND hwnd, double progress)
  447. {
  448. int  sizeX, sizeY, i;
  449. RECT clientRect;
  450. HDC  hdc, bdc;
  452. if(progress != this->progress) {
  454. hdc = GetDC(this->hwnd);
  455. bdc = CreateCompatibleDC(hdc);
  456.  
  457. if(hdc == NULL) {
  459. MessageBox(NULL, "Cannot get appropriate DCs!", "Error", MB_OK);
  460. }
  462. SelectObject(bdc, this->skin);
  464. /*
  465.   * Get some info about the
  466. * window size and all.
  467. */
  469. GetClientRect(hwnd, &clientRect);
  471. sizeX = clientRect.right - clientRect.left;
  472. sizeY = clientRect.bottom - clientRect.top;
  474. BitBlt(hdc, progressCursor.left, progressCursor.top, 
  475.   (progressCursor.right - progressCursor.left), 
  476.   (progressCursor.bottom - progressCursor.top), 
  477.   bdc, 200, 321, SRCCOPY);
  479. SetProgress(hwnd, progress);
  482. /*
  483.  * The cursor
  484.  */
  486. SelectObject(bdc, this->controls);
  488. BitBlt(hdc, progressCursor.left, progressCursor.top, 
  489.   (progressCursor.right - progressCursor.left), 
  490.   (progressCursor.bottom - progressCursor.top), 
  491.   bdc, 2, 45, SRCCOPY);
  493. DeleteDC(bdc);
  494. ReleaseDC(hwnd, hdc);
  495. }
  497. return 1;
  498. }
  501. /*
  502.  * Gives the Progress and Volume
  503.  *
  504.  */
  506. int Skin::GetProgress()
  507. {
  508. return (int) this->progress;
  509. }
  511. int Skin::GetVolume()
  512. {
  513. return this->volume;
  514. }
  516. /*
  517.  * Display : display the skin 
  518.  *           into a window
  519.  *
  520.  */
  522. Skin::Display(HWND hwnd, Playback *playback)
  523. {
  524. HDC          hdc, bdc, dbdc;
  525. PAINTSTRUCT  ps;
  526. int          sizeX, sizeY, i;
  527. RECT         clientRect;
  528. HBRUSH       brush, oldBrush;
  530. /*
  531.    * Get some info about the
  532.  * window size and all.
  533.  */
  535. this->hwnd = hwnd;
  537. GetClientRect(hwnd, &clientRect);
  539. sizeX = clientRect.right - clientRect.left;
  540. sizeY = clientRect.bottom - clientRect.top;
  542. hdc  = BeginPaint(hwnd, &ps);
  544. bdc  = CreateCompatibleDC(hdc);
  545. SelectObject(bdc, this->skin);
  547. if(hdc == NULL || bdc == NULL) {
  549. MessageBox(NULL, "Cannot get appropriate DCs!", "Error", MB_OK);
  550. }
  552. /*
  553.  * First blit the background
  554.  */
  556. /*
  557.  * Title
  558.  */
  560. BitBlt(hdc, 0, 0, 21, 22, bdc, 0, 0, SRCCOPY);
  562. for(i = 0; i < (sizeX - DEFAULT_SKIN_WIDTH) / 2; i++) {
  564. BitBlt(hdc, 21 + i, 0, 1, 22, bdc, 21, 0, SRCCOPY);
  565. }
  567. BitBlt(hdc, 21 + (sizeX - DEFAULT_SKIN_WIDTH) / 2, 0, 240, 22, bdc, 21, 0, SRCCOPY);
  569. for(i = 0; i < (sizeX - DEFAULT_SKIN_WIDTH) / 2 + ((sizeX - DEFAULT_SKIN_WIDTH) % 2); i++) {
  571. BitBlt(hdc, 261 + (sizeX - DEFAULT_SKIN_WIDTH) / 2 + i, 0, 1, 22, bdc, 261, 0, SRCCOPY);
  572. }
  574. BitBlt(hdc, 261 + (sizeX - DEFAULT_SKIN_WIDTH), 0, 39, 22, bdc, 261, 0, SRCCOPY);
  576. /*
  577.  * The play Area
  578.  *
  579.  */
  581. for(i=0; i < 238 + (sizeY - DEFAULT_SKIN_HEIGHT); i++) {
  583. BitBlt(hdc, 0, 22 + i, 7, 1, bdc, 0, 22, SRCCOPY);
  584. BitBlt(hdc, 292 + (sizeX - DEFAULT_SKIN_WIDTH), 22 + i, 8, 1, bdc, 292, 22, SRCCOPY);
  585. }
  587. /*
  588.  * The bottom
  589.  */
  591. BitBlt(hdc, 0, 260 + (sizeY - DEFAULT_SKIN_HEIGHT), 200, 115, bdc, 0, 260, SRCCOPY);
  592. BitBlt(hdc, 200 + (sizeX - DEFAULT_SKIN_WIDTH), 260 + (sizeY - DEFAULT_SKIN_HEIGHT), 100, 115, bdc, 200, 260, SRCCOPY);
  594. SelectObject(bdc, this->bottom);
  596. if(sizeX - DEFAULT_SKIN_WIDTH > 0) {
  598. int pass = (sizeX - DEFAULT_SKIN_WIDTH) / 256;
  600. for(i=0; i < pass; i++) {
  602. BitBlt(hdc, 200 + i*256, 260 + (sizeY - DEFAULT_SKIN_HEIGHT), 256, 115, bdc, 0, 0, SRCCOPY);
  603. }
  605. BitBlt(hdc, 200 + pass*256, 260 + (sizeY - DEFAULT_SKIN_HEIGHT), (sizeX - DEFAULT_SKIN_WIDTH) - pass*256, 115, bdc, 0, 0, SRCCOPY);
  606. }
  608. /*
  609.  * Now the controls
  610.  *
  611.  */
  613. SelectObject(bdc, this->controls);
  615. BitBlt(hdc, progressCursor.left, progressCursor.top, (progressCursor.right - progressCursor.left), (progressCursor.bottom - progressCursor.top), 
  616.    bdc, 2, 45, SRCCOPY);
  618. BitBlt(hdc, volumeCursor.left, volumeCursor.top, (volumeCursor.right - volumeCursor.left), (volumeCursor.bottom - volumeCursor.top), 
  619.    bdc, 32, 45, SRCCOPY);
  621. /*
  622.  * And the time info
  623.  */
  625. if(!playback->isPlaying()) {
  627. brush = CreateSolidBrush(this->skinColor); 
  629. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  630. Rectangle(hdc, 7, 22, 292 + (sizeX - DEFAULT_SKIN_WIDTH), 260 + (sizeY - DEFAULT_SKIN_HEIGHT)); 
  632. SelectObject(bdc, this->logo);
  634. BitBlt(hdc, (sizeX - LOGO_WIDTH)/2, 50 + (sizeY - DEFAULT_SKIN_HEIGHT)/2, LOGO_WIDTH, LOGO_HEIGHT, 
  635.    bdc, 0, 0, SRCCOPY);
  637. SelectObject(hdc, oldBrush);
  638. DeleteObject((HGDIOBJ) brush);
  639. }
  641. if(playback->isPaused()) {
  643. brush = CreateSolidBrush(0); 
  644.  
  645. oldBrush = (HBRUSH) SelectObject(hdc, brush);
  646. Rectangle(hdc, 7, 22, 292 + (sizeX - DEFAULT_SKIN_WIDTH), 260 + (sizeY - DEFAULT_SKIN_HEIGHT)); 
  648. SelectObject(hdc, oldBrush);
  649. DeleteObject((HGDIOBJ) brush);
  650. }
  652. DeleteDC(bdc);
  654. EndPaint(hwnd, &ps); 
  656. return 1;
  657. }
  660. /*
  661.  * Display the FPS
  662.  *
  663.  */
  665. int Skin::DisplayFps(HWND hwnd, Playback *playback)
  666. {
  667. HDC          hdc, bdc;
  668. int          sizeX, sizeY;
  669. RECT         clientRect;
  671. if(playback) {
  673. /*
  674.    * Get some info about the
  675.  * window size and all.
  676. */
  678. GetClientRect(hwnd, &clientRect);
  680. sizeX = clientRect.right - clientRect.left;
  681. sizeY = clientRect.bottom - clientRect.top;
  683. hdc  = GetDC(hwnd);
  684. bdc  = CreateCompatibleDC(hdc);
  686. SelectObject(bdc, this->skin);
  688. BitBlt(hdc, 0, 260 + (sizeY - DEFAULT_SKIN_HEIGHT), 200, 40, bdc, 0, 260, SRCCOPY);
  690. char msg[10];
  691. sprintf(msg, "%3.f FPS", playback->GetCurrentFps());
  693. SetBkMode(hdc, TRANSPARENT);
  694. TextOut(hdc, 15, 280 + (sizeY - DEFAULT_SKIN_HEIGHT), msg, 7);
  696. DeleteDC(bdc);
  697. ReleaseDC(hwnd, hdc);
  698. }
  700. return 1;
  701. }
  704. /*
  705.  * Update the rects according
  706.  * to the new size of the window
  707.  *
  708.  */
  710. int Skin::UpdateSize(HWND hwnd)
  711. {
  713. int          sizeX, sizeY;
  714. RECT         clientRect;
  716. /*
  717.    * Get some info about the
  718.  * window size and all.
  719.  */
  721. GetClientRect(hwnd, &clientRect);
  723. sizeX = clientRect.right - clientRect.left;
  724. sizeY = clientRect.bottom - clientRect.top;
  726. this->menuButton.left   = 2;
  727. this->menuButton.right  = 14;
  728. this->menuButton.top    = 3;
  729. this->menuButton.bottom = 14;
  731. this->minimizeButton.left   = 266 + (sizeX - DEFAULT_SKIN_WIDTH);
  732. this->minimizeButton.right  = 278 + (sizeX - DEFAULT_SKIN_WIDTH);
  733. this->minimizeButton.top    = 3;
  734. this->minimizeButton.bottom = 14;
  736. this->closeButton.left   = 283 + (sizeX - DEFAULT_SKIN_WIDTH);
  737. this->closeButton.right  = 295 + (sizeX - DEFAULT_SKIN_WIDTH);
  738. this->closeButton.top    = 3;
  739. this->closeButton.bottom = 14;
  741. this->rewindButton.left   = 15;
  742. this->rewindButton.right  = 15+29;
  743. this->rewindButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  744. this->rewindButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  746. this->stopButton.left   = 52;
  747. this->stopButton.right  = 52+29;
  748. this->stopButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  749. this->stopButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  751. this->playButton.left   = 89;
  752. this->playButton.right  = 89+29;
  753. this->playButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  754. this->playButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  756. this->pauseButton.left   = 126;
  757. this->pauseButton.right  = 126+29;
  758. this->pauseButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  759. this->pauseButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  761. this->forwardButton.left   = 163;
  762. this->forwardButton.right  = 192;
  763. this->forwardButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  764. this->forwardButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  766. this->loadButton.left   = 236 + (sizeX - DEFAULT_SKIN_WIDTH);
  767. this->loadButton.right  = 236 + 44 + (sizeX - DEFAULT_SKIN_WIDTH);
  768. this->loadButton.top    = 343 + (sizeY - DEFAULT_SKIN_HEIGHT);
  769. this->loadButton.bottom = 360 + (sizeY - DEFAULT_SKIN_HEIGHT);
  771. this->resizeButton.left   = 282 + (sizeX - DEFAULT_SKIN_WIDTH);
  772. this->resizeButton.right  = 282 + 15 + (sizeX - DEFAULT_SKIN_WIDTH);
  773. this->resizeButton.top    = 357 + (sizeY - DEFAULT_SKIN_HEIGHT);
  774. this->resizeButton.bottom = 357 + 15 + (sizeY - DEFAULT_SKIN_HEIGHT);
  776. this->progressBar.left   = 12;
  777. this->progressBar.right  = 281 + (sizeX - DEFAULT_SKIN_WIDTH);
  778. this->progressBar.top    = 325 + (sizeY - DEFAULT_SKIN_HEIGHT);
  779. this->progressBar.bottom = 332 + (sizeY - DEFAULT_SKIN_HEIGHT);
  781. this->volumeBar.left   = 212 + (sizeX - DEFAULT_SKIN_WIDTH);
  782. this->volumeBar.right  = 273 + (sizeX - DEFAULT_SKIN_WIDTH);
  783. this->volumeBar.top    = 296 + (sizeY - DEFAULT_SKIN_HEIGHT);
  784. this->volumeBar.bottom = 304 + (sizeY - DEFAULT_SKIN_HEIGHT);
  786. SetVolume(hwnd, this->volume);
  787. SetProgress(hwnd, this->progress);
  789. return 1;
  790. }
  792. /*
  793.  * Updates special zones upon action
  794.  *
  795.  */
  797. int Skin::SetActionStart(HWND hwnd, int action)
  798. {
  799. HDC          hdc, bdc;
  801. hdc = GetDC(hwnd);
  802. bdc = CreateCompatibleDC(hdc);
  803.  
  804. if(hdc == NULL || bdc == NULL) {
  806. MessageBox(NULL, "Cannot get appropriate DCs!", "Error", MB_OK);
  807. }
  809. SelectObject(bdc, this->controls);
  811. switch(action) {
  813. case ACTION_REWIND:
  815. BitBlt(hdc, rewindButton.left, rewindButton.top, (rewindButton.right - rewindButton.left), (rewindButton.bottom - rewindButton.top),
  816.    bdc, 2, 26, SRCCOPY);
  817. break;
  819. case ACTION_STOP:
  821. BitBlt(hdc, stopButton.left, stopButton.top, (stopButton.right - stopButton.left), (stopButton.bottom - stopButton.top),
  822.    bdc, 33, 26, SRCCOPY);
  823. break;
  825. case ACTION_PLAY:
  827. BitBlt(hdc, playButton.left, playButton.top, (playButton.right - playButton.left), (playButton.bottom - playButton.top),
  828.    bdc, 64, 26, SRCCOPY);
  829. break;
  831. case ACTION_PAUSE:
  833. BitBlt(hdc, pauseButton.left, pauseButton.top, (pauseButton.right - pauseButton.left), (pauseButton.bottom - pauseButton.top),
  834.    bdc, 95, 26, SRCCOPY);
  835. break;
  837. case ACTION_FORWARD:
  839. BitBlt(hdc, forwardButton.left, forwardButton.top, (forwardButton.right - forwardButton.left), (forwardButton.bottom - forwardButton.top),
  840.    bdc, 126, 26, SRCCOPY);
  841. break;
  843. case ACTION_LOAD:
  845. BitBlt(hdc, loadButton.left, loadButton.top, (loadButton.right - loadButton.left), (loadButton.bottom - loadButton.top),
  846.    bdc, 157, 26, SRCCOPY);
  847. break;
  849. default:
  850. break;
  851. }
  853. DeleteDC(bdc);
  854. ReleaseDC(hwnd, hdc);
  856. return 1;
  857. }
  859. int Skin::SetActionEnd(HWND hwnd, int action)
  860. {
  861. HDC          hdc, bdc;
  863. hdc = GetDC(hwnd);
  864. bdc = CreateCompatibleDC(hdc);
  865.  
  866. if(hdc == NULL || bdc == NULL) {
  868. MessageBox(NULL, "Cannot get appropriate DCs!", "Error", MB_OK);
  869. }
  871. SelectObject(bdc, this->skin);
  873. switch(action) {
  875. case ACTION_REWIND:
  877. BitBlt(hdc, rewindButton.left, rewindButton.top, (rewindButton.right - rewindButton.left), (rewindButton.bottom - rewindButton.top),
  878.    bdc, 15, 343, SRCCOPY);
  879. break;
  881. case ACTION_STOP:
  883. BitBlt(hdc, stopButton.left, stopButton.top, (stopButton.right - stopButton.left), (stopButton.bottom - stopButton.top),
  884.    bdc, 52, 343, SRCCOPY);
  885. break;
  887. case ACTION_PLAY:
  889. BitBlt(hdc, playButton.left, playButton.top, (playButton.right - playButton.left), (playButton.bottom - playButton.top),
  890.    bdc, 89, 343, SRCCOPY);
  891. break;
  893. case ACTION_PAUSE:
  895. BitBlt(hdc, pauseButton.left, pauseButton.top, (pauseButton.right - pauseButton.left), (pauseButton.bottom - pauseButton.top),
  896.    bdc, 126, 343, SRCCOPY);
  897. break;
  899. case ACTION_FORWARD:
  901. BitBlt(hdc, forwardButton.left, forwardButton.top, (forwardButton.right - forwardButton.left), (forwardButton.bottom - forwardButton.top),
  902.    bdc, 163, 343, SRCCOPY);
  903. break;
  905. case ACTION_LOAD:
  907. BitBlt(hdc, loadButton.left, loadButton.top, (loadButton.right - loadButton.left), (loadButton.bottom - loadButton.top),
  908.    bdc, 236, 343, SRCCOPY);
  909. break;
  911. default:
  912. break;
  913. }
  915. DeleteDC(bdc);
  916. ReleaseDC(hwnd, hdc);
  918. return 1;
  919. }
  921. /*
  922.  * Returns the action corresponding
  923.  * to the given mouse click inside 
  924.  * the skin
  925.  *
  926.  */
  928. int Skin::GetAction(int x, int y)
  929. {
  930. if(isInsideRect(x, y, this->menuButton))
  931. return ACTION_MENU;
  933. if(isInsideRect(x, y, this->minimizeButton))
  934. return ACTION_MINIMIZE;
  936. if(isInsideRect(x, y, this->closeButton))
  937. return ACTION_CLOSE;
  939. if(isInsideRect(x, y, this->rewindButton))
  940. return ACTION_REWIND;
  942. if(isInsideRect(x, y, this->stopButton))
  943. return ACTION_STOP;
  945. if(isInsideRect(x, y, this->playButton))
  946. return ACTION_PLAY;
  948. if(isInsideRect(x, y, this->pauseButton))
  949. return ACTION_PAUSE;
  951. if(isInsideRect(x, y, this->forwardButton))
  952. return ACTION_FORWARD;
  954. if(isInsideRect(x, y, this->loadButton))
  955. return ACTION_LOAD;
  957. if(isInsideRect(x, y, this->resizeButton))
  958. return ACTION_RESIZE;
  960. if(isInsideRect(x, y, this->volumeCursor))
  961. return ACTION_VOLUME_CURSOR;
  963. if(isInsideRect(x, y, this->progressCursor))
  964. return ACTION_PROGRESS_CURSOR;
  966. if(isInsideRect(x, y, this->volumeBar))
  967. return ACTION_VOLUME_BAR;
  969. if(isInsideRect(x, y, this->progressBar))
  970. return ACTION_PROGRESS_BAR;
  972. return ACTION_NONE;
  973. }