main.c

VC++视频开发实例集锦(包括“远程视频监控”"语音识别系统"等13个经典例子)

                                   Skin.Object[teller].y);
                    moveit = FALSE;
                    return 0;
                }
            }

            if (cursorpos.x >= Skin.Object[TimeText].x
                    && cursorpos.y >= Skin.Object[TimeText].y
                    && cursorpos.x <=
                    Skin.Object[TimeText].x + (Skin.Object[TimeText].w * 8)
                    && cursorpos.y <=
                    Skin.Object[TimeText].y + Skin.Object[TimeText].h) {
                moveit = FALSE;
            }
            // id3tag editor
            if (cursorpos.x >= Skin.Object[SongtitleText].x
                    && cursorpos.y >= Skin.Object[SongtitleText].y
                    && cursorpos.x <=
                    Skin.Object[SongtitleText].x +
                    (Skin.Object[SongtitleText].w *
                     Skin.Object[SongtitleText].maxw)
                    && cursorpos.y <=
                    Skin.Object[SongtitleText].y +
                    Skin.Object[SongtitleText].h) {
                moveit = FALSE;
            }
            // VU & volume
            if (main_draw_vu_all(hWnd, wParam, lParam, TRUE) == FALSE)
                moveit = FALSE;

            // Move Window
            if (cursorpos.x >= Skin.Object[MoveArea].x
                    && cursorpos.y >= Skin.Object[MoveArea].y
                    && cursorpos.x <=
                    Skin.Object[MoveArea].x + Skin.Object[MoveArea].w
                    && cursorpos.y <=
                    Skin.Object[MoveArea].y + Skin.Object[MoveArea].h
                    || (moveit == TRUE && options.easy_move == TRUE)) {
                ReleaseCapture();
                SendMessage(hWnd, WM_SYSCOMMAND, SC_MOVE | HTCLIENT, 0);
            }
            break;
        }
    case WM_MOUSEMOVE:
        {
            MSG     msg;

            if (wParam == MK_LBUTTON)
                main_draw_vu_all(hWnd, wParam, lParam, FALSE);

            msg.lParam = lParam;
            msg.wParam = wParam;
            msg.message = message;
            msg.hwnd = hWnd;
            SendMessage(windows.wnd_tooltip, TTM_RELAYEVENT, 0,
                        (LPARAM) (LPMSG) & msg);
        }
        break;
    case WM_CANCELMODE:

		
        ReleaseCapture();
        break;
    case WM_LBUTTONUP:
        {
            int     teller;
            ReleaseCapture();
            globals.main_bool_slider_keep_focus = FALSE;
            cursorpos = MAKEPOINTS(lParam);
            for (teller = PlaySwitch; teller <= ExitButton; teller++) {
                if (cursorpos.x >= Skin.Object[teller].x
                        && cursorpos.y >= Skin.Object[teller].y
                        && cursorpos.x <=
                        Skin.Object[teller].x + Skin.Object[teller].w
                        && cursorpos.y <=
                        Skin.Object[teller].y + Skin.Object[teller].h) {
                    switch (teller) {
                    case PlaySwitch:
                        main_play_control(ID_PLAY, hWnd);
                        break;
                    case PauseSwitch:
                        main_play_control(ID_PAUSE, hWnd);
                        break;
                    case StopSwitch:
                        main_play_control(ID_STOP, hWnd);
                        break;
                    case RepeatSwitch:
                        main_play_control(ID_REPEAT, hWnd);
                        break;
                    case ShuffleSwitch:
                        main_play_control(ID_SHUFFLE, hWnd);
                        break;
                    case EqSwitch:
                        main_play_control(ID_EQUALIZER, hWnd);
                        break;
                    case PlaylistButton:
                        main_play_control(ID_PLAYLIST, hWnd);
                        break;
                    case NextButton:
                        main_play_control(ID_NEXT, hWnd);
                        break;
                    case PrevButton:
                        main_play_control(ID_PREVIOUS, hWnd);
                        break;
                    case MinimizeButton:
                        if (options.show_on_taskbar)
                            ShowWindow(hWnd, SW_MINIMIZE);
                        else
                            ShowWindow(hWnd, SW_HIDE);
                        break;
                    case NextSkinButton:
                        main_play_control(ID_LOADSKIN, hWnd);
                        break;
                    case ExitButton:
                        DestroyWindow(hWnd);
                        break;
                    case EjectButton:
                        main_play_control(ID_LOAD, hWnd);
                        break;
                    }
                }
            }

            // options.show_remaining_time time
            if (cursorpos.x >= Skin.Object[TimeText].x
                    && cursorpos.y >= Skin.Object[TimeText].y
                    && cursorpos.x <=
                    (Skin.Object[TimeText].x + (Skin.Object[TimeText].w * 8))
                    && cursorpos.y <=
                    (Skin.Object[TimeText].y + Skin.Object[TimeText].h)) {
                options.show_remaining_time = !options.show_remaining_time;
                main_draw_time(hWnd);
                break;
            }
            main_draw_controls_all(hWnd);
            break;
        }

    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC     winhdc = BeginPaint(hWnd, &ps);
            if (graphics.bmp_main_up) {
                BITMAP  bm;
                int     teller, teller2 = 1;

                HPALETTE oldpal;
                oldpal =
                    SelectPalette(drawables.dc_main, graphics.pal_main,
                                  FALSE);
                RealizePalette(drawables.dc_main);

                GetObject(graphics.bmp_main_up, sizeof(bm), &bm);
                window_bmp_blt(hWnd, graphics.bmp_main_up, ps.rcPaint.left,
                               ps.rcPaint.top, ps.rcPaint.right,
                               ps.rcPaint.bottom, ps.rcPaint.left,
                               ps.rcPaint.top);
                for (teller = Eq1; teller <= Eq8; teller++)
                    main_draw_vu_from_value(hWnd, teller,
                                            options.eq_settings
                                            [teller2++]);
                main_draw_vu_from_value(hWnd, VolumeSlider, globals.m_iVolume);

                if(globals.m_bStreaming == TRUE)
                    main_draw_vu_from_value(windows.wnd_main, PositionSlider, globals.m_iStreamingPortion);
                else
                    main_draw_vu_from_value(windows.wnd_main, PositionSlider, globals.main_int_track_position);

                main_draw_tracknr(hWnd);
                main_draw_title(hWnd);
                main_draw_time(hWnd);
                main_draw_bitrate(hWnd);
                main_draw_frequency(hWnd);

                main_draw_controls_all(hWnd);
                SelectPalette(drawables.dc_main, oldpal, FALSE);
            }
            EndPaint(hWnd, &ps);
            return 0;
        }
    case WM_MOVE:
        options.main_window_pos.x = (int) (short) LOWORD(lParam);	// horizontal position
        options.main_window_pos.y = (int) (short) HIWORD(lParam);	// vertical position
        return 0;

    case WM_SYSKEYDOWN:
    case WM_KEYDOWN:
        {
            const BOOL bAltIsDown = (GetAsyncKeyState(VK_MENU)  & 0x8000) ? TRUE : FALSE;
            const BOOL bCtrlIsDown = (GetAsyncKeyState(VK_CONTROL)  & 0x8000) ? TRUE : FALSE;
            const BOOL bShiftIsDown = (GetAsyncKeyState(VK_SHIFT)  & 0x8000) ? TRUE : FALSE;
            CP_HandleKeyPress_Player(hWnd, (int)wParam, bAltIsDown, bCtrlIsDown, bShiftIsDown);
        }
        return 0;

    case WM_DESTROY:
        if (options.remember_playlist == TRUE)
            playlist_write_default();
        CPlaylistWindow_Destroy();
        //		CPlayerWindow_Destroy();
        options_write();
        CPL_DestroyPlaylist(globals.m_hPlaylist);
        CPI_Player__Destroy(globals.m_hPlayer);
        CPIC_FreeIndicators();
#if _DEBUG
        globals.m_hPlaylist = NULL;
        globals.m_hPlayer = NULL;
#endif
        PostQuitMessage(0);
        break;
    case WM_COMMAND:
        {
            int     accelreturn = main_play_control(LOWORD(wParam), hWnd);
            main_draw_controls_all(hWnd);
            return accelreturn;
        }

        // Set the global window handle and handle normally
    case WM_NCCREATE:
        windows.wnd_main = hWnd;
        return DefWindowProc(hWnd, message, wParam, lParam);
        break;

    case WM_DROPFILES:
        {
            const BOOL bCtrlIsDown = (GetAsyncKeyState(VK_CONTROL)  & 0x8000) ? TRUE : FALSE;
            HDROP hDrop = (HDROP)wParam;

            // Replace the current list by default - append if CTRL is down
            CPL_SyncLoadNextFile(globals.m_hPlaylist);
            if(bCtrlIsDown == FALSE)
            {
                CPL_Empty(globals.m_hPlaylist);
                globals.m_enPlayerState = cppsStopped;
                CPL_AddDroppedFiles(globals.m_hPlaylist, hDrop);
                CPL_PlayItem(globals.m_hPlaylist, TRUE, pmCurrentItem);
            }
            else
                CPL_AddDroppedFiles(globals.m_hPlaylist, hDrop);
        }

    case WM_HOTKEY:
        {
            const int iIDHotKey = (int)wParam;

            if(iIDHotKey == CP_HOTKEY_NEXT)
                CPVERB_NextTrack(vaDoVerb, hWnd);
            if(iIDHotKey == CP_HOTKEY_PREV)
                CPVERB_PrevTrack(vaDoVerb, hWnd);
            if(iIDHotKey == CP_HOTKEY_STOP)
                CPVERB_Stop(vaDoVerb, hWnd);
            if(iIDHotKey == CP_HOTKEY_PLAY0 || iIDHotKey == CP_HOTKEY_PLAY1)
            {
                if(globals.m_enPlayerState == cppsPlaying)
                    CPVERB_Pause(vaDoVerb, hWnd);
                else
                    CPVERB_Play(vaDoVerb, hWnd);
            }

        }

    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return (0);
}

int     main_play_control(WORD wParam, HWND hWnd)
{
    switch (wParam)
    {
    case ID_PLAYLIST:
        CPVERB_TogglePlaylistWindow(vaDoVerb, hWnd);
        return !options.show_playlist;
        break;

    case ID_REPEAT:
        CPVERB_ToggleRepeat(vaDoVerb, hWnd);
        return !options.shuffle_play;

    case ID_EXIT:
        CPVERB_Exit(vaDoVerb, hWnd);
        break;

    case ID_SHUFFLE:
        CPVERB_ToggleShuffle(vaDoVerb, hWnd);
        return !options.shuffle_play;

    case ID_EQUALIZER:
        CPVERB_ToggleEqualiser(vaDoVerb, hWnd);
        return !options.equalizer;

    case ID_STOP:
        CPVERB_Stop(vaDoVerb, hWnd);
        break;

    case ID_PLAY:
        CPVERB_Play(vaDoVerb, hWnd);
        break;

    case ID_PAUSE:
        CPVERB_Pause(vaDoVerb, hWnd);
        return 0;

    case ID_NEXT:
        CPVERB_NextTrack(vaDoVerb, hWnd);
        break;

    case ID_PREVIOUS:
        CPVERB_PrevTrack(vaDoVerb, hWnd);
        break;

    case ID_LOAD:
        CPVERB_OpenFile(vaDoVerb, hWnd);
        break;

    case ID_VOLUMEUP:
        CPVERB_VolumeUp(vaDoVerb, hWnd);
        break;

    case ID_VOLUMEDOWN:
        CPVERB_VolumeDown(vaDoVerb, hWnd);
        break;

    case ID_SEEKFORWARD:
        CPVERB_SkipForwards(vaDoVerb, hWnd);
        break;

    case ID_SEEKBACKWARD:
        CPVERB_SkipBackwards(vaDoVerb, hWnd);
        break;

    case ID_ABOUT:
        CPVERB_About(vaDoVerb, hWnd);
        break;

    case ID_DRAWSKINLINES:
        {
            int     teller;
            HDC     windc = GetDC(hWnd);
            HPEN    pen = CreatePen(PS_NULL, 0, 0);
            HPEN    oldpen = SelectObject(windc, pen);
            for (teller = PlaySwitch; teller < Lastone; teller++) {
                HBRUSH  brush =
                    CreateSolidBrush(RGB(255 * rand(), 255 * rand(),
                                         255 * rand()));
                HBRUSH  oldbrush = SelectObject(windc, brush);
                Rectangle(windc, Skin.Object[teller].x,
                          Skin.Object[teller].y,
                          Skin.Object[teller].x +
                          Skin.Object[teller].w + 2,
                          Skin.Object[teller].y + Skin.Object[teller].h +
                          2);
                SelectObject(windc, oldbrush);
                DeleteObject(brush);
            }
            SelectObject(windc, oldpen);
            DeleteObject(pen);
            ReleaseDC(hWnd, windc);
        }