trackview.cpp

WINCE XAUDIO可播放各种音乐格式内附SOURCE CODE可以再不同CPU 平台编译测试

TrackView::TrackView(HWND parent, WCEPlayer *player, 
                     int x, int y, int width, int height) 
{
    WNDCLASS wclass;

    wclass.style         = CS_HREDRAW | CS_VREDRAW;
    wclass.lpfnWndProc   = TrackViewWindowProc;
    wclass.cbClsExtra    = 0;
    wclass.cbWndExtra    = 0;
    wclass.hInstance     = player->m_Instance;
    wclass.hIcon         = 0;
    wclass.hCursor       = NULL;
    wclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wclass.lpszMenuName  = NULL;
    wclass.lpszClassName = XA_TRACKVIEW_CLASS_NAME;

    RegisterClass(&wclass);

    m_Timecode.h = m_Timecode.m = m_Timecode.s = -1;
    m_Visible    = TRUE;
    m_Height     = height;
    m_Width      = width;
    
    m_Window = CreateWindow(
        XA_TRACKVIEW_CLASS_NAME,           // class name
        NULL,                              // caption
        WS_CHILD,                          // style
        x,                                 // x pos
        y,                                 // y pos
        m_Width,                           // x size
        m_Height,                          // y size
        parent,                            // parent
        NULL,                              // menu
        player->m_Instance,                // program instance
        this);                             // creation params

    // load bitmaps
    m_Images.timecode.LoadFromResource(player->m_Instance, ID(IDB_LCD_DIGITS_LARGE));
    m_Images.duration.LoadFromResource(player->m_Instance, ID(IDB_LCD_DIGITS_SMALL));
    m_Images.bitrate.LoadFromResource(player->m_Instance, ID(IDB_LCD_DIGITS_TINY), 3);
    m_Images.frequency.LoadFromResource(player->m_Instance, ID(IDB_LCD_DIGITS_TINY), 2);
    m_Images.state.LoadFromResource(player->m_Instance, ID(IDB_LCD_STATES), 4);
    m_Images.channels.LoadFromResource(player->m_Instance, ID(IDB_LCD_CHANNELS), 2);
    m_Images.khz.LoadFromResource(player->m_Instance, ID(IDB_LCD_KHZ));
    m_Images.kbps.LoadFromResource(player->m_Instance, ID(IDB_LCD_KBPS));

    // place bitmaps
    ComputeItemPositions();

    GetClientRect(m_Window, &m_Bounds);
    SetTimecode(0, 0, 0);
	SetDuration(0);
	SetChannels(1);
	SetState(XA_PLAYER_STATE_STOPPED);
	SetFrequency(0);
	SetBitrate(0);
}


/*----------------------------------------------------------------------
|       TrackView::Show
+---------------------------------------------------------------------*/
void 
TrackView::Show(void)
{
    m_Visible = TRUE;
    ShowWindow(m_Window, SW_SHOW);
    UpdateWindow(m_Window);
}

/*----------------------------------------------------------------------
|       TrackView::Hide
+---------------------------------------------------------------------*/
void 
TrackView::Hide(void)
{
    m_Visible = FALSE;
    ShowWindow(m_Window, SW_HIDE);
    UpdateWindow(m_Window);
}

/*----------------------------------------------------------------------
|       TrackView::ComputeItemPositions
+---------------------------------------------------------------------*/
void 
TrackView::ComputeItemPositions(void)
{
    // initialize the item positions
    int max_height = 0;

    // set image parameters
    m_Images.timecode.SetDigitSpacing(XA_TRACKVIEW_TIMECODE_DIGIT_SPACING);
    m_Images.duration.SetDigitSpacing(XA_TRACKVIEW_DURATION_DIGIT_SPACING);
    m_Images.frequency.SetDigitSpacing(XA_TRACKVIEW_FREQUENCY_DIGIT_SPACING);
    m_Images.bitrate.SetDigitSpacing(XA_TRACKVIEW_BITRATE_DIGIT_SPACING);

    // compute layout
    int x = m_Images.timecode.GetWidth()+XA_TRACKVIEW_STATE_SPACING;
    int y = 0;
    m_Images.state.Move(x, y);
    x += m_Images.state.GetWidth() + XA_TRACKVIEW_STATE_SPACING;
    m_Images.duration.Move(x, y);
    x += m_Images.duration.GetWidth() + XA_TRACKVIEW_CHANNELS_SPACING;
    m_Images.channels.Move(x, y);
    x = m_Images.duration.m_Bounds.left;
    y = m_Images.duration.m_Bounds.bottom;
    m_Images.frequency.Move(x, y+XA_TRACKVIEW_FREQUENCY_V_SPACING);
    x += m_Images.frequency.GetWidth() + XA_TRACKVIEW_FREQUENCY_LABEL_SPACING;
    m_Images.khz.Move(x, y+XA_TRACKVIEW_FREQUENCY_V_SPACING);
    x += m_Images.khz.GetWidth() + XA_TRACKVIEW_FREQUENCY_BITRATE_SPACING;
    m_Images.bitrate.Move(x, y+XA_TRACKVIEW_BITRATE_V_SPACING);
    x += m_Images.bitrate.GetWidth() + XA_TRACKVIEW_BITRATE_LABEL_SPACING;
    m_Images.kbps.Move(x, y+XA_TRACKVIEW_BITRATE_V_SPACING);

    // now center the whole view
    int dx;
    int dy;
    max_height = m_Images.channels.m_Bounds.bottom-m_Images.channels.m_Bounds.top;

    dx = (m_Width - m_Images.channels.m_Bounds.right)/2;
    dy = (m_Height - max_height)/2;
    m_Images.timecode.Move(dx, dy);
    m_Images.duration.Move(dx, dy);
    m_Images.state.Move(dx, dy);
    m_Images.channels.Move(dx, dy);
    m_Images.frequency.Move(dx, dy);
    m_Images.bitrate.Move(dx, dy);
    m_Images.khz.Move(dx, dy);
    m_Images.kbps.Move(dx, dy);
}

/*----------------------------------------------------------------------
|       TrackView::SetTimecode
+---------------------------------------------------------------------*/
void
TrackView::SetTimecode(int h, int m, int s)
{
    if (m == m_Timecode.m &&
        s == m_Timecode.s) return;

    m_Timecode.h = h;
	m_Timecode.m = m;
	m_Timecode.s = s;

    if (m_Visible) {
        m_Images.timecode.SetValue(m,s);
        InvalidateRect(m_Window, &m_Images.timecode.m_Bounds, FALSE);
    }
}

/*----------------------------------------------------------------------
|       TrackView::SetDuration
+---------------------------------------------------------------------*/
void
TrackView::SetDuration(int seconds)
{
    if (m_Visible) {
        m_Images.duration.SetValue(seconds);
        InvalidateRect(m_Window, &m_Images.duration.m_Bounds, FALSE);

    }
}

/*----------------------------------------------------------------------
|       TrackView::SetState
+---------------------------------------------------------------------*/
void
TrackView::SetState(int state)
{
    if (m_Visible) {
	    switch (state) {
	      case XA_PLAYER_STATE_PLAYING:
		    m_Images.state.m_Index = 2;
	    	break;

	      case XA_PLAYER_STATE_PAUSED:
		    m_Images.state.m_Index = 1;
		    break;

	      case XA_PLAYER_STATE_STOPPED:
		    m_Images.state.m_Index = 0;
		    break;

	      default:
		    m_Images.state.m_Index = 3;
		    break;
	    }
        InvalidateRect(m_Window, &m_Images.state.m_Bounds, FALSE);
    }
}

/*----------------------------------------------------------------------
|       TrackView::SetChannels
+---------------------------------------------------------------------*/
void
TrackView::SetChannels(int channels)
{
    if (m_Visible) {
        if (channels == 1) {
		    m_Images.channels.m_Index = 0;
	    } else {
		    m_Images.channels.m_Index = 1;
	    }
        InvalidateRect(m_Window, &m_Images.channels.m_Bounds, FALSE);
    }
}

/*----------------------------------------------------------------------
|       TrackView::SetFrequency
+---------------------------------------------------------------------*/
void
TrackView::SetFrequency(int frequency)
{
    if (m_Visible) {
        m_Images.frequency.SetValue(frequency/1000);
        InvalidateRect(m_Window, &m_Images.frequency.m_Bounds, FALSE);
    }
}

/*----------------------------------------------------------------------
|       TrackView::SetBitrate
+---------------------------------------------------------------------*/
void
TrackView::SetBitrate(int bitrate)
{   
    if (m_Visible) {
        m_Images.bitrate.SetValue(bitrate);
        InvalidateRect(m_Window, &m_Images.bitrate.m_Bounds, FALSE);
    }
}

/*----------------------------------------------------------------------
|       TrackView::HandleWindowsMessage
+---------------------------------------------------------------------*/
LRESULT
TrackView::HandleWindowsMessage(HWND window,
                                UINT message, 
                                WPARAM wparam, 
                                LPARAM lparam)
{
    switch (message) {
      PAINTSTRUCT ps;
      case WM_PAINT:
        HDC dc;
        HDC bitmap_dc;

        BeginPaint(window, &ps);

        dc = GetDC(window);
        bitmap_dc = CreateCompatibleDC(dc);

        m_Images.timecode.Paint(bitmap_dc, dc);
        m_Images.duration.Paint(bitmap_dc, dc);
        m_Images.state.Paint(bitmap_dc, dc);
        m_Images.channels.Paint(bitmap_dc, dc);
        m_Images.frequency.Paint(bitmap_dc, dc);
        m_Images.bitrate.Paint(bitmap_dc, dc);
        m_Images.khz.Paint(bitmap_dc, dc);
        m_Images.kbps.Paint(bitmap_dc, dc);

        DeleteDC(bitmap_dc);

        EndPaint(window, &ps);
		return 0;
    }

	return DefWindowProc(window, message, wparam, lparam);
}