bbtkWxGUITextEditor.cxx

Go to the documentation of this file.

/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkWxGUITextEditor.cxx,v $
  Language:  C++
  Date:      $Date: 2009/12/04 10:48:34 $
  Version:   $Revision: 1.21 $
=========================================================================*/

/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         


#ifdef _USE_WXWIDGETS_

#include <iostream>     
#include "bbtkWxGUITextEditor.h"
#include "bbtkWxBlackBox.h"
#include "bbtkConfigurationFile.h"
#include "bbtkUtilities.h"

//#include "icons/cc_new.xpm"
//#include "icons/cc_open.xpm"
//#include "icons/cc_stop.xpm"
//#include "icons/cc_save.xpm"
//#include "icons/cc_save_as.xpm"
//#include "icons/cc_run.xpm"
//#include "icons/cc_exit.xpm"

#include "../data/icons/wxart_new.xpm"
#include "../data/icons/wxart_fileopen.xpm"
#include "../data/icons/wxart_filesave.xpm"
#include "../data/icons/wxart_filesaveas.xpm"
//#include "../data/icons/wxart_exefile.xpm"
//#include "../data/icons/wxart_delete.xpm"
//#include "../data/icons/wxart_down.xpm"
#include "../data/icons/wxart_run.xpm"
#include "../data/icons/wxart_runbbi.xpm"
#include "../data/icons/wxart_graphsimple.xpm"
#include "../data/icons/wxart_graphdetail.xpm"
#include "../data/icons/wxart_eldel.xpm"

namespace bbtk
{


  //================================================================
  class WxTextCtrlGettingKeyEvents : public wxTextCtrl
  {
  public:
    WxTextCtrlGettingKeyEvents(wxWindow *parent, wxWindowID id, const wxString &value,
                               const wxPoint &pos, const wxSize &size, int style = 0)
      : wxTextCtrl(parent, id, value, pos, size, style)
    {
    }
    
    void SetWxGUITextEditor(WxGUITextEditor* e) 
    { mWxGUITextEditor = e; }
    
    void OnKeyDown(wxKeyEvent& event);
    void OnKeyUp(wxKeyEvent& event);
    void OnChar(wxKeyEvent& event);
  private :
    WxGUITextEditor* mWxGUITextEditor;
    
    DECLARE_EVENT_TABLE()
      };
  
  BEGIN_EVENT_TABLE(WxTextCtrlGettingKeyEvents, wxTextCtrl)
    EVT_KEY_DOWN(WxTextCtrlGettingKeyEvents::OnKeyDown)
    EVT_KEY_UP(WxTextCtrlGettingKeyEvents::OnKeyUp)
    EVT_CHAR(WxTextCtrlGettingKeyEvents::OnChar)
    END_EVENT_TABLE()
    
    
    void WxTextCtrlGettingKeyEvents::OnChar(wxKeyEvent& event)
  {
    event.Skip();
  }
  
  void WxTextCtrlGettingKeyEvents::OnKeyUp(wxKeyEvent& event)
  {
    mWxGUITextEditor->OnKeyUp(event);
    event.Skip();
  }
  
  void WxTextCtrlGettingKeyEvents::OnKeyDown(wxKeyEvent& event)
  {
    mWxGUITextEditor->OnKeyDown(event);
    event.Skip();
  }
  //================================================================
  
  
  //================================================================  
  /*  BEGIN_EVENT_TABLE(WxGUITextEditorPage, wxPanel)
    EVT_CLOSE(WxGUITextEditorPage::OnClose)
    END_EVENT_TABLE()
  */
 
  //================================================================
  WxGUITextEditorPage::WxGUITextEditorPage(wxWindow* parent,
                                               WxGUITextEditor* editor)
    : wxPanel(parent,-1),
      mEditor(editor),
      mName(""),
      mAskFilename(true)
  {  

          //      std::cout << "WxGUITextEditorPage::WxGUITextEditorPage("<<mName<<")"<<std::endl;

    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    mwxInputText = 
                
      new WxTextCtrlGettingKeyEvents(this,
                                     -1, //ID_InputText,
                                     _T(""),
                                     wxDefaultPosition,
                                     wxDefaultSize,
                                     wxTE_MULTILINE 
                                     //    |wxTE_PROCESS_ENTER
                                     //| wxTE_PROCESS_TAB 
                                     //             | wxWANTS_CHARS 
                                    // |  wxTAB_TRAVERSAL
                                     );
    mwxInputText->SetWxGUITextEditor(mEditor);
    /*
        new wxTextCtrl(this,-1,_T(""),
                wxDefaultPosition,
                                             wxDefaultSize,
                                             wxTE_MULTILINE 
                                             //    |wxTE_PROCESS_ENTER
                                        //       | wxTE_PROCESS_TAB 
                                //                  | wxWANTS_CHARS 
                                 //    |  wxTAB_TRAVERSAL
                                     );
                                         */
    mFixedFont = new wxFont(10,
                                   wxFONTFAMILY_MODERN,
                                   wxFONTSTYLE_NORMAL,
                                   wxFONTWEIGHT_NORMAL,
                                   false);
    
    mwxInputTextAttr = new wxTextAttr;
    mwxInputTextAttr->SetFont(*mFixedFont);
   
    sizer->Add(mwxInputText,1,wxGROW);
    SetSizer(sizer);
    SetAutoLayout(true);
    Layout();
  }
  //================================================================

  //================================================================
  WxGUITextEditorPage::~WxGUITextEditorPage()
  {
          delete mwxInputTextAttr;
          delete mFixedFont;
  }
  //================================================================

  bool WxGUITextEditorPage::IsModified()
   { return mwxInputText->IsModified(); }

  std::string WxGUITextEditorPage::GetText()
  {
    return wx2std(GetTextCtrl()->GetValue());
  }

  //================================================================
  void WxGUITextEditorPage::Load(const std::string& filename)
  {
    //    std::cout << "-------------- LOAD ---------------"<<std::endl;
    //    std::cout << "'" << filename << "'"<<std::endl;
    //std::string oldFilename = mFilename;
    mName = filename;
    mAskFilename = false;
    mwxInputText->LoadFile(std2wx(mName));
  }
  //================================================================

  //================================================================
  void WxGUITextEditorPage::Save(const std::string& filter)
  {
    //    std::cout << "-------------- SAVE ---------------"<<std::endl;
    if (mAskFilename)
      {
        wxFileDialog* fd = new wxFileDialog(this,_T("Save file"),_T(""),
                                            _T(""),std2wx(filter),
                                            wxSAVE | wxOVERWRITE_PROMPT );
        int result_fd = fd->ShowModal();
    
        // This line is need it by windows // EED
        fd->SetReturnCode( result_fd );

        if (fd->GetReturnCode()==wxID_OK)
          {
            mName = wx2std(fd->GetPath());
            mAskFilename = false;
          }
        else 
          {
            //      std::cout << "-------------- CANCELLED ---------------"
            //                <<std::endl;
            return;
          } 
      }
    //    std::cout << "file [" << mName << "]" <<std::endl;
//    mwxInputText->SaveFile(std2wx(mName));
        SaveFile(mName);
    mwxInputText->SetModified(false);
  }
  //================================================================
  

        //================================================================
        void WxGUITextEditorPage::SaveFile(const std::string& filename)
        {
                mwxInputText->SaveFile( std2wx(filename) );
        }
        //================================================================
        
        










  //================================================================
  // WxGUITextEditor
  //================================================================


  //================================================================
  WxGUITextEditor::WxGUITextEditor( wxWindow *parent,
                                    WxGUITextEditorUser* user )
    : wxPanel(parent, -1),
      mUser(user),
      mFileNameFilter("*.*")
  {
  //  m_mgr.SetManagedWindow(this);
                    //    wxInitAllImageHandlers();
     
        //  std::cout << "WxGUITextEditor::WxGUITextEditor"<<std::endl;

      wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);

    mwxNotebook = new wxNotebook(this,-1,
                wxDefaultPosition, wxDefaultSize, 
                wxNB_TOP 

                
                );
                
   sizer->Add(mwxNotebook,1,wxGROW);

                
                /*
   mwxNotebook =                new wxAuiNotebook(this,  
                                    -1,
                                    wxPoint(0, 0),
                                    wxSize(500,500),
                                    wxAUI_NB_TAB_SPLIT 
                                    | wxAUI_NB_TAB_MOVE
                                    | wxAUI_NB_TAB_EXTERNAL_MOVE
                                    | wxAUI_NB_WINDOWLIST_BUTTON
                                    |wxAUI_NB_SCROLL_BUTTONS
                                    // | wxAUI_NB_CLOSE_BUTTON 
                                    | wxAUI_NB_CLOSE_ON_ACTIVE_TAB
                                    //| wxAUI_NB_CLOSE_ON_ALL_TABS
                                    | wxNO_BORDER);
    
    m_mgr.AddPane(mwxNotebook,
                  wxAuiPaneInfo().Name(wxT("notebook"))
                  .Caption(wxT(""))
                  .CaptionVisible(false)
                  .MinimizeButton(false)
                  .MaximizeButton(false)
                  .CloseButton(false)
                  //              .Dockable(false).Float()
                  .Center()
                  .MinSize(wxSize(100,50))
                  );   
*/
 
    /*   
    wxBitmap bmp_new(cc_new_xpm);
    wxBitmap bmp_open(cc_open_xpm);
    wxBitmap bmp_close(cc_stop_xpm);
    wxBitmap bmp_save(cc_save_xpm);
    wxBitmap bmp_saveas(cc_save_as_xpm);
    wxBitmap bmp_run(cc_run_xpm);
    */
    wxBitmap bmp_new(new_xpm);
    wxBitmap bmp_open(fileopen_xpm);
    wxBitmap bmp_close(eldel_xpm);
    wxBitmap bmp_save(filesave_xpm);
    wxBitmap bmp_saveas(filesaveas_xpm);
    wxBitmap bmp_run(wxart_run_xpm);
    wxBitmap bmp_runbbi(wxart_runbbi_xpm);
    wxBitmap bmp_graphsimple(wxart_graphsimple_xpm);
        wxBitmap bmp_graphdetail(wxart_graphdetail_xpm);

    mwxToolBar = new wxToolBar(this, wxID_ANY, 
                               wxDefaultPosition, wxDefaultSize,
                               wxTB_FLAT | wxTB_NODIVIDER);
    
    mwxToolBar->AddTool(ID_ButtonNew, _T("New"),
                     bmp_new, wxNullBitmap, wxITEM_NORMAL,
                     _T("New file"), _T("Create a new file"));
    mwxToolBar->AddTool(ID_ButtonOpen, _T("Open"),
                     bmp_open, wxNullBitmap, wxITEM_NORMAL,
                     _T("Open file"), _T("This is help for new file tool"));
    mwxToolBar->AddTool(ID_ButtonClose, _T("Close"),
                     bmp_close, wxNullBitmap, wxITEM_NORMAL,
                     _T("Close file"), _T("Close current file"));
    mwxToolBar->AddTool(ID_ButtonSave, _T("New"),
                     bmp_save, wxNullBitmap, wxITEM_NORMAL,
                     _T("Save file"), _T("Save current file"));
    mwxToolBar->AddTool(ID_ButtonSaveAs, _T("New"),
                     bmp_saveas, wxNullBitmap, wxITEM_NORMAL,
                     _T("Save file as"), _T("Save current file as"));
    mwxToolBar->AddTool(ID_ButtonRun, _T("Run"),
                     bmp_run, wxNullBitmap, wxITEM_NORMAL,
                     _T("Run file"), _T("Run current file"));

          
        mwxToolBar->AddTool(ID_ButtonGraphSimple, _T("Graph (simple)"),
                                                  bmp_graphsimple, wxNullBitmap, wxITEM_NORMAL,
                                                  _T("Graph simple"), _T("Simple graph of actual script"));

        mwxToolBar->AddTool(ID_ButtonGraphDetail, _T("Graph (detail)"),
                                                  bmp_graphdetail, wxNullBitmap, wxITEM_NORMAL,
                                                  _T("Graph (detail)"), _T("Detail graph of actual script"));
          
        mwxToolBar->AddTool(ID_ButtonRunBBI, _T("Run external bbi "),
                                                  bmp_runbbi, wxNullBitmap, wxITEM_NORMAL,
                                                  _T("Run external bbi"), _T("Run external bbi"));
          
          
          
    mwxToolBar->AddSeparator();
    mwxPosition = new wxStaticText ( mwxToolBar, -1, _T(""));
    mwxToolBar->AddControl(mwxPosition);
    mwxToolBar->Realize();

          sizer->Add(mwxToolBar,0,wxGROW);

        /*
    m_mgr.AddPane(mwxToolBar, 
                  wxAuiPaneInfo().Name(wxT("toolBar"))
                  .Caption(wxT(""))
                  .ToolbarPane()
                  .Bottom()
                  .MinSize(wxSize(100,50))
                  .LeftDockable(false).RightDockable(false)
                  );   
*/
  SetSizer(sizer);
  
    
//    m_mgr.Update();
    SetAutoLayout(true);
    Layout();

    NewPage("");
    UpdateInfo();

  }
  //================================================================
  
  //================================================================
  WxGUITextEditor::~WxGUITextEditor()
  {
  //  m_mgr.UnInit();

    //    delete mInterpreter;
  }
  //================================================================

  //================================================================
  void WxGUITextEditor::NewPage(const std::string& filename)
  {
   WxGUITextEditorPage* page = 
      new WxGUITextEditorPage(mwxNotebook,this);
    std::string name("untitled");
    if (filename.size()!=0) 
      {
        name = filename;
        page->Load(name);
      }
    page->SetPageName(name);
    std::string fname = Utilities::get_file_name(name);
    mwxNotebook->AddPage(page,std2wx(fname),true);
    FocusOnCurrentPage();
  }
  //================================================================

  //================================================================
  WxGUITextEditorPage* WxGUITextEditor::GetCurrentPage()
  {
    return (WxGUITextEditorPage*)
      mwxNotebook->GetPage(mwxNotebook->GetSelection());
  }
  //================================================================

  //================================================================
  void WxGUITextEditor::FocusOnCurrentPage()
  {
    if (mwxNotebook->GetPageCount()==0) return;
    GetCurrentPage()->SetFocus();    
  }
  //================================================================

  //================================================================  
  void WxGUITextEditor::OnToolLeftClick(wxCommandEvent& event)
  {
    switch (event.GetId())
      {
      case ID_ButtonNew :
        New(); 
        FocusOnCurrentPage();
        break;
      case ID_ButtonOpen :
        Open(); 
        FocusOnCurrentPage();
        break;
      case ID_ButtonClose :
        CloseCurrentPage();
        break;
      case ID_ButtonSave :
        SaveCurrentPage();
        break;
      case ID_ButtonSaveAs :
        if (mwxNotebook->GetPageCount()==0) break;  
        GetCurrentPage()->SetAskFilename(true);
        SaveCurrentPage();
        break;
      case ID_ButtonRun :
        if ((mUser!=0) && (mwxNotebook->GetPageCount()>0)) 
          mUser->WxGUITextEditorRun();
        FocusOnCurrentPage();
        break;
                          
                  case ID_ButtonGraphSimple :
                          if ((mUser!=0) && (mwxNotebook->GetPageCount()>0)) 
                                  mUser->WxGUITextEditorGraphSimple();
                          FocusOnCurrentPage();
                          break;

                  case ID_ButtonGraphDetail :
                          if ((mUser!=0) && (mwxNotebook->GetPageCount()>0)) 
                                  mUser->WxGUITextEditorGraphDetail();
                          FocusOnCurrentPage();
                          break;
                          
                  case ID_ButtonRunBBI :
                          if ((mUser!=0) && (mwxNotebook->GetPageCount()>0)) 
                                  mUser->WxGUITextEditorRunBBI();
                          FocusOnCurrentPage();
                          break;
                          
      }
  }
  //================================================================  

  //================================================================  
  void WxGUITextEditor::OnToolRightClick(wxCommandEvent& event)
  {
  }
  //================================================================  

  //================================================================  
  void WxGUITextEditor::New()
  {
    NewPage("");
    UpdateInfo();
  }
  //================================================================

  //================================================================  
  void WxGUITextEditor::Open()
  {
    //    std::cout << "-------------- OPEN ---------------"<<std::endl;

    wxFileDialog* fd = new wxFileDialog(this,_T("Open file"),_T(""),
                                        _T(""),std2wx(mFileNameFilter),
                                        wxOPEN | wxFILE_MUST_EXIST );
    int result_fd = fd->ShowModal();

        // This line is need it by windows //EED
        fd->SetReturnCode( result_fd );

    if (fd->GetReturnCode()==wxID_OK)
      {
        std::string filename = wx2std(fd->GetPath());
        std::cout << "file [" << filename << "]" <<std::endl;
        Open(filename);
      }
    else 
      {
        //      std::cout << "-------------- CANCELLED ---------------"<<std::endl;
      }
  }
  //================================================================  
  
  //================================================================  
  void WxGUITextEditor::Open(const std::string& filename)
  {
    NewPage(filename);
    UpdateInfo();
  }
  //================================================================  


  //================================================================  
  bool WxGUITextEditor::CloseCurrentPage()
  {
    if (mwxNotebook->GetPageCount()==0) return true;

    if (GetCurrentPage()->IsModified()) 
      {
        wxString mess = std2wx(GetCurrentPage()->GetPageName());
        mess += _T(" modified. Save it ?");
        wxMessageDialog* d = 
          new wxMessageDialog(this,
                              mess, 
                              _T("Save buffer"), 
                              wxYES_NO | wxCANCEL | wxICON_QUESTION);
        switch (d->ShowModal())
          {
          case wxID_CANCEL : 
            return false;
            break;
          case wxID_YES : 
            GetCurrentPage()->Save(mFileNameFilter); 
            break;
          case wxID_NO : ;
          }       
      } 
    mwxNotebook->DeletePage(mwxNotebook->GetSelection());
    FocusOnCurrentPage();
    return true;
  }
  //================================================================  

  //================================================================  
  bool WxGUITextEditor::CloseAllPages()
  {
    bool ok = true;
    while (mwxNotebook->GetPageCount()!=0)
      {
        if (!CloseCurrentPage()) 
          {
            ok = false;
            break;
          }
      }
    return ok;
  }
  //================================================================  

  //================================================================  
  void WxGUITextEditor::SaveCurrentPage()
  {
    if (mwxNotebook->GetPageCount()==0) return;  
    GetCurrentPage()->Save(mFileNameFilter);
    mwxNotebook->SetPageText(mwxNotebook->GetSelection(),
                             std2wx(GetCurrentPage()->GetPageName()));
  }
  //================================================================  


  //================================================================  
  void WxGUITextEditor::OnPageClose(wxAuiNotebookEvent& evt)
  {
    if (!CloseCurrentPage()) evt.Veto();
  }
  //================================================================



  /*
  //================================================================  
  void WxGUITextEditor::OnButtonQuit(wxCommandEvent& event) 
  { 
    Quit(); 
    FocusOnCurrentPage();
  }
  void WxGUITextEditor::Quit()
  {
    std::cout << "-------------- QUIT ---------------"<<std::endl;
    if (AskSave()) GetParent()->Close();
  }
  //================================================================  
  */

  //================================================================  

  /*
  void WxGUITextEditor::Run()
  {
    std::cout << "-------------- RUN ---------------"<<std::endl;

    if (!mwxSplit->IsSplit()) 
      {
        int size = -100;
        int minsize = - (int)(mwxInputText->GetSize().GetHeight() / 2.);
        if (size<minsize) size = minsize;
        mwxSplit->SplitHorizontally( mwxInputText, mwxOutputText, size);
      }

    std::stringstream* buffer = new std::stringstream(bbtk::wx2std(mwxInputText->GetValue()));
    mInterpreter->InterpretLine("reset");
    try 
      {
        mInterpreter->InterpretBuffer(buffer);
      }
    catch (...)
      {
      }
  } 
  //================================================================  
*/
  
 
  
  //================================================================
  

  //================================================================
  void WxGUITextEditor::UpdateInfo()
  {
    if (mwxNotebook->GetPageCount()==0) return;
    WxTextCtrlGettingKeyEvents* text = GetCurrentPage()->GetTextCtrl();
    
    long line, column, pos;
    pos = text->GetInsertionPoint();
    text->PositionToXY(pos, &column, &line);
    
    
    //                wxLogMessage(_T("Current position: %ld\nCurrent line, column: (%ld, %ld)\nNumber of lines: %ld\nCurrent line length: %ld\nTotal text length: %u (%ld)"),
    
    
    char mess[200];
    sprintf(mess,"%ld:%ld/%ld:%ld",
            line+1,column+1,
            (long)text->GetNumberOfLines(),
            (long)text->GetLineLength(line)+1);
    //       pos+1,
    //       (long)mwxInputText->GetValue().length())+1;
    
   // mwxPosition->SetLabel(wxString(mess));
    mwxPosition->SetLabel(std2wx(mess));    
    mwxPosition->Show();
    
    if (text->IsModified()) 
      {
        std::string title("*");
        title += GetCurrentPage()->GetPageName();
        mwxNotebook->SetPageText(mwxNotebook->GetSelection(),std2wx(title));
      }
  }
  //================================================================
  //================================================================
  void WxGUITextEditor::OnKeyUp(wxKeyEvent& event)
  {
  //    std::cout << "U" << std::endl;
    UpdateInfo();
  }
  //================================================================

  //================================================================
  void WxGUITextEditor::OnKeyDown(wxKeyEvent& event)
  {
     //   std::cout << "D" << std::endl;
    // std::cout << "Key="<<event.GetKeyCode()<<std::endl;
    if ( event.ControlDown() )
      {
        switch (event.GetKeyCode())
          {
          case 'n': case 'N' : New(); break;
          case 's': case 'S' : SaveCurrentPage(); break;
          case 'o': case 'O' : Open(); break;
            //    case 'r': case 'R' : Run(); break;
            //    case 'q': case 'Q' : Quit(); break;
          }
      }
  }
  //================================================================
  
  //================================================================  
  BEGIN_EVENT_TABLE(WxGUITextEditor, wxPanel)
    EVT_MENU(wxID_ANY,  WxGUITextEditor::OnToolLeftClick)
    EVT_TOOL_RCLICKED(wxID_ANY,  WxGUITextEditor::OnToolRightClick)
    EVT_AUINOTEBOOK_PAGE_CLOSE(wxID_ANY, WxGUITextEditor::OnPageClose)
    END_EVENT_TABLE()
  //================================================================
    



  
  //================================================================
  WxGUITextEditorWindow::WxGUITextEditorWindow( wxWindow *parent, 
                                                    wxString title, 
                                                    wxSize size)
    : wxFrame((wxFrame *)parent, -1, title, wxDefaultPosition, size)
  {     
    
    
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);

    mEditor = new WxGUITextEditor(this);
    sizer->Add(mEditor,1,wxGROW);
    
    //    WxGUICommand* com = new WxGUICommand(this,this);
    //    sizer->Add(com);
    
    SetSizer(sizer);

    // parent window of all bbtk windows will be a child of this
    //    Wx::SetTopWindowParent(this);
    Wx::SetTopWindow(this);
    // Add the method OnWxSignal as a Wx::Signal observer 
    //bbtkAddWxSignalObserver(WxGUITextEditorWindow::OnWxSignal);
    
   
    SetAutoLayout(true);
    Layout();
  }
  //================================================================

  //================================================================
  WxGUITextEditorWindow::~WxGUITextEditorWindow()
  {
  }
  //================================================================


} // namespace bbtk


#endif //_USE_WXWIDGETS_