~ubuntu-branches/ubuntu/trusty/3depict/trusty-proposed

#include "mainFrame.h"

 

#ifdef __APPLE__

const unsigned int MIN_WIN_HEIGHT=100;

 

 

//!Number of pages in the panel at the bottom

const unsigned int NOTE_CONSOLE_PAGE_OFFSET= 2;

 

    //Options panel

    ID_CHECK_ALPHA,

    ID_CHECK_LIGHTING,

    ID_CHECK_CACHING,

    ID_CHECK_WEAKRANDOM,

    ID_SPIN_CACHEPERCENT,

 

};

 

 

void setWxTreeImages(wxTreeCtrl *t, const map<size_t, wxArtID> &artFilters)

{

        const int winTreeIconSize=9;

        wxImageList *imList = new wxImageList(winTreeIconSize,winTreeIconSize);

#else

        //Construct an image list for the tree

        for(map<size_t,wxArtID>::const_iterator it=artFilters.begin();it!=artFilters.end();++it)

        {

 

                        imList->Add(wxBitmap(wxBitmap(wxArtProvider::GetBitmap(it->second)).

                                                ConvertToImage().Rescale(winTreeIconSize, winTreeIconSize)));

        fullscreenState=0;

        verCheckThread=0;

        lastMessageType=MESSAGE_NONE;

        //Set up the program icon handler

        wxArtProvider::Push(new MyArtProvider);

        SetIcon(wxArtProvider::GetIcon(wxT("MY_ART_ID_ICON")));

    panelTop = new BasicGLPane(splitTopBottom);

 

 

#if wxCHECK_VERSION(2,9,0)

        glPanelOK = panelTop->displaySupported();

#else

        #if defined(__WXGTK20__) 

                //on a broken and working Gl install. booyah.

                glPanelOK=panelTop->m_glWidget;

        #elif defined(__WIN32) || defined(__WIN64) || defined(__APPLE__)

    bitmapFxStereoGlasses = new wxStaticBitmap(noteFxPanelStereo, wxID_ANY, wxNullBitmap);

    labelFxStereoBaseline = new wxStaticText(noteFxPanelStereo, wxID_ANY, wxTRANS("Baseline Separation"));

    sliderFxStereoBaseline = new wxSlider(noteFxPanelStereo,ID_EFFECT_STEREO_BASELINE_SLIDER, 20, 0, 100);

    checkAlphaBlend = new wxCheckBox(noteTools,ID_CHECK_ALPHA , wxTRANS("Smooth && translucent objects"));

    checkAlphaBlend->SetValue(true);

    checkLighting = new wxCheckBox(noteTools, ID_CHECK_LIGHTING, wxTRANS("3D lighting"));

    checkLighting->SetValue(true);

    checkWeakRandom = new wxCheckBox(noteTools, ID_CHECK_WEAKRANDOM, wxTRANS("Fast and weak randomisation."));

    checkWeakRandom->SetValue(true);

    checkCaching = new wxCheckBox(noteTools, ID_CHECK_CACHING, wxTRANS("Filter caching"));

    checkCaching->SetValue(true);

    labelMaxRamUsage = new wxStaticText(noteTools, wxID_ANY, wxTRANS("Max. Ram usage (%)"), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT);

 

        //delete the file history  pointer

        delete recentHistory;

 

        //wxwidgets can crash if objects are ->Connect-ed  in 

        // wxWindowBase::DestroyChildren(), so Disconnect before destructing

    EVT_CHECKBOX(ID_EFFECT_STEREO_LENSFLIP, MainWindowFrame::OnFxStereoLensFlip)

    EVT_COMBOBOX(ID_EFFECT_STEREO_COMBO, MainWindowFrame::OnFxStereoCombo)

    EVT_COMMAND_SCROLL(ID_EFFECT_STEREO_BASELINE_SLIDER, MainWindowFrame::OnFxStereoBaseline)

  

 

    EVT_COMMAND(wxID_ANY, RemoteUpdateAvailEvent, MainWindowFrame::OnCheckUpdatesThread)

END_EVENT_TABLE();

 

 

bool MainWindowFrame::getTreeFilterId(const wxTreeItemId &tId, size_t &filterId) const

{

        if(!tId.IsOk())

        return true;

}

 

 

void MainWindowFrame::OnFileOpen(wxCommandEvent &event)

{

        if(currentlyUpdatingScene || visControl.isRefreshing())

                return;

 

        //Load a file, either a state file, or a new pos file

        wxFileDialog *wxF = new wxFileDialog(this,wxTRANS("Select Data or State File..."), wxT(""),

                wxT(""),wxTRANS("Readable files (*.xml, *.pos, *.txt,*.csv)|*.xml;*.pos;*.txt;*.csv|POS File (*.pos)|*.pos|XML State File (*.xml)|*.xml|Text Data Files (*.txt/csv)|*.txt;*.csv|All Files (*)|*"),wxFD_OPEN|wxFD_FILE_MUST_EXIST);

        if( (wxF->ShowModal() == wxID_CANCEL))

                return;

 

        textConsoleOut->Clear();

        //Get vis controller to update tree control to match internal

        // structure. Retain tree selection & visibility if we currently

        statusMessage(TRANS("Merged file."),MESSAGE_INFO);

 

        panelTop->Refresh();

        

        wxF->Destroy();

}

 

bool MainWindowFrame::loadFile(const wxString &fileStr, bool merge)

{

        //Don't try to alter viscontrol if we are refreshing. That would be bad.

        ASSERT(!visControl.isRefreshing());

        std::string dataFile = stlStr(fileStr);

        

        {

                std::stringstream ss;

                

                        return false;

                }

 

 

                if(visControl.hasHazardousContents())

                {

 

                checkViewWorldAxis->Check(visControl.getAxisVisible());

 

                //Update the camera dropdown

 

                comboCamera->Clear();

                {

                        //Do not delete as this will be deleted by wx

                        //If this is the active cam (1) set the selection and (2) remember

                        //the ID

                                comboCamera->SetSelection(ui-1);

                }

 

                //Only update the camera grid if we have a valid uniqueID

                {

                        //Use the remembered ID to update the grid.

                }

                else

                {

                        gridCameraProperties->clear();

                        comboCamera->SetValue(wxCStr(TRANS(cameraIntroString)));

                }

 

                //reset the stash combo box

                comboStash->SetValue(wxCStr(TRANS(stashIntroString)));

 

 

 

                fileSave->Enable(true);

 

                

 

                FilterTree fTree;

 

                posFilter= configFile.getDefaultFilter(FILTER_TYPE_DATALOAD);

 

                //Bastardise the default settings such that it knows to use the correct

                // file type, based upon file extension

                unsigned int fileMode;

                        fileMode=DATALOAD_TEXT_FILE;

                else

                        fileMode=DATALOAD_FLOAT_FILE;

 

                //Append a new filter to the filter tree

                fTree.addFilter(posFilter,0);

                visControl.addFilterTree(fTree,true,0);

 

        }       

 

        visControl.updateWxTreeCtrl(treeFilters);

                if(getTreeFilterId(treeFilters->GetSelection(),filterId))

                        visControl.setWxTreeFilterViewPersistence(filterId);

 

                bool loadOK=false;

                if(!wxFileExists(f))

                        statusMessage("File does not exist",MESSAGE_ERROR);

                {

                }

                

                if(!loadOK)

                        recentHistory->RemoveFileFromHistory(event.GetId()-wxID_FILE1);

                        configFile.removeRecentFile(stlStr(f));

                }

        }

}

 

void MainWindowFrame::OnFileSave(wxCommandEvent &event)

{

 

        //If the file does not exist, use saveas instead

        {

                OnFileSaveAs(event);

                return;

        }

        

        std::map<string,string> dummyMap;

        //Try to save the viscontrol state

        {

                wxErrMsg(this,TRANS("Save error"),TRANS("Unable to save. Check output destination can be written to."));

        }

        else

        {

                //Update the recent files, and the menu.

 

        }

 

}

 

void MainWindowFrame::OnFileExportPlot(wxCommandEvent &event)

                        checkWeakRandom->Enable(!locking);

                        checkCaching->Enable(!locking);

                        spinCachePercent->Enable(!locking);

 

                        fileMenu->Enable(ID_FILE_OPEN,!locking);

                        fileMenu->Enable(ID_FILE_MERGE,!locking);

                        fileMenu->Enable(ID_FILE_SAVEAS,!locking);

 

                        for(size_t ui=0;ui<recentFilesMenu->GetMenuItemCount();ui++)

 

                        fileMenu->Enable(ID_FILE_OPEN,!locking);

                        fileMenu->Enable(ID_FILE_MERGE,!locking);

                        fileMenu->Enable(ID_FILE_SAVEAS,!locking);

 

                        for(size_t ui=0;ui<recentFilesMenu->GetMenuItemCount();ui++)

                        {

                                wxMenuItem *m;

                        //Locking of the tools pane

                        checkWeakRandom->Enable(!locking);

                        checkCaching->Enable(!locking);

                        spinCachePercent->Enable(!locking);

 

                        //Lock panel spectra, so we cannot alter things like ranges

                        panelSpectra->limitInteraction(locking);

                        break;

                        {

                                if(exportDialog->wantsImages())

                                {

                                        //update the output streams, but do not release

                                        // the contents.

                                        {

                                                pair<string,string> errMsg;

                                                string tmpStr;

        }

        else

        {

 

                //Update the recent files, and the menu.

                configFile.addRecentFile(dataFile);

 

        //Restore the relative path behaviour

        visControl.setUseRelPaths(oldRelPath);

}

 

 

        

                        //Force a scene update, independent of if autoUpdate is enabled. 

                        doSceneUpdate();        

                        break;

                }

                default:

                clearWxTreeImages(treeFilters);

 

        visControl.updateFilterPropGrid(gridFilterPropGroup,filterId);

        Layout();

        programmaticEvent=false;

}

                //refresh the camera property grid

                visControl.updateCamPropertyGrid(gridCameraProperties ,l->value);

 

                //force redraw in 3D pane

                panelTop->Refresh(false);

                return ;

        visControl.setCam(u);

        visControl.updateCamPropertyGrid(gridCameraProperties,u);

        panelTop->Refresh(false);

}

 

void MainWindowFrame::OnComboCamera(wxCommandEvent &event)

        statusMessage(s.c_str(),MESSAGE_INFO);

        

        panelTop->Refresh(false);

        return ;

}

 

                doSceneUpdate();

 

        comboFilters->SetValue(wxT(""));

}

 

bool MainWindowFrame::doSceneUpdate()

        progressTimer->Start(PROGRESS_TIMER_DELAY);             

        currentlyUpdatingScene=true;

        haveAborted=false;

 

                

        statusMessage("",MESSAGE_NONE);

 

        updateLastRefreshBox();

 

 

        //Add (or hide) a little "Star" to inform the user there is some info available

        if(textConsoleOut->IsEmpty() || noteDataView->GetSelection()==NOTE_CONSOLE_PAGE_OFFSET)

 

        visControl.updateRawGrid();

 

        //Return a value dependant upon whether we successfully loaded 

        //the data or not

        return errCode == 0;

        //Save to the autosave file

        std::string s;

        s=  stlStr(filePath);

        {

        }

 

 

        {

                //Use the current combobox value to determine which camera is the 

                //current camera in the property grid

                int n = comboCamera->FindString(comboCamera->GetValue());

 

                if(n != wxNOT_FOUND)

                }

 

                panelTop->clearCameraUpdates();

        }

 

        if(plotUpdates)

 

        }

 

        programmaticEvent=false;        

}

 

        }

        else

        {

                ProgressData p;

                p=visControl.getProgress();

                ASSERT(p.totalProgress <= visControl.numFilters());

                

                if(p.filterProgress > 100)

                                progressString = totalProg + TRANS(" of ") + totalCount;

                }

 

                if( p.filterProgress != 100)

                        filterProg+=TRANS("\% Done (Esc aborts)");

                else

                        filterProg+=TRANS("\% Done");

 

        }

 

        MainFrame_statusbar->SetStatusText(wxT(""),0);

        MainFrame_statusbar->SetStatusText(wxStr(progressString),1);

        MainFrame_statusbar->SetStatusText(wxStr(filterProg),2);

}

 

void MainWindowFrame::updatePostEffects()

                        statusMessage(TRANS("Tip: You can shift-click to force full refresh, if required"),MESSAGE_HINT);

        }

        doSceneUpdate();        

}

 

void MainWindowFrame::OnRawDataUnsplit(wxSplitterEvent &event)

                else

                        clearWxTreeImages(treeFilters);

        }

}

 

void MainWindowFrame::OnFilterGridCellEditorHide(wxGridEvent &event)

        }

 

        panelTop->Refresh(false);

}

 

void MainWindowFrame::OnButtonGridCopy(wxCommandEvent &event)

        doSceneUpdate();

}

 

void MainWindowFrame::OnCacheRamUsageSpin(wxSpinEvent &event)

{

        ASSERT(event.GetPosition() >= 0 &&event.GetPosition()<=100);

                comboCamera->SetValue(wxT(""));

                gridCameraProperties->clear();

                programmaticEvent=false;

        }

}

 

void MainWindowFrame::OnSpectraListbox(wxCommandEvent &event)

                // as we can't abort it anyway.

                if(event.CanVeto())

                {

                        {

                                //Prompt for close

                                wxMessageDialog *wxD  =new wxMessageDialog(this,

        noteFxPanelStereo->Enable(event.IsChecked());

        visControl.setEffects(event.IsChecked());

        updatePostEffects();

        

        panelTop->Refresh();

}

        labelFxCropDy->Enable(event.IsChecked());

        labelFxCropDz->Enable(event.IsChecked());

 

        updatePostEffects();

}

 

 

        panelTop->setMouseZoomFactor((float)zoomRate/100.0f);

        panelTop->setMouseMoveFactor((float)moveRate/100.0f);

}

 

void MainWindowFrame::restoreConfigPanelDefaults()

                                requireFirstUpdate=true;

                                //Prevent the program from allowing save menu usage

                                //into autosave file

                        }

 

                

                                {

                                        //Prevent the program from allowing save menu usage

                                        //into autosave file

                                        doErase=true;

                                }

                                else 

                        wxFileName fileNaming(wxStr(removeFiles[ui]));

                        wxCopyFile(wxStr(removeFiles[ui]),wxtmpDir+fileNaming.GetFullName()); 

                }

                wxRemoveFile(wxStr(removeFiles[ui]));   

        }

}

 

wxSize MainWindowFrame::getNiceWindowSize() const

{

        wxDisplay *disp=new wxDisplay;

    checkAlphaBlend->SetToolTip(wxTRANS("Enable/Disable \"Alpha blending\" (transparency) in rendering system. Blending is used to smooth objects (avoids artefacts known as \"jaggies\") and to make transparent surfaces. Disabling will provide faster rendering but look more blocky")); 

    checkLighting->SetToolTip(wxTRANS("Enable/Disable lighting calculations in rendering, for objects that request this. Lighting provides important depth cues for objects comprised of 3D surfaces. Disabling may allow faster rendering in complex scenes"));

    checkWeakRandom->SetToolTip(wxTRANS("Enable/Disable weak randomisation (Galois linear feedback shift register). Strong randomisation uses a much slower random selection method, but provides better protection against inadvertent correlations, and is recommended for final analyses"));

    checkCaching->SetToolTip(wxTRANS("Enable/Disable caching of intermediate results during filter updates. Disabling caching will use less system RAM, though changes to any filter property will cause the entire filter tree to be recomputed, greatly slowing computations"));

 

    gridFilterPropGroup->CreateGrid(0, 2);

    wxBoxSizer* sizerLeft = new wxBoxSizer(wxVERTICAL);

    wxBoxSizer* sizerTools = new wxBoxSizer(wxVERTICAL);

    wxBoxSizer* sizerToolsRamUsage = new wxBoxSizer(wxHORIZONTAL);

    wxBoxSizer* postProcessSizer = new wxBoxSizer(wxVERTICAL);

    wxBoxSizer* sizerFxStereo = new wxBoxSizer(wxVERTICAL);

    wxBoxSizer* sizerSetereoBaseline = new wxBoxSizer(wxHORIZONTAL);

    noteEffects->AddPage(noteFxPanelStereo, wxTRANS("Stereo"));

    postProcessSizer->Add(noteEffects, 1, wxEXPAND, 0);

    notePost->SetSizer(postProcessSizer);

    sizerTools->Add(checkAlphaBlend, 0, wxLEFT|wxTOP|wxBOTTOM, 5);

    sizerTools->Add(checkLighting, 0, wxLEFT|wxTOP|wxBOTTOM, 6);

    sizerTools->Add(checkWeakRandom, 0, wxLEFT|wxTOP|wxBOTTOM, 5);

    sizerTools->Add(checkCaching, 0, wxLEFT|wxTOP|wxBOTTOM, 5);

    sizerToolsRamUsage->Add(labelMaxRamUsage, 0, wxRIGHT|wxALIGN_RIGHT, 5);

    sizerToolsRamUsage->Add(spinCachePercent, 0, 0, 5);

    splitLeftRight->SplitVertically(panelLeft, panelRight);

    topSizer->Add(splitLeftRight, 1, wxEXPAND, 0);

    SetSizer(topSizer);

    Layout();

    // end wxGlade

    //