guiclient/guiclient.cpp

Go to the documentation of this file.

#include "wx/wxprec.h"
#ifndef WX_PRECOMP
        #warning Precompiled wx header not used.
    #include "wx/wx.h"
#endif
#include "wx/socket.h"
#include "wx/event.h"
#include "../trucknet/trucknet.h"
#include "wxMsg.h"
#include <math.h>

//create a wxPointList type
#include "wx/listimpl.cpp"
WX_DECLARE_LIST(wxPoint, wxPointList);
WX_DEFINE_LIST(wxPointList);


class GuiClientApp : public wxApp
{
  public:
        virtual bool OnInit();
        virtual int OnRun();
};

class GuiGraphFrame : public wxFrame
{
  public:
        GuiGraphFrame (const wxString &title,
                    const wxPoint &pos,
                    const wxSize &size);
        ~GuiGraphFrame();
        
};


class GuiMapFrame : public wxFrame
{
        public:
        GuiMapFrame (const wxString &title,
                    const wxPoint &pos,
                    const wxSize &size);
        ~GuiMapFrame();
        void OnPaint(wxPaintEvent &event);
        void OnClick(wxMouseEvent &event);
        void OnSize(wxSizeEvent &event);
        void PaintMe(wxDC& DC);
        void ScaleMe(wxDC& DC);
        void AddPoint(wxPoint point);
        void SetAngle(float radians);
        void Clear();

        private:
        //the list of path points
        wxPointList pointlist;

        //maximums and minimums, used for scaling
        int maxX, minX, maxY, minY;
        double scale;
        wxCoord offX, offY; //the offsets

        //the angle of the craft
        float angle; //in radians
        
        DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(GuiMapFrame, wxFrame)
        EVT_PAINT(              GuiMapFrame::OnPaint)
        EVT_LEFT_DOWN(  GuiMapFrame::OnClick)
        EVT_SIZE(               GuiMapFrame::OnSize)
END_EVENT_TABLE()

class GuiClientFrame : public wxFrame
{
  public:
        GuiClientFrame (const wxString &title,
                    const wxPoint &pos,
                    const wxSize &size);
        ~GuiClientFrame();


        //event handlers
    void OnQuit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);
        void OnMove(wxCommandEvent& event);
        void OnText(wxKeyEvent& event);
        void OnCheck(wxCommandEvent& event);
        void OnCommandEnter(wxCommandEvent& event);
        void OnSocket(wxSocketEvent& event);

private:
        wxTextCtrl *console;
        wxTextCtrl *commandline;
        wxSocketClient *sock;
        wxButton *forward, *left, *back, *right, *stop;
        wxMsg msg;
        wxMenu *menuMovement;
        GuiGraphFrame *graph;
        GuiMapFrame *map;
        void Connect();
    DECLARE_EVENT_TABLE()

};

GuiGraphFrame::GuiGraphFrame
        (const wxString &title, const wxPoint &pos, const wxSize &size)
    : wxFrame ( (wxFrame *) NULL, wxID_ANY, title, pos, size) 
{

}

GuiGraphFrame::~GuiGraphFrame()
{
}

GuiMapFrame::GuiMapFrame
        (const wxString &title, const wxPoint &pos, const wxSize &size)
    : wxFrame ( (wxFrame *) NULL, wxID_ANY, title, pos, size) 
{       
        scale = 1;
        offX = offY = 0;
        

}

GuiMapFrame::~GuiMapFrame()
{
}

enum event_t
{
        //menu
    ID_Quit = 1,
    ID_About,

        //movement (button + menu)
        ID_Stop,
        ID_Forward,
        ID_Back,
        ID_Left,
        ID_Right,

        //text
        ID_Commandline,
        ID_Console,

        //checkboxes
        ID_Map,
        ID_Graph,
        ID_Power,
        ID_Numeric,
        ID_FOView,
};


BEGIN_EVENT_TABLE(GuiClientFrame, wxFrame)
    EVT_MENU(ID_Quit,           GuiClientFrame::OnQuit)
    EVT_MENU(ID_About,          GuiClientFrame::OnAbout)
        EVT_MENU(ID_Stop,               GuiClientFrame::OnMove)
        EVT_MENU(ID_Forward,    GuiClientFrame::OnMove)
        EVT_MENU(ID_Back,               GuiClientFrame::OnMove)
        EVT_MENU(ID_Left,               GuiClientFrame::OnMove)
        EVT_MENU(ID_Right,              GuiClientFrame::OnMove)
        EVT_BUTTON(ID_Stop,             GuiClientFrame::OnMove)
        EVT_BUTTON(ID_Forward,  GuiClientFrame::OnMove)
        EVT_BUTTON(ID_Back,             GuiClientFrame::OnMove)
        EVT_BUTTON(ID_Left,             GuiClientFrame::OnMove)
        EVT_BUTTON(ID_Right,    GuiClientFrame::OnMove)
        EVT_CHECKBOX(ID_Map,    GuiClientFrame::OnCheck)
        EVT_CHECKBOX(ID_Graph,  GuiClientFrame::OnCheck)
        EVT_CHECKBOX(ID_Power,  GuiClientFrame::OnCheck)
        EVT_CHECKBOX(ID_Numeric,GuiClientFrame::OnCheck)
        EVT_CHECKBOX(ID_FOView, GuiClientFrame::OnCheck)
        EVT_CHAR(                               GuiClientFrame::OnText)
        EVT_TEXT_ENTER(ID_Commandline,  GuiClientFrame::OnCommandEnter)
        EVT_SOCKET(wxID_ANY,    GuiClientFrame::OnSocket)
END_EVENT_TABLE()

IMPLEMENT_APP(GuiClientApp)



bool GuiClientApp::OnInit()
{ 

  GuiClientFrame *frame = \
                new GuiClientFrame(wxT("RAPTOR Main Interface"), wxPoint(-1, -1), wxSize(600, 800));
  SetTopWindow(frame);
  return TRUE;  
}

int GuiClientApp::OnRun()
{
     // run application
     wxApp::OnRun();

         // return my exit code
     return TRUE;
} 


GuiClientFrame::GuiClientFrame
        (const wxString &title, const wxPoint &pos, const wxSize &size)
    : wxFrame ( (wxFrame *) NULL, wxID_ANY, title, pos, size) 
{
        //menus~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    wxMenuBar *menuBar = new wxMenuBar;
    wxMenu *menuFile = new wxMenu;
    menuMovement = new wxMenu;

    menuFile->Append( ID_About, wxT("&About...") );
    menuFile->AppendSeparator();
    menuFile->Append( ID_Quit, wxT("E&xit\tCtrl-C") );
    menuBar->Append( menuFile, wxT("&File") );
        
        menuMovement->Append( ID_Forward, wxT("&Forward\tCtrl-W"));
        menuMovement->Append( ID_Left, wxT("&Left\tCtrl-A"));
        menuMovement->Append( ID_Back, wxT("&Back\tCtrl-S"));
        menuMovement->Append( ID_Right, wxT("&Right\tCtrl-D"));
        menuMovement->Append( ID_Stop, wxT("&Stop\tCtrl-Space"));
    menuBar->Append( menuMovement, wxT("&Movement") );

    SetMenuBar( menuBar );

        //controls~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        //console
        console = new wxTextCtrl(this , ID_Console, wxT(""), wxDefaultPosition, \
                wxDefaultSize, wxTE_MULTILINE | wxTE_READONLY);
        commandline = new wxTextCtrl(this, ID_Commandline, wxT(""), \
                wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER );
        wxBoxSizer *textsizer = new wxBoxSizer(wxVERTICAL);
        textsizer->Add( commandline, 0, wxEXPAND);
        textsizer->Add( console, 1, wxEXPAND); 
        
        //buttons
        forward = new wxButton(this,ID_Forward,wxT("Forward"));
        left = new wxButton(this,ID_Left,wxT("Left"));
        back = new wxButton(this,ID_Back,wxT("Backward"));
        right = new wxButton(this,ID_Right,wxT("Right"));
        stop = new wxButton(this,ID_Stop,wxT("Stop"));

        wxGridSizer *buttonsizer = new wxGridSizer(1,0);
        buttonsizer->Add(forward ,0,wxEXPAND);
        buttonsizer->Add(left ,0,wxEXPAND);
        buttonsizer->Add(back ,0,wxEXPAND);
        buttonsizer->Add(right ,0,wxEXPAND);
        buttonsizer->Add(stop ,0,wxEXPAND);
        
        //checkboxes
        wxBoxSizer *checksizer = new wxBoxSizer(wxHORIZONTAL);
        checksizer->Add( new wxCheckBox(this, ID_Map, wxT("Map")));
        checksizer->Add( new wxCheckBox(this, ID_Graph, wxT("Graph")));
        checksizer->Add( new wxCheckBox(this, ID_Power, wxT("Power")));
        checksizer->Add( new wxCheckBox(this, ID_Numeric, wxT("Numeric")));
        checksizer->Add( new wxCheckBox(this, ID_FOView, wxT("FOView")));

        //main
        wxBoxSizer *mainsizer = new wxBoxSizer(wxHORIZONTAL);
        mainsizer->Add(textsizer, 1, wxEXPAND); //do we need wxEXPAND?
        mainsizer->Add(buttonsizer, 0, wxEXPAND);
        wxBoxSizer *allsizer = new wxBoxSizer(wxVERTICAL);
        allsizer->Add(checksizer, 0, wxEXPAND);
        allsizer->Add(mainsizer, 1, wxEXPAND);
        allsizer->SetSizeHints(this);
        this->SetSizer(allsizer);

        //other windows~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        graph = new GuiGraphFrame(wxT("RAPTOR Graphs"), wxPoint(-1, -1), wxSize(600, 800));
        map = new GuiMapFrame(wxT("RAPTOR Map"), wxPoint(-1, -1), wxSize(600, 800));

                
        //show window~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        CreateStatusBar();
        commandline->SetFocus();
        Show(true);
                        
        //sockets~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        sock = new wxSocketClient(wxSOCKET_NOWAIT);
        sock->SetEventHandler(*this);
        sock->SetNotify(wxSOCKET_CONNECTION_FLAG | wxSOCKET_INPUT_FLAG | \
                        wxSOCKET_LOST_FLAG);
        sock->Notify(true);
        Connect();

        //message system~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        msg.setsock(sock);
        msg.setconsole(console);
}

GuiClientFrame::~GuiClientFrame()
{
        delete sock;
}

void GuiClientFrame::Connect()
{
        SetStatusText( wxT("Connecting...") );
        // Ask user for server address
        wxString hostname = wxGetTextFromUser(
                wxT("Enter the server address:"),
                wxT("Connect ..."),
                wxT("localhost"));

        if(hostname.IsEmpty())
        {       Close( true );
                return;
        }
        wxIPV4address addr;
        addr.Hostname(hostname);
        addr.Service(GUI_PORT.PORT);
        sock->Connect(addr,false);//nonblocking
}

void GuiClientFrame::OnSocket(wxSocketEvent& event)
{
        const int buflen = 32; 
        char buf[buflen];
        int count;

        switch(event.GetSocketEvent())
        {
                case wxSOCKET_CONNECTION:
                        if(sock->IsConnected())
                                SetStatusText(wxT("Connected."));
                        else
                                SetStatusText(wxT("Connected???"));
                        break;
                case wxSOCKET_INPUT:
                        msg.recv();
                        //*console << wxT("Type: ") << wxString(msg.type().c_str(), *wxConvCurrent, msg.type().length()); //DEBUG
                        if( msg.type() == string("map"))
                        {
                                float x, y, theta;
                                msg >> x >> y >> theta;
                                map->AddPoint(wxPoint((int)(x*1000),(int)(y*1000)));
                                map->SetAngle(theta);
                                if(map->IsShown())
                                {
                                        wxClientDC DC(map);
                                        map->PaintMe(DC);
                                }
                        }
                        break;
                case wxSOCKET_LOST:
                        *console << wxT("Disconnected.\n");
                        Connect();
                        break;
                default:
                        SetStatusText(wxT("Unknown event on socket!"));
        }
}

void GuiClientFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    Close( true );
}

void GuiClientFrame::OnMove(wxCommandEvent& event)
{
        switch(event.GetId())
        {
                case ID_Forward:
                        msg << startmsg("forward") << endmsg;
                        break;
                case ID_Back:
                        msg << startmsg("back") << endmsg;
                        break;
                case ID_Left:
                        msg << startmsg("left") << endmsg;
                        break;
                case ID_Right:
                        msg << startmsg("right") << endmsg;
                        break;
                case ID_Stop:
                        msg << startmsg("stop") << endmsg;
                        break;
                        //TODO need messages for 'gps' 'kill' 'start'
                default:
                    wxMessageBox(wxT("Unknown movement!"),wxT("???"),wxOK | wxICON_INFORMATION );
        }
}


void GuiMapFrame::OnPaint(wxPaintEvent &event)
{
        wxPaintDC DC(this);
        this->ScaleMe(DC);
        this->PaintMe(DC);
        event.Skip();
}

void GuiMapFrame::OnSize(wxSizeEvent &event)
{
        wxClientDC DC(this);
        PaintMe(DC);
        event.Skip();
}

void GuiMapFrame::OnClick(wxMouseEvent &event)
{
        wxPoint p = event.GetPosition();
        p.x = (int)(p.x/scale) - offX;
        p.y = (int)(p.y/scale) - offY;
        AddPoint(p);
        wxClientDC DC(this);
        this->PaintMe(DC);

        event.Skip();
}


void GuiMapFrame::PaintMe(wxDC& DC)
{
        const int grid = 1000;
        wxCoord w, h;
        DC.GetSize(&w,&h);
        wxCoord i, j; //iterators


        DC.SetUserScale(scale, scale);

        //draw background
        DC.SetBackground(*wxWHITE_BRUSH);
        DC.SetBackgroundMode(wxSOLID);
        DC.Clear();
        
        //draw grid
        int radius;
        if (1 > 1/scale)
                radius = 1;
        else
                radius = (int)(1/scale);
        DC.SetPen(wxPen(*wxBLACK, 0));
        for(i = offX % grid; i < (int)(w/scale + offX); i += grid)
                for(j = offY % grid; j < (int)(h/scale + offX); j += grid)
                        DC.DrawCircle(i, j, radius);
                        

        //draw path
        if(!pointlist.IsEmpty())
                DC.DrawLines((wxList *)&pointlist, offX, offY);

        //draw truck
        if(pointlist.GetLast())
        {
                wxPoint* p = pointlist.GetLast()->GetData();
                DC.DrawCircle(p->x + offX, p->y + offY, 8/scale);
                DC.DrawLine(p->x + offX, p->y + offY,\
                        p->x + offX + (int)(10/scale*cos(angle)),\
                        p->y + offY + (int)(10/scale*sin(angle)));
        }

        
//draws a couple rounded rectangles
#if 0
        DC.SetPen(*wxWHITE_PEN);
        DC.SetBrush( *wxTRANSPARENT_BRUSH );
        DC.DrawRoundedRectangle(150, 270, 49, 29, 6);
        DC.DrawRoundedRectangle(200, 270, 49, 29, 6);
        DC.SetPen(*wxWHITE_PEN);
        DC.DrawLine(250, 270, 250, 310);
        DC.DrawLine(150, 300, 260, 300);
#endif  
}

void GuiMapFrame::AddPoint(wxPoint point)
{
        pointlist.Append(new wxPoint(point));

        if(pointlist.IsEmpty())
        {
                minX = maxX = point.x;
                minY = maxY = point.y;
        }
        else
        {
                
                if(point.x < minX)
                        minX = point.x;
                else if(point.x > maxX)
                        maxX = point.x;

                if(point.y < minY)
                        minY = point.y;
                else if(point.y > maxY)
                        maxY = point.y;
        }

        
        if(this->IsShown())
        {
                wxClientDC DC(this);
                ScaleMe(DC);
        }
}


//sets scale, offX, offY
void GuiMapFrame::ScaleMe(wxDC &DC)
{
        wxCoord w, h;
        double temp;

        DC.GetSize(&w,&h);
        if( (scale=(double)(maxX - minX)) != 0)
                scale = .9*w/scale;
        else
                scale = 1;

        if( (temp=(double)(maxY - minY)) != 0)
                temp = .9*h/temp;
        else
                temp = 1;

        if(temp < scale)
                scale = temp;


        offX = -(int)((maxX + minX - w/scale)/2);
        offY = -(int)((maxY + minY - h/scale)/2);
}

void GuiMapFrame::SetAngle(float radians)
{
        angle = radians;
}

void GuiClientFrame::OnCheck(wxCommandEvent& event)
{
        switch(event.GetId())
        {
                case ID_Map:
                        if (event.IsChecked())
                        {
                                map->Show(true);
                                //wxClientDC DC(map);
                                //while(!DC.Ok());//spin wait
                                //map->ScaleMe(DC);
                                

                        }
                        else
                                map->Show(false);
                        break;
                case ID_Graph:
                        if (event.IsChecked())
                                graph->Show(true);
                        else
                                graph->Show(false);
                        //TODO
                        break;
                case ID_Power:
                        if (event.IsChecked())
                                wxMessageBox(wxT("Power not yet implemented."),wxT("Not implemented"),wxOK | wxICON_INFORMATION );
                                ((wxCheckBox*)event.GetEventObject())->SetValue(false);
                        break;
                case ID_Numeric:
                        if (event.IsChecked())
                                wxMessageBox(wxT("Numeric not yet implemented."),wxT("Not implemented"),wxOK | wxICON_INFORMATION );
                                ((wxCheckBox*)event.GetEventObject())->SetValue(false);
                        break;
                case ID_FOView:
                        if (event.IsChecked())
                                wxMessageBox(wxT("FOView not yet implemented."),wxT("Not implemented"),wxOK | wxICON_INFORMATION );
                                ((wxCheckBox*)event.GetEventObject())->SetValue(false);
                        break;
                        //TODO need messages for 'gps' 'kill' 'start'
                default:
                    wxMessageBox(wxT("Unknown Checkbox!"),wxT("???"),wxOK | wxICON_INFORMATION );
        }
}

void GuiClientFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    wxMessageBox( wxT("This is a wxWidgets' Hello world sample"),
                  wxT("About Hello World"), wxOK | wxICON_INFORMATION );
}


void GuiClientFrame::OnText(wxKeyEvent& event)
{       
        if(event.GetKeyCode() == WXK_TAB)
        {
                if(commandline->IsEnabled())
                {
                        menuMovement->FindItem(ID_Forward)->SetText(wxT("&Forward\tW"));
                        menuMovement->FindItem(ID_Left)->SetText(wxT("&Left\tA"));
                        menuMovement->FindItem(ID_Back)->SetText(wxT("&Back\tS"));
                        menuMovement->FindItem(ID_Right)->SetText(wxT("&Right\tD"));
                        menuMovement->FindItem(ID_Stop)->SetText(wxT("&Stop\tSpace"));
//trying to find a better way
#if 0
                        menuMovement->Destroy(ID_Forward);
                        menuMovement->Destroy(ID_Left);
                        menuMovement->Destroy(ID_Back);
                        menuMovement->Destroy(ID_Right);
                        menuMovement->Destroy(ID_Stop);

                        menuMovement->Append( ID_Forward, wxT("&Forward\tW"));
                        menuMovement->Append( ID_Left, wxT("&Left\tA"));
                        menuMovement->Append( ID_Back, wxT("&Back\tS"));
                        menuMovement->Append( ID_Right, wxT("&Right\tD"));
                        menuMovement->Append( ID_Stop, wxT("&Stop\tSpace"));
#endif
                        commandline->Disable();
                        stop->SetFocus();
                } else {
                        menuMovement->FindItem(ID_Forward)->SetText(wxT("&Forward\tCtrl-W"));
                        menuMovement->FindItem(ID_Left)->SetText(wxT("&Left\tCtrl-A"));
                        menuMovement->FindItem(ID_Back)->SetText(wxT("&Back\tCtrl-S"));
                        menuMovement->FindItem(ID_Right)->SetText(wxT("&Right\tCtrl-D"));
                        menuMovement->FindItem(ID_Stop)->SetText(wxT("&Stop\tCtrl-Space"));
#if 0
                        menuMovement->Destroy(ID_Forward);
                        menuMovement->Destroy(ID_Left);
                        menuMovement->Destroy(ID_Back);
                        menuMovement->Destroy(ID_Right);
                        menuMovement->Destroy(ID_Stop);

                        menuMovement->Append( ID_Forward, wxT("&Forward\tCtrl-W"));
                        menuMovement->Append( ID_Left, wxT("&Left\tCtrl-A"));
                        menuMovement->Append( ID_Back, wxT("&Back\tCtrl-S"));
                        menuMovement->Append( ID_Right, wxT("&Right\tCtrl-D"));
                        menuMovement->Append( ID_Stop, wxT("&Stop\tCtrl-Space"));
#endif
                        commandline->Enable();
                        commandline->SetFocus();
                }
        }
}

void GuiClientFrame::OnCommandEnter(wxCommandEvent& event)
{
        int i;
        wxString input = commandline->GetValue();
        i = input.Find(wxT(" "));
        if(i > -1)
        {
                //space found
                msg << startmsg(input.Left(i).mb_str());
                input = input.Remove(0,i+1);
        } else {
                //space not found
                msg << startmsg(input.mb_str());
                input.Clear();
        }
        while(input.Len() > 0)
        {
                i = input.Find(wxT(" "));
                if(i > -1)
                {
                        //space found
                        msg << input.Left(i).mb_str();
                        input = input.Remove(0,i+1);
                } else {
                        //space not found
                        msg << input.mb_str();
                        input.Clear();
                }
        }
        msg << endmsg;
        commandline->Clear();
}

---