freeampui.cpp

FreeAMP(MP3播放)程序源代码-用来研究MP3解码

}

FreeAmpUI::
~FreeAmpUI()
{
    // Be good citizens and clean up after ourselves
    RemoveTrayIcon();

    DeleteBitmaps();
    DeleteRegions();

    if(m_viewList)
    {
        m_viewList->DeleteAll();
        delete m_viewList;
    }

    if(m_prevSongInfoText)
        delete [] m_prevSongInfoText;

    if(m_uiThread)
        delete m_uiThread;

    if(m_trayIcon)
        DeleteObject(m_trayIcon);
}

void 
FreeAmpUI::
Create()
{
    assert( m_hwnd );

    // We want people to be able to drop files on the player
    DragAcceptFiles(m_hwnd, TRUE);

    // Where are things located? What shape are they?
    InitializeRegions();

    // Center the window and make sure it is the right size
    assert( m_windowRegion );

    RECT windowRect;

    GetRgnBox(m_windowRegion, &windowRect);
    
    int32 left, top;

    m_prefs->GetWindowPosition( &left, 
                                &top,
                                &m_width, 
                                &m_height);

    if(left == 0 && top == 0 && m_width == 0 && m_height == 0)
    {
        m_width = windowRect.right - windowRect.left;
        m_height = windowRect.bottom - windowRect.top;
        left = (GetSystemMetrics (SM_CXFULLSCREEN) - m_width) / 2;
	    top = (GetSystemMetrics (SM_CYFULLSCREEN) - m_height) / 2;
    }
    		
	SetWindowPos (	m_hwnd,
					0, 
					left, 
					top, 
					m_width, 
					m_height, 
					SWP_NOZORDER);

    // copy window region so windows doesn't take our region
    HRGN windowRegion = CreateRectRgn(0,0,0,0);
    
    CombineRgn( windowRegion,
                windowRegion,
                m_windowRegion,
                RGN_OR);


    // Change window region
    SetWindowRgn(m_hwnd, windowRegion, TRUE);

    // What do we look like?
    LoadBitmaps();

    // Create Controls
    CreateControls();

    CreateTooltips();

    m_trayIcon = LoadIcon(g_hinst, MAKEINTRESOURCE(IDI_EXE_ICON));

    ReadPreferences();

    // platform specific initialization
    OSVERSIONINFO osid;

	osid.dwOSVersionInfoSize = sizeof (osid);
	GetVersionEx (&osid);

	switch (osid.dwPlatformId) 
    {
        // Window 3.x
	    case VER_PLATFORM_WIN32s:
		    break;

	    // Windows 95
	    case VER_PLATFORM_WIN32_WINDOWS:
 		    break;

	    // Windows NT
	    case VER_PLATFORM_WIN32_NT:
        {
		    if(osid.dwMajorVersion >= 4)
            {
                // this will allow us port access thru
                // inp and outp so the rio stuff will
                // work.

                const char* driver = "portio";
                char path[MAX_PATH];
                uint32 size = sizeof(path);

                m_prefs->GetPrefString(kInstallDirPref, path, &size);

                strcat(path, "\\");
                strcat(path, driver);
                strcat(path, ".sys");

                LoadDriver(driver, path);
            }

            break;
        }
    }
}

void 
FreeAmpUI::
Destroy()
{
    // platform specific uninitialization
    OSVERSIONINFO osid;

	osid.dwOSVersionInfoSize = sizeof (osid);
	GetVersionEx (&osid);

	switch (osid.dwPlatformId) 
    {
        // Window 3.x
	    case VER_PLATFORM_WIN32s:
		    break;

	    // Windows 95
	    case VER_PLATFORM_WIN32_WINDOWS:
 		    break;

	    // Windows NT
	    case VER_PLATFORM_WIN32_NT:
        {
		    if(osid.dwMajorVersion >= 4)
            {
                UnloadDriver("portio");
            }

            break;
        }
    }

    // Tell windows msg loop we wanna die
    PostQuitMessage(0);
}

void
FreeAmpUI::
ExitSizeMove()
{
    // save window position
    RECT windowRect;

    GetWindowRect(m_hwnd, &windowRect);
    
    m_prefs->SetWindowPosition( windowRect.left, 
                                windowRect.top,
                                windowRect.right - windowRect.left, 
                                windowRect.bottom - windowRect.top);
}

void 
FreeAmpUI::
MinMaxInfo(MINMAXINFO* info)
{
    /*char buf[256];

    wsprintf(buf,   "max width = %d\r\n"
                    "max height = %d\r\n"
                    "min width = %d\r\n"
                    "min height = %d\r\n", 
                    info->ptMaxTrackSize.x, 
                    info->ptMaxTrackSize.y, 
                    info->ptMinTrackSize.x, 
                    info->ptMinTrackSize.y);

    OutputDebugString(buf);*/
}

int32 
FreeAmpUI::
HitTest(int32 xPos, 
        int32 yPos)
{
    int32 result = 0;

    if(PtInRegion(m_playerRegion, xPos, yPos))
    {
        result = HTCAPTION;
    }
    else if(PtInRegion(m_controlRegions[kResizeControl], xPos, yPos))
    {
        result = HTSIZE;
    }
    else
    {
        result = HTCLIENT;
    }

    return result;
}

void
FreeAmpUI::
KeyDown(int32 keyCode)
{
    switch(keyCode) 
    { 
        case VK_PRIOR:
        case VK_NEXT:
        case VK_UP: 
        case VK_DOWN: 
        case VK_HOME: 
        case VK_END: 
        case VK_DELETE: 
        case 'A':
            if(m_playlistView->Visible() && m_playlistView->Enabled())
                m_playlistView->KeyPressed(keyCode);
            break;

        case 'O':
        {
            short state = GetKeyState(VK_CONTROL);

            if(state>>4)
            {
                SendMessage(m_hwnd, WM_COMMAND, kOpenControl, 0);
            }

            break;
        }

        case 'P':
        {
            short state = GetKeyState(VK_CONTROL);

            if(state>>4)
            {
                SendMessage(m_hwnd, WM_COMMAND, kPlayControl, 0);
            }

            break;
        }

        case 'U':
        {
            short state = GetKeyState(VK_CONTROL);

            if(state>>4)
            {
                SendMessage(m_hwnd, WM_COMMAND, kPauseControl, 0);
            }

            break;
        }

        case 'S':
        {
            short state = GetKeyState(VK_CONTROL);

            if(state>>4)
            {
                SendMessage(m_hwnd, WM_COMMAND, kStopControl, 0);
            }

            break;
        }

        case 'N':
        {
            short state = GetKeyState(VK_CONTROL);

            if(state>>4)
            {
                SendMessage(m_hwnd, WM_COMMAND, kNextControl, 0);
            }

            break;
        }

        case 'L':
        {
            short state = GetKeyState(VK_CONTROL);

            if(state>>4)
            {
                SendMessage(m_hwnd, WM_COMMAND, kLastControl, 0);
            }

            break;
        }
    }

}

void 
FreeAmpUI::
InitMenuPopup(HMENU menuHandle, 
              uint32 position, 
              bool systemMenu)
{
    /*if(systemMenu)
    {
        MENUITEMINFO mii;
        uint32 state = 0;
        Preferences prefs;
        bool stayOnTop;
        char szStayOnTop[] = "Stay On Top";
        char buffer[256];

        prefs.GetPrefBoolean(kStayOnTopPref, &stayOnTop);

        GetMenuString(  menuHandle, 
                        0, 
                        buffer, 
                        sizeof(buffer), 
                        MF_BYPOSITION);

        if(strcmp(buffer, szStayOnTop))
        {
            mii.cbSize = sizeof(MENUITEMINFO);
            mii.fMask = MIIM_TYPE;
            mii.fType = MFT_SEPARATOR;

            InsertMenuItem( menuHandle, 
                            0, 
                            TRUE, 
                            &mii);

            mii.cbSize = sizeof(MENUITEMINFO);
            mii.fMask = MIIM_TYPE|MIIM_STATE|MIIM_ID ;
            mii.fType = MFT_STRING;
            mii.fState = (stayOnTop ? MFS_CHECKED : MFS_UNCHECKED);
            mii.dwTypeData = szStayOnTop;
            mii.cch = strlen(szStayOnTop);
            mii.wID = kMenuStayOnTop;

            InsertMenuItem( menuHandle, 
                            0, 
                            TRUE,
                            &mii);
        }

        mii.cbSize = sizeof(MENUITEMINFO);
        mii.fMask = MIIM_STATE;
        mii.fState = (stayOnTop ? MFS_CHECKED : MFS_UNCHECKED);

        SetMenuItemInfo(menuHandle, 
                        0, 
                        TRUE, 
                        &mii);
    }*/
}

static void ResolveLink(char* buf, int32 length)
{
    assert(buf);

    if(buf)
    {
        HRESULT hres = NULL;

        hres = CoInitialize(NULL);

        if(SUCCEEDED(hres))
        {
            IShellLink* psl = NULL;

            // Get a pointer to the IShellLink interface
            hres = CoCreateInstance(CLSID_ShellLink, 
                                    NULL, 
                                    CLSCTX_INPROC_SERVER, 
                                    IID_IShellLink, 
                                    (void**)&psl);

            if(SUCCEEDED(hres))
            {
                IPersistFile* ppf;

                // Get a pointer to the IPersistFile interface
                hres = psl->QueryInterface(IID_IPersistFile, (void**)&ppf);

                if(SUCCEEDED(hres))
                {
                    WORD wsz[MAX_PATH];

                    // Ensure string is UNICODE
                    MultiByteToWideChar(CP_ACP, 
                                        0, 
                                        buf, 
                                        -1, 
                                        wsz, 
                                        MAX_PATH);

                    // Load Shortcut
                    hres = ppf->Load(wsz, STGM_READ);

                    if(SUCCEEDED(hres))
                    {
                        // Resolve the link
                        hres = psl->Resolve(NULL, SLR_ANY_MATCH|SLR_NO_UI);
                
                        if(SUCCEEDED(hres))
                        {
                            WIN32_FIND_DATA wfd;

                            // Resolve the link
                            hres = psl->GetPath(buf,length,&wfd, 0);
                        }
                    }

                    // Release the IPersist Interface
                    ppf->Release();
                }
        
                // Release the IShellLink Interface
                psl->Release();
            }

            CoUninitialize(); 
        }
    }
}

void 
FreeAmpUI::
DropFiles(HDROP dropHandle)
{
	int32 count;
    int32 originalCount = m_plm->CountItems();
	char file[MAX_PATH + 1];

	count = DragQueryFile(	dropHandle,
							-1L,
							file,
							sizeof(file));

	//m_target->AcceptEvent(new Event(CMD_Stop));

	for(int32 i = 0; i < count; i++)
	{
		DragQueryFile(	dropHandle,
						i,
						file,
						sizeof(file));

        char* pExtension = NULL;

        pExtension = strrchr(file, '.');

        if(pExtension && strcasecmp(pExtension, ".lnk") == 0)
        {