MainFrm.cpp

// MainFrm.cpp : implementation of the CMainFrame class
//

#include "stdafx.h"
#include "TransClient.h"
#include "ConnectDialog.h"
#include "ProfileDialog.h"
#include "globalvar.h"
#include <winsock.h>

#include "MainFrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define VIDEO_WIDTH 150 //the width of the combo box
#define IDC_SNAP_COMBO 100

extern char ServerAddress[20];
extern CClient m_client;
extern HWND pPlayer;

// CMainFrame

IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
        //{{AFX_MSG_MAP(CMainFrame)
        ON_WM_CREATE()
        ON_COMMAND(IDM_CONNECT, OnConnect)
        ON_COMMAND(IDM_DISCONNECT, OnDisconnect)
        ON_COMMAND(IDM_STOP, OnStop)
        ON_COMMAND(IDM_SETTING, OnSetting)
        ON_COMMAND(IDM_REQUEST, OnRequest)
        ON_COMMAND(ID_APP_EXIT, OnAppExit)
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()

static UINT indicators[] =
{
        ID_SEPARATOR,           // status line indicator
        ID_INDICATOR_CAPS,
        ID_INDICATOR_NUM,
        ID_INDICATOR_SCRL,
};

// CMainFrame construction/destruction

CMainFrame::CMainFrame()
{
        // TODO: add member initialization code here
        m_SocketIsAvailable = false;
        VideoIsRequested = false;
}

CMainFrame::~CMainFrame()
{
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
        int index;
        CRect rect;

        if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
                return -1;
        
        if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
                | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
                !m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
        {
                TRACE0("Failed to create toolbar\n");
                return -1;      // fail to create
        }

        if (!m_wndStatusBar.Create(this) ||
                !m_wndStatusBar.SetIndicators(indicators,
                  sizeof(indicators)/sizeof(UINT)))
        {
                TRACE0("Failed to create status bar\n");
                return -1;      // fail to create
        }

        // TODO: Delete these three lines if you don't want the toolbar to
        //  be dockable
        m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
        EnableDocking(CBRS_ALIGN_ANY);
        DockControlBar(&m_wndToolBar);


    //set up the ComboBox control as a snap mode select box
    //
    //First get the index of the placeholder's position in the toolbar

    index = 0;
    
        while(m_wndToolBar.GetItemID(index)!=ID_COMBO)
                index++;

    //next convert that button to a seperator and get its position
    m_wndToolBar.SetButtonInfo(index, ID_COMBO, TBBS_SEPARATOR, VIDEO_WIDTH);
    m_wndToolBar.GetItemRect(index, &rect);

    //expand the rectangle to allow the combo box room to drop down
    rect.top += 7;
    rect.bottom += 100;

    // then .Create the combo box and show it
    if (!m_wndToolBar.m_wndVideo.Create(WS_CHILD | WS_VISIBLE | WS_VSCROLL | CBS_AUTOHSCROLL | 
                                                                               CBS_DROPDOWNLIST | CBS_HASSTRINGS | CBS_SORT,
                                                                                   rect, &m_wndToolBar, IDC_SNAP_COMBO))
    {
       TRACE0("Failed to create combo-box\n");
       return FALSE;
    }
    m_wndToolBar.m_wndVideo.ShowWindow(SW_SHOW);

    return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
        cs.style = WS_OVERLAPPED | WS_SYSMENU | WS_BORDER;
        if( !CFrameWnd::PreCreateWindow(cs) )
                return FALSE;
        // TODO: Modify the Window class or styles here by modifying
        //  the CREATESTRUCT cs

        return TRUE;
}

// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
        CFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
        CFrameWnd::Dump(dc);
}

#endif //_DEBUG

// CMainFrame message handlers

void CMainFrame::OnConnect() 
{
        // TODO: Add your command handler code here
        char temp[20];
        char inbuf[100];
        int error = 0;

        if(m_SocketIsAvailable)
        {
                MessageBox("Connection has been created!","Connect",MB_OK);
                return;
        }

        WSADATA wsd;
        
        if(WSAStartup(0x0101,&wsd)!=0)
        {
                MessageBox("Unable to start socket.","Socket Error",MB_OK);
                return;
        }
        else
        {
                try
                {
                        m_client.m_ControlSock.Cleanup();
                        m_client.m_ControlSock.Create(SOCK_STREAM);
                }
                catch(const char* e)
                {
                        MessageBox(e,"Socket Error",MB_OK);
                        return;
                }
        }

        CConnectDialog ConnectDlg;
                
        if(ConnectDlg.DoModal()==IDOK)
        {
                try
                {
                        if(ConnectDlg.m_LocalHost==0)
                        {
                                gethostname ( temp, 20 ); 
                                //CSockAddr saServer;
                                //ClientSocket.SetLoginName(IPAddrDlg.m_LoginName.operator LPCTSTR());
                                m_client.m_ControlSock.Connect(m_client.m_ControlSock.GetHostByName(temp,23));
                                sprintf(ServerAddress, "%s\n", "127.0.0.1");
                        }
                        else
                        {
                                sprintf(temp,"%d.%d.%d.%d",ConnectDlg.m_nAddr[0],ConnectDlg.m_nAddr[1],ConnectDlg.m_nAddr[2],ConnectDlg.m_nAddr[3]);
                                CSockAddr saServerCtrl(temp,23);
                                m_client.m_ControlSock.Connect(saServerCtrl);
                                sprintf(ServerAddress, "%s\n", temp);
                        }

                        m_client.m_ControlSock.Print("connect");

                        //receive the video list
                        m_client.m_ControlSock.ReadLine(inbuf,sizeof inbuf,1800);

                        while(stricmp(inbuf,"end"))
                        {
                                AddVideo(inbuf);
                                m_client.m_ControlSock.ReadLine(inbuf,sizeof inbuf,1800);
                        }
                        m_SocketIsAvailable = true;
        }
                catch(const char* e)
                {
                        m_client.m_ControlSock.Cleanup();
                        MessageBox(e,"Socket Error",MB_OK);
                        m_SocketIsAvailable = false;
                        return; 
                }
        }       
}

void CMainFrame::OnDisconnect() 
{
        // TODO: Add your command handler code here
        char inbuf[100];
        if(m_SocketIsAvailable)
        {
                //send disconnect command
                try
                {
                        m_client.m_ControlSock.Print("break");

                        m_client.m_ControlSock.ReadLine(inbuf,sizeof inbuf,1800);
                        if(!stricmp(inbuf,"end"))
                        {
                                
                                m_client.m_ControlSock.Cleanup();
                                m_SocketIsAvailable = false;
                                VideoIsRequested = false;
                                m_wndToolBar.m_wndVideo.ResetContent();
                        }
                        else
                        {
                                MessageBox("Handshake error","Client",MB_OK);
                                return;
                        }
                }
                catch(const char* e)
                {       
                        m_client.m_ControlSock.Cleanup();
                        MessageBox(e,"Socket Error",MB_OK);
                        m_SocketIsAvailable = false;
                        VideoIsRequested = false;
                        m_wndToolBar.m_wndVideo.ResetContent();
                        return; 
                }
        }
        return;
}

void CMainFrame::OnStop() 
{
        // TODO: Add your command handler code here
        char inbuf[100];
        if(m_SocketIsAvailable)
        {
                //send disconnect command
                try
                {
                        m_client.m_ControlSock.Print("stop");

                        m_client.m_ControlSock.ReadLine(inbuf,sizeof inbuf,1800);
                        if(!stricmp(inbuf,"end"))
                        {
                                VideoIsRequested = false;
                        }
                        else
                        {
                                MessageBox("Handshake error","Client",MB_OK);
                                return;
                        }
                }
                catch(const char* e)
                {       
                        m_client.m_ControlSock.Cleanup();
                        MessageBox(e,"Socket Error",MB_OK);
                        m_SocketIsAvailable = false;
                        VideoIsRequested = false;
                        //m_VideoList.DeleteAllItems();
                        return; 
                }
        }
        return;
}

void CMainFrame::OnSetting() 
{
        // TODO: Add your command handler code here
        CProfileDialog ProfileDlg(NULL, &m_client.m_profile);
        if(ProfileDlg.DoModal()==IDOK)
        {
                m_client.SaveProfile();
        }
}

void CMainFrame::OnRequest() 
{
        // TODO: Add your command handler code here
        char inbuf[100];
        if(VideoIsRequested)
        {
                MessageBox("You have already requested a video.","",MB_OK);
                return;
        }

        // TODO: Add your control notification handler code here
        char temp[100];
        char fn[100];
        
        if(m_wndToolBar.m_wndVideo.GetLBText(m_wndToolBar.m_wndVideo.GetCurSel(), fn)!=CB_ERR)
        {
                if(m_SocketIsAvailable)
                {
                        //send profile
                        //format of profile:  profile:FrameSize:FrameRate:color:BitRate

                        sprintf(temp,"profile:%d:%d:%d:%d",m_client.m_profile.FrameSize,
                                m_client.m_profile.FrameRate,m_client.m_profile.color,m_client.m_profile.BitRate);

                        m_client.m_ControlSock.Print(temp);

                        m_client.m_ControlSock.ReadLine(inbuf, sizeof inbuf, 1000);
                        if(stricmp(inbuf,"end"))
                        {
                                MessageBox("Handshake error","Client",MB_OK);
                                return;
                        }

                        //send a request

                        sprintf(temp,"request:");
                        strcat(temp, fn);
                        try
                        {
                                m_client.m_ControlSock.Print(temp);
                                m_client.m_ControlSock.ReadLine(inbuf,sizeof inbuf,1000);

                                m_client.m_DataPort = atoi(inbuf);

                                m_client.m_ControlSock.ReadLine(inbuf,sizeof inbuf,1000);
                                
                                if(!stricmp(inbuf,"end"))
                                {
                                        m_DecodingThread = new CDecodingThread(&m_client);
                                        m_DecodingThread->m_bAutoDelete = true;
                                        m_DecodingThread->CreateThread();       
                                        VideoIsRequested = true;
                                }
                                else
                                {
                                        MessageBox("Handshake error","Client",MB_OK);
                                        return;
                                }
                        }
                        catch(const char* e)
                        {       
                                return;
                        }
                }
        }
        return;
}

void CMainFrame::AddVideo(const char *video)
{
        m_wndToolBar.m_wndVideo.AddString(video);
}

void CMainFrame::OnAppExit() 
{
        // TODO: Add your command handler code here
        m_wndToolBar.m_wndVideo.ResetContent();
        m_client.m_ControlSock.Cleanup();
        /*
        if(m_SocketIsAvailable)
        {
                //send disconnect command
                try
                {
                        m_client.m_ControlSock.Print("disconnect");
                        m_client.m_ControlSock.ReadLine(temp,sizeof temp,100);
                        if(!stricmp(temp,"end"))
                        {
                                m_client.m_ControlSock.Cleanup();
                                m_SocketIsAvailable = false;
                                m_VideoIsRequested = false;
                        }
                        else
                                MessageBox("Communication Error","Error",MB_OK);
                }
                catch(const char* e)
                {       
                        m_client.m_ControlSock.Cleanup();
                        MessageBox(e,"Socket Error",MB_OK);
                        m_SocketIsAvailable = false;
                        m_VideoIsRequested = false;
                }
        }
        */
        DestroyWindow();
}

---