mainframe.cpp

rcssserver3d Robocup 3D比赛官方指定平台

    SparkEdit::GetInstance().UpdateTitles(mCtrNotebook);
}

bool mainframe::SaveFileAs(wxScintilla* edit)
{
    if (edit == 0)
    {
        return false;
    }

    wxString message(wxT("Choose a file to save"));
    wxString default_path;
    wxString default_filename;
    wxString default_extension;
    wxString wildcard(wxT("simspark files (*.rsg, *.rb)|*.rb;*.rsg"));
    int flags = wxFD_SAVE | wxFD_OVERWRITE_PROMPT;

    wxString filename = wxFileSelector(message, default_path, default_filename,
                                       default_extension, wildcard,flags);

    if (filename.empty() )
    {
        return false;
    }

    SparkEdit::GetInstance().SaveFileAs(mCtrNotebook, edit, filename);
    return true;
}

void mainframe::OnFileSaveAs(wxCommandEvent& /*event*/)
{
    wxScintilla* edit = SparkEdit::GetCurrentPage(mCtrNotebook);
    if (edit == 0)
    {
        return;
    }

    SaveFileAs(edit);
}

void mainframe::OnUpdateFileSave(wxUpdateUIEvent& event)
{
    event.Enable(SparkEdit::GetCurrentPage(mCtrNotebook) != 0);
}

bool mainframe::SaveFile(wxScintilla* edit)
{
    if (edit == 0)
    {
        return false;
    }

    if (SparkEdit::GetInstance().GetFile(edit).IsEmpty())
        {
            return SaveFileAs(edit);
        }

    SparkEdit::GetInstance().SaveFile(edit);
    return true;
}

void mainframe::OnFileSave(wxCommandEvent& /*event*/)
{
    wxScintilla* edit = SparkEdit::GetCurrentPage(mCtrNotebook);
    if (edit == 0)
    {
        return;
    }

    SaveFile(edit);
}

void mainframe::SelectCanvasTab()
{
    int idx = mCtrNotebook->GetPageIndex(mCanvas);
    if (idx < 0)
    {
        assert(false);
        return;
    }

    mCtrNotebook->SetSelection(idx);
    mCanvas->SetFocus();
}

void mainframe::OnFileNew(wxCommandEvent& /*event*/)
{
    bool select = true;
    SparkEdit::GetInstance().GetEdit(wxString(), mCtrNotebook, select);
}

void mainframe::OnFileOpen(wxCommandEvent& /*event*/)
{
    wxString message(wxT("Choose a file to open"));
    wxString default_filename(wxT(""));
    wxString default_extension(wxT(""));
    wxString wildcard(wxT("simspark files (*.rsg, *.rb)|*.rb;*.rsg"));
    int flags = wxFD_OPEN | wxFD_FILE_MUST_EXIST;

    wxString filename = wxFileSelector(message, Platform::GetDefaultFileOpenPath(),
                                       default_filename, default_extension, wildcard, flags);
    if (filename.empty() )
    {
        return;
    }

    bool select = false;
    wxScintilla* edit = SparkEdit::GetInstance().GetEdit(filename, mCtrNotebook, select);

    if (
        (SparkEdit::GetInstance().GetStartScript() != 0) ||
        (SparkEdit::GetInstance().GetFileType(edit) != SparkEdit::GetInstance().ET_RB)
        )
    {
        SparkEdit::GetInstance().SelectEdit(mCtrNotebook, edit);
        return;
    }

    SelectCanvasTab();
    SparkEdit::GetInstance().SetStartScript(mCtrNotebook, edit);
    UpdateTitle();
    OpenSimulation(filename);
}

void mainframe::OnUpdateFileReload(wxUpdateUIEvent& event)
{
    event.Enable(
                 (GetSimState() == S_PAUSED) &&
                 (SparkEdit::GetInstance().GetStartScript() != 0)
                 );
}

void mainframe::OnFileReload(wxCommandEvent& /*event*/)
{
    wxString simName = SparkEdit::GetInstance().GetStartScriptFile();
    if (simName.IsEmpty())
    {
        return;
    }

    SaveModified();
    SelectCanvasTab();
    OpenSimulation(simName);
}

void mainframe::OnHelpAbout(wxCommandEvent& /*event*/)
{
    aboutDlg dlg(this, wxID_ANY, wxT("About SimSpark"));
    dlg.ShowModal();
}

void mainframe::OnAgentOpen(wxCommandEvent& /*event*/)
{
    wxString message(wxT("Choose an agent executable to run"));
    wxString default_filename(wxT(""));
    wxString default_extension(wxT(""));
    wxString wildcard(wxT("agent executables (*.exe)|*.exe"));

    wxString filename = wxFileSelector(message, Platform::GetDefaultAgentOpenPath(),
                                       default_filename, default_extension,
                                       Platform::GetDefaultAgentOpenWildcard());
    if (filename.empty() )
        {
            return;
        }

    agentframe* frame(new agentframe(this, wxID_ANY, filename));
    frame->SetTitle(wxFileName(filename).GetName());
    frame->Show();
    frame->StartAgent(filename);
}

void mainframe::PrintSimState()
{
    shared_ptr<SimSpark> spark = wxGetApp().GetSpark();

    if (spark.get() == 0)
        {
            mSimState->SetValue(wxString());
            return;
        }

    shared_ptr<SimulationServer> sim = spark->GetSimulationServer();
    if (sim.get() == 0)
        {
            mSimState->SetValue(wxString());
            return;
        }

    wxString state;
    switch (spark->GetSimState())
        {
        default:
            break;

        case S_PAUSED:
            state = wxT("Paused ");
            break;

        case S_RUNNING:
            state = wxT("Running ");
            break;
        }

    float now = sim->GetTime();
    mSimState->SetValue(state + wxString::Format(wxT("t=%.1lf"),now));
}

void mainframe::OnSparkContext(SparkContextEvent& event)
{
    switch (event.GetType())
    {
    default:
        assert(false);
        break;

    case SparkContextEvent::T_SELECTION_CHANGED:
        {
            // redraw gl canvas
            bool swapBuffers = true;
            wxClientDC dc(this);
            mCanvas->Render(dc, swapBuffers);

            weak_ptr<Leaf> leaf = SparkContext::GetInstance().GetSelection();
            if (mSparkTree.SelectLeaf(leaf))
            {
                mSparkTree.MarkItem(mCtrTree->GetSelection());
            } else
            {
                mSparkTree.MarkItem(wxTreeItemId());
            }

            break;
        }
    }
}

void mainframe::OnLogClear(wxCommandEvent& /*event*/)
{
    mCtrLog->SetValue(wxString());
}

void mainframe::OnLogCopy(wxCommandEvent& /*event*/)
{
    long from, to;
    mCtrLog->GetSelection(&from,&to);
    mCtrLog->SetSelection(-1,-1);
    mCtrLog->Copy();
    mCtrLog->SetSelection(from,to);
}

void mainframe::UpdateLogChannelState()
{
    shared_ptr<SimSpark> spark = wxGetApp().GetSpark();
    if (spark.get() == 0)
        {
            assert(false);
            return;
        }

    unsigned int mask = spark->GetLogPriority();

    mCtrLogChannelDebug->SetValue((mask & LogServer::eDebug) != 0);
    mCtrLogChannelNormal->SetValue((mask & LogServer::eNormal) != 0);
    mCtrLogChannelWarning->SetValue((mask & LogServer::eWarning) != 0);
    mCtrLogChannelError->SetValue((mask & LogServer::eError) != 0);
}

void mainframe::OnLogChannel(wxCommandEvent& /*event*/)
{
    shared_ptr<SimSpark> spark = wxGetApp().GetSpark();
    if (spark.get() == 0)
        {
            assert(false);
            return;
        }

    unsigned int mask = LogServer::eNone;

    mask += mCtrLogChannelDebug->GetValue() ? static_cast<int>(LogServer::eDebug) : 0;
    mask += mCtrLogChannelNormal->GetValue() ? static_cast<int>(LogServer::eNormal) : 0;
    mask += mCtrLogChannelWarning->GetValue() ? static_cast<int>(LogServer::eWarning) : 0;
    mask += mCtrLogChannelError->GetValue() ? static_cast<int>(LogServer::eError) : 0;

    spark->SetLogPriority(mask);
}

void mainframe::OnTabClosing(wxFlatNotebookEvent& event)
{
    wxWindow* page = mCtrNotebook->GetPage(event.GetSelection());
    if (page == mCanvas)
    {
        event.Veto();
        return;
    }

    wxScintilla* edit = dynamic_cast<wxScintilla*>(page);
    if (edit == 0)
    {
        event.Skip();
        return;
    }

    if (edit->GetModify())
        {
            int res = wxMessageBox(wxT("The file '")+SparkEdit::GetInstance().GetTitle(edit)+wxT("' is modified.\n")
                                   wxT("Do you want to save your changes?"),
                                   wxT("rsgedit"),
                                   wxYES_NO|wxCANCEL|wxICON_QUESTION
                                   );

            switch (res)
                {
                default:
                    assert(false);
                    // fall through

                case wxCANCEL:
                    event.Veto();
                    return;

                case wxYES:
                    if (! SaveFile(edit))
                    {
                        event.Veto();
                        return;
                    }
                    break;

                case wxNO:
                    break;
                }
        }

    if (edit != 0)
        {
            SparkEdit::GetInstance().PutEdit(edit);
            UpdateTitle();
        }

    event.Skip();
}

void mainframe::OnTabStartScript(wxCommandEvent& event)
{
    wxScintilla* edit = SparkEdit::GetCurrentPage(mCtrNotebook);
    if (edit == 0)
    {
        event.Skip();
        return;
    }

    SparkEdit::GetInstance().SetStartScript(mCtrNotebook, edit);
}

void mainframe::OnTabCloseOther(wxCommandEvent& /*event*/)
{
    int sel = mCtrNotebook->GetSelection();
    if (sel < 0)
    {
        return;
    }

    int n = mCtrNotebook->GetPageCount();
    for (int i=(n-1);i>=0;--i)
    {
        if (i == sel)
        {
            continue;
        }

        bool notify = true;
        mCtrNotebook->RemovePage(i, notify);
    }
}

void mainframe::OnTabClose(wxCommandEvent& /*event*/)
{
    int sel = mCtrNotebook->GetSelection();
    if (sel < 0)
    {
        return;
    }

    bool notify = true;
    mCtrNotebook->RemovePage(sel, notify);
}

void mainframe::OnTabContextMenu(wxFlatNotebookEvent& event)
{
    wxScintilla* edit = SparkEdit::GetCurrentPage(mCtrNotebook);
    if (edit == 0)
    {
        event.Skip();
        return;
    }

    wxMenu* context = SparkContext::GetInstance().GetContextMenu(edit);
    if (context == 0)
        {
            return;
        }

    PopupMenu(context);
}

void mainframe::OnTabChanged(wxFlatNotebookEvent& event)
{
    wxWindow* page = mCtrNotebook->GetPage(event.GetSelection());
    if (page == mCanvas)
    {
        mCanvas->SetFocus();
    }

    event.Skip();
}

void mainframe::OnEditSavePointReached(wxScintillaEvent& event)
{
    SparkEdit::GetInstance().UpdateTitle(mCtrNotebook,static_cast<wxScintilla*>(event.GetEventObject()));
    event.Skip();
}

void mainframe::OnEditSavePointLeft(wxScintillaEvent& event)
{
    SparkEdit::GetInstance().UpdateTitle(mCtrNotebook,static_cast<wxScintilla*>(event.GetEventObject()));
    event.Skip();
}

void mainframe::OnEditCommand(wxCommandEvent& event)
{
    wxScintilla* edit = SparkEdit::GetCurrentPage(mCtrNotebook);
    if (edit == 0)
    {
        event.Skip();
        return;
    }

    switch (event.GetId())
        {
        case wxID_UNDO:
            edit->Undo();
            break;

        case wxID_REDO:
            edit->Redo();
            break;

        case wxID_CUT:
            edit->Cut ();
            break;

        case wxID_COPY:
            edit->Copy ();
            break;

        case wxID_PASTE:
            edit->Paste();
            break;

        case wxID_SELECTALL:
            edit->SetSelection (0, edit->GetLength());
            break;
        }
}

void mainframe::OnUpdateEditCommand(wxUpdateUIEvent& event)
{
    wxScintilla* edit = SparkEdit::GetCurrentPage(mCtrNotebook);
    if (edit == 0)
    {
        event.Enable(false);
        return;
    }

    switch (event.GetId())
        {
        case wxID_UNDO:
            {
                event.Enable(edit->CanUndo());
                break;
            }

        case wxID_REDO:
            {
                event.Enable(edit->CanRedo());
                break;

            }

        case wxID_CUT:
            {
                event.Enable(
                             (! edit->GetReadOnly()) &&
                             (edit->GetSelectionEnd()-edit->GetSelectionStart() > 0)
                             );
                break;
            }

        case wxID_COPY:
            {
                event.Enable
                    (
                     (edit->GetSelectionEnd()-edit->GetSelectionStart() > 0)
                     );
                break;
            }

        case wxID_PASTE:
            {
                event.Enable(edit->CanPaste());
                break;
            }

        case wxID_SELECTALL:
            {
                event.Enable(true);
                break;
            }
        }
}