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

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

VC书籍

开发平台：

Visual C++

playlist.c：源码内容
  4. #include "stdafx.h"
  5. #include "globals.h"
  6. #include "CPI_Player.h"
  7. #include "CPI_Playlist.h"
  8. #include "CPI_PlaylistItem.h"
  9. #include "CPI_ID3.h"
  12. ////////////////////////////////////////////////////////////////////////
  13. //
  14. //
  15. //
  16. void    playlist_move_control(int ControlID, LPRECT NewPlaylistrect,
  17.                               int type)
  18. {
  19.     /*
  20.        RECT    winrect;
  22.        int     xsize, ysize;
  24.        HWND    hwndDlg = windows.dlg_playlist;
  25.        HWND    hwndControl = GetDlgItem(hwndDlg, ControlID);
  27.        GetWindowRect(hwndControl, // handle to window
  28.        &winrect); // address of structure for window coordinates
  30.        xsize = winrect.right - winrect.left;
  31.        ysize = winrect.bottom - winrect.top;
  32.        ScreenToClient(hwndDlg, // window handle for source coordinates
  33.         (LPPOINT) & winrect); // address of structure containing coordinates);
  35.        switch (type) {
  36.        case TOPRIGHT:
  37.     MoveWindow(hwndControl, // handle to window
  38.         winrect.left +
  39.         ((NewPlaylistrect->right - globals.playlist_rect.right)
  40.          + (globals.playlist_rect.left - NewPlaylistrect->left)), // horizontal position
  41.         winrect.top, //+NewPlaylistrect->top,          // vertical position
  42.         xsize, // width
  43.         ysize, // height
  44.         TRUE); // repaint flag
  45.     break;
  46.        case RESIZE:
  47.     MoveWindow(hwndControl, // handle to window
  48.         winrect.left, // horizontal position
  49.         winrect.top, //+NewPlaylistrect->top,          // vertical position
  50.         xsize +
  51.         ((NewPlaylistrect->right - globals.playlist_rect.right)
  52.          + (globals.playlist_rect.left - NewPlaylistrect->left)), // width
  53.         ysize +
  54.         ((NewPlaylistrect->bottom
  55.           - globals.playlist_rect.bottom) +
  56.          (globals.playlist_rect.top - NewPlaylistrect->top)), // height
  57.         TRUE); // repaint flag
  58.     break;
  59.        case BOTTOMLEFT:
  60.     MoveWindow(hwndControl, // handle to window
  61.         winrect.left, // horizontal position
  62.     // horizontal position
  63.         winrect.top +
  64.         ((NewPlaylistrect->bottom
  65.           - globals.playlist_rect.bottom) +
  66.          (globals.playlist_rect.top - NewPlaylistrect->top)), //+NewPlaylistrect->top,          // vertical position
  67.         xsize, // width
  68.         ysize, // height
  69.         TRUE); // repaint flag
  70.     break;
  71.        case BOTTOMRIGHT:
  72.     MoveWindow(hwndControl, // handle to window
  73.         winrect.left +
  74.         ((NewPlaylistrect->right - globals.playlist_rect.right)
  75.          + (globals.playlist_rect.left - NewPlaylistrect->left)), // horizontal position
  76.         winrect.top +
  77.         ((NewPlaylistrect->bottom
  78.           - globals.playlist_rect.bottom) +
  79.          (globals.playlist_rect.top - NewPlaylistrect->top)), //+NewPlaylistrect->top,          // vertical position
  80.         xsize, // width
  81.         ysize, // height
  82.         TRUE); // repaint flag
  83.     break;
  84.        }
  85.     */
  86. }
  88. BOOL    playlist_skin_set_control_bitmap(char *position)
  89. {
  90.     /*
  91.        HWND    hDlg = windows.dlg_playlist;
  92.        HWND    button;
  93.        unsigned int teller = 0;
  94.        char    name[MAX_PATH];
  95.        int     controlid = 0;
  96.        short   i = 0;
  97.        LONG    style;
  98.        UINT    x = 0, y = 0, w = 0, h = 0;
  100.        char   *items[] =
  101.     { "Add", "Save", "AddDir", "Clear", "ClearSel", "MoveUp",
  102.     "MoveDown",
  103.     "Shuffle", "Close", "Close2",
  104.     "Minimize", "Maximize", "Find", NULL
  105.        };
  106.        UINT    controlids[] =
  107.     { IDC_OPENLIST, IDC_SAVELIST, IDC_ADDDIR, IDC_CLEAR, IDC_CLEARSEL,
  108.     IDC_MOVEUP, IDC_MOVEDOWN, IDC_SHUFFLE, IDOK, IDC_CLOSE, IDC_MINIMIZE, 
  109.     IDC_MAXIMIZE, IDC_FIND,
  110.     0
  111.        };
  112.        RECT    winrect;
  113.        WINDOWPLACEMENT wndpl;
  114.        if (IsIconic(hDlg)) {
  115.     wndpl.length = sizeof(WINDOWPLACEMENT);
  116.     GetWindowPlacement(hDlg, &wndpl);
  117.     CopyRect(&winrect, &wndpl.rcNormalPosition);
  118.        } else
  119.     GetWindowRect(hDlg, &winrect);
  120.        winrect.right -= winrect.left;
  121.        winrect.bottom -= winrect.top;
  122.        winrect.left = 0;
  123.        winrect.top = 0;
  125.        while (teller < strlen(position)) {
  126.     if (position[teller] == '=' || position[teller] == ',')
  127.         position[teller] = ' ';
  128.     teller++;
  129.        }
  130.        sscanf(position, "%s %d %d %d %d", name, &x, &y, &w, &h);
  132.        while (items[i] != NULL) {
  133.     if (!stricmp(name, items[i])) {
  134.         controlid = controlids[i];
  135.         break;
  136.     };
  137.     i++;
  138.        }
  140.        if (!stricmp(name, "List")) {
  141.     button = GetDlgItem(hDlg, IDC_PLAYLIST);
  142.     SetWindowPos(button, NULL, x, y, winrect.right - w - x,
  143.           winrect.bottom - h - y,
  144.           SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOREDRAW);
  145.     return TRUE;
  146.        }
  148.        if (controlid) {
  149.     BITMAP  bm;
  150.     char    playlistbitmapfile[MAX_PATH];
  151.     char    pathname[MAX_PATH];
  152.     button = GetDlgItem(hDlg, controlid);
  153.     style = GetWindowLong(button, GWL_STYLE);
  154.     style |= BS_OWNERDRAW;
  155.     SetWindowLong(button, GWL_STYLE, style);
  156.     SetWindowLong(button, GWL_USERDATA, w);
  157.     strcpy(playlistbitmapfile, options.playlist_skin_file);
  158.     path_remove_filespec(playlistbitmapfile);
  160.     sprintf(pathname, "%s%s.bmp", playlistbitmapfile, name);
  161.     DeleteObject(PlayListBitmap.bm[i]);
  162.     PlayListBitmap.bm[i] =
  163.         LoadImage(0, pathname, IMAGE_BITMAP, 0, 0,
  164.            LR_LOADFROMFILE);
  166.     if (!PlayListBitmap.bm[i])
  167.         ShowWindow(GetDlgItem(hDlg, controlid), SW_HIDE);
  168.     GetObject(PlayListBitmap.bm[i], sizeof(bm), &bm);
  169.     SetWindowPos(GetDlgItem(hDlg, controlid), NULL, 0, 0,
  170.           bm.bmWidth, bm.bmHeight / 2,
  171.           SWP_NOREDRAW | SWP_NOMOVE | SWP_NOOWNERZORDER |
  172.           SWP_NOZORDER);
  173.     switch (w) {
  174.     case BOTTOMRIGHT:
  175.         SetWindowPos(button, NULL, winrect.right - x,
  176.       winrect.bottom - y, 0, 0,
  177.       SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOZORDER
  178.       | SWP_NOREDRAW);
  179.         break;
  180.     case TOPRIGHT:
  181.         SetWindowPos(button, NULL, winrect.right - x, y, 0, 0,
  182.       SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOZORDER
  183.       | SWP_NOREDRAW);
  184.         break;
  185.     case BOTTOMLEFT:
  186.         SetWindowPos(button, NULL, x, winrect.bottom - y, 0, 0,
  187.       SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOZORDER
  188.       | SWP_NOREDRAW);
  189.         break;
  190.     case TOPLEFT:
  191.         SetWindowPos(button, NULL, x, y, 0, 0,
  192.       SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOZORDER
  193.       | SWP_NOREDRAW);
  194.         break;
  195.     }
  196.     return TRUE;
  197.        }
  198.      */
  199.     return FALSE;
  200. }
  202. BOOL    playlist_skin_get_ini_value(char *key, char *position, SIZE * rect)
  203. {
  204.     /*
  205.        SIZE    readrect;
  206.        while (*position != 0) {
  207.     unsigned int teller = 0;
  208.     char    name[MAX_PATH];
  209.     while (teller < strlen(position)) {
  210.         if (position[teller] == '=' || position[teller] == ',')
  211.      position[teller] = ' ';
  212.         teller++;
  213.     }
  214.     sscanf(position, "%s %i %i", name, &readrect.cx, &readrect.cy);
  216.     if (!stricmp(name, key)) {
  217.         rect->cx = readrect.cx;
  218.         rect->cy = readrect.cy;
  219.         return TRUE;
  220.     }
  222.     position = position + strlen(position) + 1;
  223.        }
  224.     */
  226.     return FALSE;
  227. }
  229. /*
  230. You should add your initialization code here. This function will be called
  231. when the dialog box receives the WM_INITDIALOG message.
  232. */
  233. int     playlist_skin_read()
  234. {
  235.     /*
  237.        char    values[32768];
  238.        char    playlistfile[MAX_PATH];
  239.        char    playlistbitmapfile[MAX_PATH];
  240.        char   *position;
  241.        char    buffer[4096];
  242.        HWND    hDlg = windows.dlg_playlist;
  243.        int     i = 0;
  244.        UINT    controlids[] =
  245.     { IDC_OPENLIST, IDC_SAVELIST, IDC_ADDDIR, IDC_CLEAR, IDC_CLEARSEL,
  246.     IDC_MOVEUP, IDC_MOVEDOWN, IDC_SHUFFLE, IDOK, IDC_CLOSE, 
  247.     IDC_MINIMIZE, IDC_MAXIMIZE, IDC_FIND,
  248.     0
  249.        };
  250.        while (controlids[i] != 0)
  251.     SetWindowLong(GetDlgItem(hDlg, controlids[i++]), GWL_USERDATA, 0);
  253.        if (!*options.playlist_skin_file || !options.use_playlist_skin)
  254.     return FALSE;
  255.        GetPrivateProfileString(NULL, NULL, NULL,
  256.          buffer, sizeof(buffer),
  257.          options.playlist_skin_file);
  259.        if (GetPrivateProfileSection
  260.     ("Playlist", values, 32767, options.playlist_skin_file) == 0) {
  261.     MessageBox(hDlg, "Can't open ini file!",
  262.         options.playlist_skin_file,
  263.         MB_ICONERROR | MB_SETFOREGROUND | MB_TOPMOST);
  264.        } // points to initialization filename
  265.        strcpy(playlistfile, options.playlist_skin_file);
  266.        path_remove_filespec(playlistfile);
  267.        position = values;
  268.        while (*position != 0) {
  270.     playlist_skin_set_control_bitmap(position);
  271.     position = position + strlen(position) + 1;
  272.        }
  274.        sprintf(playlistbitmapfile, "%sPlaylist.bmp", playlistfile);
  275.        DeleteObject(graphics.bmp_playlist_bg);
  276.        graphics.bmp_playlist_bg =
  277.     LoadImage(0, playlistbitmapfile, IMAGE_BITMAP, 0, 0,
  278.        LR_LOADFROMFILE);
  279.        if (!graphics.bmp_playlist_bg)
  280.     MessageBox(hDlg, "Can't load bitmap", playlistbitmapfile,
  281.         MB_ICONERROR | MB_SETFOREGROUND | MB_TOPMOST);
  283.        position = values;
  284.        playlist_skin_get_ini_value("UpLeft", position,
  285.      &PlayListBitmap.UpLeft);
  286.        position = values;
  287.        playlist_skin_get_ini_value("UpRight", position,
  288.      &PlayListBitmap.UpRight);
  289.        position = values;
  290.        playlist_skin_get_ini_value("DownLeft", position,
  291.      &PlayListBitmap.DownLeft);
  292.        position = values;
  293.        playlist_skin_get_ini_value("DownRight", position,
  294.      &PlayListBitmap.DownRight);
  295.        position = values;
  296.        playlist_skin_get_ini_value("UpMid", position, &PlayListBitmap.UpMid);
  297.        position = values;
  298.        playlist_skin_get_ini_value("DownMid", position,
  299.      &PlayListBitmap.DownMid);
  300.        position = values;
  301.        playlist_skin_get_ini_value("LeftMid", position,
  302.      &PlayListBitmap.LeftMid);
  303.        position = values;
  304.        playlist_skin_get_ini_value("RightMid", position,
  305.      &PlayListBitmap.RightMid);
  306.        position = values;
  307.        playlist_skin_get_ini_value("MinSize", position,
  308.      &PlayListBitmap.MinSize);
  309.        position = values;
  310.        playlist_skin_get_ini_value("Colors", position,
  311.      &PlayListBitmap.Colors);
  313.        if (PlayListBitmap.UpLeft.cx) {
  314.     LONG    style;
  315.     HWND    button;
  316.     LONG    data;
  317.     style = GetWindowLong(hDlg, GWL_STYLE);
  318.     style &= ~WS_CAPTION;
  319.     style &= ~WS_THICKFRAME;
  320.     style &= ~WS_BORDER;
  321.     SetWindowLong(hDlg, GWL_STYLE, style);
  323.     ShowWindow(GetDlgItem(hDlg, IDC_MINIMIZE), SW_SHOW);
  324.     ShowWindow(GetDlgItem(hDlg, IDC_MAXIMIZE), SW_SHOW);
  325.     ShowWindow(GetDlgItem(hDlg, IDC_CLOSE), SW_SHOW);
  326.     ShowWindow(GetDlgItem(hDlg, IDC_SORTTEXT), SW_HIDE);
  327.     ShowWindow(GetDlgItem(hDlg, IDC_MOVETEXT), SW_HIDE);
  329.     // Check for the find button.
  330.     button = GetDlgItem(hDlg, IDC_FIND);
  331.     data = GetWindowLong(button, GWL_USERDATA);
  332.     if (!data) {
  333.         ShowWindow(button, SW_HIDE);
  334.     } else
  335.         ShowWindow(button, SW_SHOW);
  337.        } else
  338.     return FALSE;
  339.     */
  340.     return 1;
  341. }
  343. void    playlist_draw_control(UINT controlid, LPDRAWITEMSTRUCT ds)
  344. {
  345.     /*
  346.        HDC     winmemdc = CreateCompatibleDC(ds->hDC);
  347.        HBITMAP h;
  348.        HBITMAP image;
  349.        HPALETTE oldpal;
  350.        int     height = 0, i = 0;
  351.        UINT    controlids[] =
  352.     { IDC_OPENLIST, IDC_SAVELIST, IDC_ADDDIR, IDC_CLEAR, IDC_CLEARSEL,
  353.     IDC_MOVEUP, IDC_MOVEDOWN, IDC_SHUFFLE, IDOK, IDC_CLOSE, IDC_MINIMIZE, 
  354.     IDC_MAXIMIZE, IDC_FIND, 0
  355.        };
  356.        while (controlids[i] != 0) {
  357.     if (controlids[i] == ds->CtlID) {
  358.         image = PlayListBitmap.bm[i];
  359.         break;
  360.     }
  361.     i++;
  362.        }
  364.        if (ds->itemState & ODS_SELECTED) {
  365.     height = ds->rcItem.bottom;
  366.        }
  368.        h = (HBITMAP) SelectObject(winmemdc, image);
  369.        oldpal = SelectPalette(ds->hDC, graphics.pal_main, FALSE);
  370.        RealizePalette(ds->hDC);
  371.        BitBlt(ds->hDC, 0, 0, ds->rcItem.right, ds->rcItem.bottom, winmemdc,
  372.        0, height, SRCCOPY);
  373.        SelectPalette(ds->hDC, oldpal, FALSE);
  374.        SelectObject(winmemdc, h);
  375.        DeleteDC(winmemdc);
  376.     */
  377. }
  379. #define  MIDUP 1
  380. #define  MIDDOWN 2
  381. #define  MIDLEFT 3
  382. #define  MIDRIGHT 4
  383. #define  CENTER 5
  385. BOOL    playlist_skin_draw_side(HDC hdc, HDC winmemdc, BITMAP * bm,
  386.                                 RECT * winrect, int type)
  387. {
  388.     /*
  389.        RECT    Siderect;
  390.        RECT    Destrect;
  391.        int     mode;
  392.        switch (type) {
  394.        case MIDUP:
  395.     Siderect.left = PlayListBitmap.UpLeft.cx;
  396.     Siderect.top = 0;
  397.     Siderect.right = bm->bmWidth - PlayListBitmap.UpRight.cx;
  398.     Siderect.bottom = PlayListBitmap.UpMid.cx;
  400.     Destrect.left = PlayListBitmap.UpLeft.cx;
  401.     Destrect.top = 0;
  402.     Destrect.right = winrect->right - (PlayListBitmap.UpRight.cx);
  403.     Destrect.bottom = PlayListBitmap.UpMid.cx;
  404.     mode = PlayListBitmap.UpMid.cy;
  405.     break;
  406.        case MIDDOWN:
  407.     Siderect.left = PlayListBitmap.DownLeft.cx;
  408.     Siderect.top = bm->bmHeight - PlayListBitmap.DownMid.cx;
  409.     Siderect.right = bm->bmWidth - PlayListBitmap.DownRight.cx;
  410.     Siderect.bottom = bm->bmHeight;
  412.     Destrect.left = PlayListBitmap.DownLeft.cx;
  413.     Destrect.top = winrect->bottom - (PlayListBitmap.DownMid.cx);
  414.     Destrect.right = winrect->right - (PlayListBitmap.DownRight.cx);
  415.     Destrect.bottom = winrect->bottom;
  416.     mode = PlayListBitmap.DownMid.cy;
  418.     break;
  420.        case MIDLEFT:
  421.     Siderect.left = 0;
  422.     Siderect.top = PlayListBitmap.UpLeft.cy;
  423.     Siderect.right = PlayListBitmap.LeftMid.cx;
  424.     Siderect.bottom = bm->bmHeight - PlayListBitmap.DownLeft.cy;
  426.     Destrect.left = 0;
  427.     Destrect.top = PlayListBitmap.UpLeft.cy;
  428.     Destrect.right = PlayListBitmap.LeftMid.cx;
  429.     Destrect.bottom = winrect->bottom - PlayListBitmap.DownLeft.cy;
  430.     mode = PlayListBitmap.LeftMid.cy;
  432.     break;
  434.        case MIDRIGHT:
  435.     Siderect.left = bm->bmWidth - (PlayListBitmap.RightMid.cx);
  436.     Siderect.top = PlayListBitmap.UpRight.cy;
  437.     Siderect.right = bm->bmWidth;
  438.     Siderect.bottom = bm->bmHeight - PlayListBitmap.DownRight.cy;
  440.     Destrect.left = winrect->right - PlayListBitmap.RightMid.cx;
  441.     Destrect.top = PlayListBitmap.UpRight.cy;
  442.     Destrect.right = winrect->right;
  443.     Destrect.bottom = winrect->bottom - PlayListBitmap.DownRight.cy;
  444.     mode = PlayListBitmap.RightMid.cy;
  445.     break;
  447.        case CENTER:
  448.     Siderect.left = PlayListBitmap.LeftMid.cx;
  449.     Siderect.top = PlayListBitmap.UpMid.cx;
  450.     Siderect.right = bm->bmWidth - PlayListBitmap.RightMid.cx;
  451.     Siderect.bottom = bm->bmHeight - PlayListBitmap.DownMid.cx;
  453.     Destrect.left = PlayListBitmap.LeftMid.cx;
  454.     Destrect.top = PlayListBitmap.UpMid.cx;
  455.     Destrect.right = winrect->right - PlayListBitmap.RightMid.cx;;
  456.     Destrect.bottom = winrect->bottom - PlayListBitmap.DownMid.cx;
  458.     mode = 1;
  460.     break;
  461.        }
  463.        if (mode == 1) {
  464.     StretchBlt(hdc, // handle to destination DC
  465.         Destrect.left, // x-coord of destination upper-left corner
  466.         Destrect.top, // y-coord of destination upper-left corner
  467.         Destrect.right - Destrect.left, // width of destination rectangle
  468.         Destrect.bottom - Destrect.top, // height of destination rectangle
  469.         winmemdc, // handle to source DC
  470.         Siderect.left, // x-coord of source upper-left corner
  471.         Siderect.top, // y-coord of source upper-left corner
  472.         Siderect.right - Siderect.left, // width of source rectangle
  473.         Siderect.bottom - Siderect.top, // height of source rectangle
  474.         SRCCOPY // raster operation code
  475.         );
  477.        } else {
  478.     //      Figure out when our last images will be drawn.
  479.     int     nEndCol =
  480.         (Destrect.right - Destrect.left) / (Siderect.right -
  481.      Siderect.left) + 1;
  482.     int     nEndRow =
  483.         (Destrect.bottom - Destrect.top) / (Siderect.bottom -
  484.      Siderect.top) + 1;
  485.     int     nCol, nRow;
  487.     //
  488.     //      We would use clipping when the tiling is used as a background bitmap.
  489.     //      This would substantially reduce the number of BitBlt's we do.
  491.     for (nCol = 0; nCol < nEndCol; nCol++) {
  492.         int     xcount, xrest = 0;
  493.         xcount =
  494.      (Destrect.right - Destrect.left) -
  495.      ((Siderect.right - Siderect.left) * (nCol + 1));
  496.         if (xcount < 0)
  497.      xrest = xcount;
  498.         for (nRow = 0; nRow < nEndRow; nRow++) {
  499.      int     ycount, yrest = 0;
  500.      ycount =
  501.          (Destrect.bottom - Destrect.top) -
  502.          ((nRow + 1) * (Siderect.bottom - Siderect.top));
  503.      if (ycount < 0)
  504.          yrest = ycount;
  505.      BitBlt(hdc,
  506.             Destrect.left +
  507.             ((Siderect.right - Siderect.left) *
  508.      nCol),
  509.             Destrect.top +
  510.             ((Siderect.bottom - Siderect.top) *
  511.      nRow),
  512.             Siderect.right - Siderect.left + xrest,
  513.             Siderect.bottom - Siderect.top + yrest,
  514.             winmemdc, Siderect.left, Siderect.top, SRCCOPY);
  515.         }
  516.     }
  518.        }
  519.     */
  520.     return TRUE;
  521. }
  522. //
  523. //
  524. //
  525. LRESULT CALLBACK playlist_windowproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
  526. {
  527.     /*
  528.        switch (msg) 
  529.     {
  530.        case WM_ERASEBKGND:
  531.      if(!PlayListBitmap.UpLeft.cx)
  532.      return FALSE;
  533.      else
  534.      return TRUE;
  535.        case WM_PAINT:
  536.      {
  537.      HDC     winhdc, winmemdc;
  538.      HBITMAP h;
  539.      BITMAP  bm;
  540.      HPALETTE oldpal;
  541.      PAINTSTRUCT Paint;
  542.      RECT    winrect;
  543.      RECT    Listviewrect;
  544.      if (!PlayListBitmap.UpLeft.cx)
  545.      break;
  546.      winhdc = BeginPaint(hwndDlg, &Paint);
  548.      GetClientRect(hwndDlg, &winrect);
  549.      GetWindowRect(windows.m_hWndPlaylist_ListView, &Listviewrect);
  551.      Listviewrect.right -= Listviewrect.left;
  552.      Listviewrect.bottom -= Listviewrect.top;
  554.      ScreenToClient(hwndDlg, (LPPOINT) & Listviewrect);
  556.      Listviewrect.right += Listviewrect.left;
  557.      Listviewrect.bottom += Listviewrect.top;
  559.      ExcludeClipRect(winhdc, Listviewrect.left, Listviewrect.top,
  560.      Listviewrect.right, Listviewrect.bottom);
  562.      winmemdc = CreateCompatibleDC(winhdc);
  563.      GetObject(graphics.bmp_playlist_bg, sizeof(bm), &bm);
  564.      h = (HBITMAP) SelectObject(winmemdc, graphics.bmp_playlist_bg);
  565.      oldpal = SelectPalette(winhdc, graphics.pal_main, FALSE);
  566.      RealizePalette(winhdc);
  567.      BitBlt(winhdc, 0, 0, PlayListBitmap.UpLeft.cx,
  568.         PlayListBitmap.UpLeft.cy, winmemdc, 0, 0, SRCCOPY);
  569.      playlist_skin_draw_side(winhdc, winmemdc, &bm, &winrect,
  570.      MIDUP);
  571.      BitBlt(winhdc, winrect.right - (PlayListBitmap.UpRight.cx), 0,
  572.         PlayListBitmap.UpRight.cx, PlayListBitmap.UpRight.cy,
  573.         winmemdc, bm.bmWidth - PlayListBitmap.UpRight.cx, 0,
  574.         SRCCOPY);
  575.      playlist_skin_draw_side(winhdc, winmemdc, &bm, &winrect,
  576.      MIDLEFT);
  577.      playlist_skin_draw_side(winhdc, winmemdc, &bm, &winrect,
  578.      MIDRIGHT);
  579.      BitBlt(winhdc, 0, winrect.bottom - PlayListBitmap.DownLeft.cy,
  580.         PlayListBitmap.DownLeft.cx, PlayListBitmap.DownLeft.cy,
  581.         winmemdc, 0, bm.bmHeight - PlayListBitmap.DownLeft.cy,
  582.         SRCCOPY);
  583.      playlist_skin_draw_side(winhdc, winmemdc, &bm, &winrect,
  584.      MIDDOWN);
  585.      BitBlt(winhdc, winrect.right - (PlayListBitmap.DownRight.cx),
  586.         winrect.bottom - PlayListBitmap.DownRight.cy,
  587.         PlayListBitmap.DownRight.cx,
  588.         PlayListBitmap.DownRight.cy, winmemdc,
  589.         bm.bmWidth - PlayListBitmap.DownRight.cx,
  590.         bm.bmHeight - PlayListBitmap.DownRight.cy, SRCCOPY);
  591.      SelectPalette(winmemdc, oldpal, FALSE);
  592.      SelectObject(winmemdc, h);
  593.      DeleteDC(winmemdc);
  594.      EndPaint(hwndDlg, &Paint);
  595.      }
  596.      return 0;
  598.        case WM_DRAWITEM:
  599.      playlist_draw_control(wParam, (LPDRAWITEMSTRUCT) lParam);
  600.      return TRUE;
  602.        case WM_INITDIALOG:
  603.      windows.wnd_playlist_IPEdit = NULL;
  604.      playlist_skin_read();
  605.      return TRUE;
  607.        case WM_SIZE:
  608.     {
  609.         RECT    NewPlaylistrect;
  610.         int     moveflag;
  612.      InvalidateRect(windows.dlg_playlist, NULL, TRUE);
  613.         if (wParam != SIZE_MINIMIZED) {
  615.      GetWindowRect(hwndDlg, &NewPlaylistrect);
  616.      windows.dlg_playlist = hwndDlg;
  617.      playlist_move_control(IDC_PLAYLIST, &NewPlaylistrect,
  618.            RESIZE);
  620.      if (!
  621.          (moveflag =
  622.           GetWindowLong(GetDlgItem
  623.         (hwndDlg, IDC_SORTTEXT),
  624.         GWL_USERDATA))) moveflag = TOPRIGHT;
  625.      playlist_move_control(IDC_SORTTEXT, &NewPlaylistrect,
  626.            moveflag);
  628.      if (!
  629.          (moveflag =
  630.           GetWindowLong(GetDlgItem
  631.         (hwndDlg, IDC_OPENLIST),
  632.         GWL_USERDATA))) moveflag = TOPRIGHT;
  633.      playlist_move_control(IDC_OPENLIST, &NewPlaylistrect,
  634.            moveflag);
  636.      if (!
  637.          (moveflag =
  638.           GetWindowLong(GetDlgItem
  639.         (hwndDlg, IDC_SAVELIST),
  640.         GWL_USERDATA))) moveflag = TOPRIGHT;
  641.      playlist_move_control(IDC_SAVELIST, &NewPlaylistrect,
  642.            moveflag);
  644.      if (!
  645.          (moveflag =
  646.           GetWindowLong(GetDlgItem(hwndDlg, IDC_CLEAR),
  647.         GWL_USERDATA))) moveflag = TOPRIGHT;
  648.      playlist_move_control(IDC_CLEAR, &NewPlaylistrect,
  649.            moveflag);
  651.      if (!
  652.          (moveflag =
  653.           GetWindowLong(GetDlgItem
  654.         (hwndDlg, IDC_CLEARSEL),
  655.         GWL_USERDATA))) moveflag = TOPRIGHT;
  656.      playlist_move_control(IDC_CLEARSEL, &NewPlaylistrect,
  657.            moveflag);
  659.      if (!(moveflag = GetWindowLong(GetDlgItem(hwndDlg, IDC_MOVETEXT), GWL_USERDATA)))
  660.      moveflag = TOPRIGHT;
  661.      playlist_move_control(IDC_MOVETEXT, &NewPlaylistrect, moveflag);
  663.      if (!
  664.          (moveflag =
  665.           GetWindowLong(GetDlgItem
  666.         (hwndDlg, IDC_MOVEUP),
  667.         GWL_USERDATA))) moveflag = TOPRIGHT;
  668.      playlist_move_control(IDC_MOVEUP, &NewPlaylistrect,
  669.            moveflag);
  671.      if (!
  672.          (moveflag =
  673.           GetWindowLong(GetDlgItem
  674.         (hwndDlg, IDC_MOVEDOWN),
  675.         GWL_USERDATA))) moveflag = TOPRIGHT;
  676.      playlist_move_control(IDC_MOVEDOWN, &NewPlaylistrect,
  677.            moveflag);
  679.      if (!
  680.          (moveflag =
  681.           GetWindowLong(GetDlgItem(hwndDlg, IDOK),
  682.         GWL_USERDATA))) moveflag = BOTTOMRIGHT;
  683.      playlist_move_control(IDOK, &NewPlaylistrect, moveflag);
  685.      if (!
  686.          (moveflag =
  687.           GetWindowLong(GetDlgItem
  688.         (hwndDlg, IDC_SHUFFLE),
  689.         GWL_USERDATA))) moveflag = TOPRIGHT;
  690.      playlist_move_control(IDC_SHUFFLE, &NewPlaylistrect,
  691.            moveflag);
  693.      if (!
  694.          (moveflag =
  695.           GetWindowLong(GetDlgItem
  696.         (hwndDlg, IDC_ADDDIR),
  697.         GWL_USERDATA))) moveflag = TOPRIGHT;
  698.      playlist_move_control(IDC_ADDDIR, &NewPlaylistrect,
  699.            moveflag);
  701.      if (!
  702.          (moveflag =
  703.           GetWindowLong(GetDlgItem
  704.         (hwndDlg, IDC_MINIMIZE),
  705.         GWL_USERDATA))) moveflag = TOPRIGHT;
  706.      playlist_move_control(IDC_MINIMIZE, &NewPlaylistrect,
  707.            moveflag);
  709.      if (!
  710.          (moveflag =
  711.           GetWindowLong(GetDlgItem
  712.         (hwndDlg, IDC_MAXIMIZE),
  713.         GWL_USERDATA))) moveflag = TOPRIGHT;
  714.      playlist_move_control(IDC_MAXIMIZE, &NewPlaylistrect,
  715.            moveflag);
  717.      if (!
  718.          (moveflag =
  719.           GetWindowLong(GetDlgItem(hwndDlg, IDC_CLOSE),
  720.         GWL_USERDATA))) moveflag = TOPRIGHT;
  721.      playlist_move_control(IDC_CLOSE, &NewPlaylistrect,
  722.            moveflag);
  724.      if (!
  725.          (moveflag =
  726.           GetWindowLong(GetDlgItem(hwndDlg, IDC_FIND),
  727.         GWL_USERDATA))) moveflag = TOPRIGHT;
  728.      playlist_move_control(IDC_FIND, &NewPlaylistrect,
  729.            moveflag);
  731.      GetWindowRect(hwndDlg, &globals.playlist_rect);
  732.      CopyRect(&options.playlist_window_pos,
  733.       &globals.playlist_rect);
  734.         }
  735.         break;
  736.     }
  738.     return 0;
  740.        }
  741.     */
  742.     return FALSE;
  743. }