EditRDL.cxx

Go to the documentation of this file.

// Name:        griddemo.cpp
// Purpose:     Grid control wxWidgets sample
// Author:      Michael Bedward
// Modified by: Santiago Palacios
// RCS-ID:      $Id: EditRDL.cxx,v 1.7 2011/01/13 06:33:39 chengzha Exp $
// Copyright:   (c) Michael Bedward, Julian Smart, Vadim Zeitlin
// Licence:     wxWindows license

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/colordlg.h"
#include "wx/fontdlg.h"
#include "wx/numdlg.h"

#include "wx/grid.h"
#include "wx/generic/gridctrl.h"

#include "wx/dataobj.h"  // For clipboard
#include "wx/clipbrd.h"  // For clipboard

#include "EditRDL.h"


// ----------------------------------------------------------------------------
// EditRDL
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE( EditRDL, wxFrame )

    EVT_MENU( ID_AUTOSIZECOLS, EditRDL::AutoSizeCols )
    EVT_MENU( ID_SETLABEL_FONT, EditRDL::SetLabelFont )

    EVT_MENU( ID_INSERTROW, EditRDL::InsertRow )
    EVT_MENU( ID_INSERTCOL, EditRDL::InsertCol )
    EVT_MENU( ID_DELETEROW, EditRDL::DeleteSelectedRows )
    EVT_MENU( ID_DELETECOL, EditRDL::DeleteSelectedCols )
    EVT_MENU( ID_CLEARGRID, EditRDL::ClearGrid )

    EVT_MENU( wxID_ABOUT, EditRDL::About )
    EVT_MENU( wxID_EXIT, EditRDL::OnQuit )

    EVT_MENU( ID_DESELECT_ALL, EditRDL::DeselectAll)
    EVT_MENU( ID_SELECT_ALL, EditRDL::SelectAll)
    EVT_MENU( ID_SELECT_UNSELECT, EditRDL::OnAddToSelectToggle)
    EVT_MENU( ID_SHOW_SELECTION, EditRDL::OnShowSelection)

    EVT_MENU( wxID_NEW, EditRDL::OnNew)
    EVT_MENU( wxID_OPEN, EditRDL::OnOpen)
    EVT_MENU( wxID_SAVE, EditRDL::OnSave)

    EVT_MENU( wxID_COPY, EditRDL::DoCopyToClipboard)
    EVT_MENU( wxID_PASTE, EditRDL::DoPasteFromClipboard)

    EVT_GRID_LABEL_LEFT_CLICK( EditRDL::OnLabelLeftClick )
    EVT_GRID_CELL_LEFT_CLICK( EditRDL::OnCellLeftClick )
    EVT_GRID_ROW_SIZE( EditRDL::OnRowSize )
    EVT_GRID_COL_SIZE( EditRDL::OnColSize )
    EVT_GRID_SELECT_CELL( EditRDL::OnSelectCell )
    EVT_GRID_RANGE_SELECT( EditRDL::OnRangeSelected )
    EVT_GRID_CELL_CHANGE( EditRDL::OnCellValueChanged )
    EVT_GRID_CELL_BEGIN_DRAG( EditRDL::OnCellBeginDrag )

END_EVENT_TABLE()


EditRDL::EditRDL()
        : wxFrame( (wxFrame *)NULL, wxID_ANY, _T("Edit Resource Description List"),
                   wxDefaultPosition,
                   wxDefaultSize )
{
    // File menu
    wxMenu *fileMenu = new wxMenu;

    fileMenu->Append( wxID_NEW, _T("&New\tCtrl-N"));
    fileMenu->Append( wxID_OPEN, _T("&Open\tCtrl-O"));
    fileMenu->AppendSeparator();

    fileMenu->Append( wxID_SAVE, _T("&Save\tCtrl-S"));
    fileMenu->AppendSeparator();

    fileMenu->Append( wxID_EXIT, _T("E&xit\tAlt-F4") );


    // Edit menu
    wxMenu *editMenu = new wxMenu;
    editMenu->Append( wxID_UNDO, _T("Undo\tCtrl-Z"));
    editMenu->Enable( wxID_UNDO, false);
    editMenu->Append( wxID_REDO, _T("Redo\tCtrl-Y"));
    editMenu->Enable( wxID_REDO, false);
    editMenu->AppendSeparator();

    editMenu->Append( wxID_CUT, _T("Cut\tCtrl-X"));
    editMenu->Append( wxID_COPY, _T("Copy\tCtrl-C"));
    editMenu->Append( wxID_PASTE, _T("Paste\tCtrl-V"));
    editMenu->Append( wxID_DELETE, _T("Delete\tDel"));
    editMenu->AppendSeparator();

    editMenu->Append( ID_SELECT_ALL, _T("Select all\tCtrl-A"));
    editMenu->Append( ID_DESELECT_ALL, _T("Deselect all"));
    editMenu->AppendSeparator();

    editMenu->Append( ID_INSERTROW, _T("Insert &row") );
    editMenu->Append( ID_INSERTCOL, _T("Insert &column") );
    editMenu->Append( ID_DELETEROW, _T("Delete selected ro&ws") );
    editMenu->Append( ID_DELETECOL, _T("Delete selected co&ls") );
    editMenu->Append( ID_CLEARGRID, _T("Cl&ear grid cell contents") );


    // View menu
    wxMenu *viewMenu = new wxMenu;
    viewMenu->Append( ID_AUTOSIZECOLS, _T("&Auto-size cols") );
    viewMenu->AppendSeparator();

    viewMenu->Append( ID_SETLABEL_FONT, _T("Set label fo&nt...") );

    // Select menu
    wxMenu *selectMenu = new wxMenu;
    selectMenu->Append( ID_SELECT_UNSELECT, _T("Add new cells to the selection"),
                        _T("When off, old selection is deselected before ")
                        _T("selecting the new cells"), wxITEM_CHECK );
    selectMenu->Append( ID_SHOW_SELECTION,
                        _T("&Show current selection\tCtrl-Alt-S"));

    // Help menu
    wxMenu *helpMenu = new wxMenu;
    helpMenu->Append( wxID_ABOUT, _T("&About Edit Resource Description List") );

    wxMenuBar *menuBar = new wxMenuBar;
    menuBar->Append( fileMenu, _T("&File") );
    menuBar->Append( editMenu, _T("&Edit") );
    menuBar->Append( viewMenu, _T("&View") );   
    menuBar->Append( selectMenu, _T("&Select") );
    menuBar->Append( helpMenu, _T("&Help") );

    SetMenuBar( menuBar );

    m_addToSel = false;

    grid = new wxGrid( this,
                       wxID_ANY,
                       wxPoint( 0, 0 ),
                       wxSize( 400, 300 ) );

#if wxUSE_LOG
    int gridW = 600, gridH = 300;
    int logW = gridW, logH = 100;

    logWin = new wxTextCtrl( this,
                             wxID_ANY,
                             wxEmptyString,
                             wxPoint( 0, gridH + 20 ),
                             wxSize( logW, logH ),
                             wxTE_MULTILINE );

    logger = new wxLogTextCtrl( logWin );
    m_logOld = wxLog::SetActiveTarget( logger );
    wxLog::SetTimestamp( wxEmptyString );
#endif // wxUSE_LOG

    // this will create a grid and, by default, an associated grid
    // table for strings
    grid->CreateGrid( 0, 0 );
    grid->AppendRows(100);
    grid->AppendCols(8);


    // Set values of column headings
    grid->SetColLabelValue(0, _T("Source\nNamespace") );
    grid->SetColLabelValue(1, _T("Source") );
    grid->SetColLabelValue(2, _T("Target\nNamespace") );
    grid->SetColLabelValue(3, _T("Target") );
    grid->SetColLabelValue(4, _T("Algorithm") );
    grid->SetColLabelValue(5, _T("Data Type") );
    grid->SetColLabelValue(6, _T("Transform Units") );
    grid->SetColLabelValue(7, _T("Filname (Use semicolons for more than one file)") );

    // Automatically size columns to the width of the headings
    //grid->AutoSizeColumns(true);
    grid->AutoSize();

    // Prevent text from going outside of cells
    grid->SetDefaultCellOverflow(false);

    //grid->HandleClipboardEvent() // get clipboard event

    // Autowrap text
    //grid->SetDefaultEditor(new wxGridCellAutoWrapStringEditor);
    grid->SetDefaultRenderer(new wxGridCellAutoWrapStringRenderer);
    //grid->SetCellRenderer(0 , 1, new wxGridCellAutoWrapStringRenderer);
    //grid->SetCellEditor( 0,  1 , new wxGridCellAutoWrapStringEditor);


    wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
    topSizer->Add( grid,
                   1,
                   wxEXPAND );

#if wxUSE_LOG
    topSizer->Add( logWin,
                   0,
                   wxEXPAND );
#endif // wxUSE_LOG

    SetAutoLayout(true);
    SetSizer( topSizer );

    topSizer->Fit( this );

    Centre();
}


EditRDL::~EditRDL()
{
#if wxUSE_LOG
    delete wxLog::SetActiveTarget(m_logOld);
#endif // wxUSE_LOG
}


void EditRDL::AutoSizeCols( wxCommandEvent& WXUNUSED(ev) )
{
    grid->AutoSizeColumns();
    grid->Refresh();
}



void EditRDL::SetLabelFont( wxCommandEvent& WXUNUSED(ev) )
{
    wxFont font = wxGetFontFromUser(this);
    if ( font.Ok() )
    {
        grid->SetLabelFont(font);
    }
}

void EditRDL::OnNew( wxCommandEvent& WXUNUSED(ev) )
{
   
}

void EditRDL::OnOpen( wxCommandEvent& WXUNUSED(ev) ) {
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a Resource Description List"), wxT(""), wxT("*.*"), wxT("*.*"));
  if ( filedialog == NULL ) { return; }
  if ( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

  wxString path = filedialog->GetPath();
  if (m_rdl->Load(std::string(path.ToAscii())) != NULL){
    // FillGridFromDOM(); need to write
  } else {
    wxString msg(wxT("Error: Could not load Resource Description List "));
    msg += path;
    wxLogError(msg);
  };

  if (filedialog){
    delete filedialog;
  }
}

void EditRDL::OnSave( wxCommandEvent& WXUNUSED(ev) ) {
  wxFileDialog * filedialog = new wxFileDialog(this, wxT("Choose a file to save Resource Description List"), wxT(""), wxT("untitled.xml"), wxT("(*.xml)|*.xml"),  wxFD_SAVE|wxFD_OVERWRITE_PROMPT, wxDefaultPosition, wxDefaultSize, wxT("Save"));
  if ( filedialog == NULL ) { return; }
  if ( filedialog->ShowModal() == wxID_CANCEL ){ delete filedialog; return;}

  // FillDOMFromGrid(); need to write
  wxString path = filedialog->GetPath();
  if (m_rdl->Save(std::string(path.ToAscii())) == NULL){
    wxString msg(wxT("Error: Could not save Resource Description List "));
    msg += path;
    wxLogError(msg);
  };

  if (filedialog){
    delete filedialog;
  }
}



void EditRDL::InsertRow( wxCommandEvent& WXUNUSED(ev) )
{
    grid->InsertRows( grid->GetGridCursorRow(), 1 );
}


void EditRDL::InsertCol( wxCommandEvent& WXUNUSED(ev) )
{
    grid->InsertCols( grid->GetGridCursorCol(), 1 );
}


void EditRDL::DeleteSelectedRows( wxCommandEvent& WXUNUSED(ev) )
{
    if ( grid->IsSelection() )
    {
        grid->BeginBatch();
        for ( int n = 0; n < grid->GetNumberRows(); )
        {
            if ( grid->IsInSelection( n , 0 ) )
                grid->DeleteRows( n, 1 );
            else
                n++;
        }
        grid->EndBatch();
    }
}


void EditRDL::DeleteSelectedCols( wxCommandEvent& WXUNUSED(ev) )
{
    if ( grid->IsSelection() )
    {
        grid->BeginBatch();
        for ( int n = 0; n < grid->GetNumberCols(); )
        {
            if ( grid->IsInSelection( 0 , n ) )
                grid->DeleteCols( n, 1 );
            else
                n++;
        }
        grid->EndBatch();
    }
}


void EditRDL::ClearGrid( wxCommandEvent& WXUNUSED(ev) )
{
    grid->ClearGrid();
}


void EditRDL::DeselectAll(wxCommandEvent& WXUNUSED(event))
{
      grid->ClearSelection();
}


void EditRDL::SelectAll(wxCommandEvent& WXUNUSED(event))
{
      grid->SelectAll();
}

void EditRDL::OnAddToSelectToggle(wxCommandEvent& event)
{
    m_addToSel = event.IsChecked();
}

void EditRDL::OnLabelLeftClick( wxGridEvent& ev )
{
  #if wxUSE_LOG
    wxString logBuf;
    if ( ev.GetRow() != -1 )
    {
        logBuf << _T("Left click on row label ") << ev.GetRow();
    }
    else if ( ev.GetCol() != -1 )
    {
        logBuf << _T("Left click on col label ") << ev.GetCol();
    }
    else
    {
        logBuf << _T("Left click on corner label");
    }

    if ( ev.ShiftDown() )
        logBuf << _T(" (shift down)");
    if ( ev.ControlDown() )
        logBuf << _T(" (control down)");
    wxLogMessage( wxT("%s"), logBuf.c_str() );
#endif

    // you must call event skip if you want default grid processing
    //
    ev.Skip();
}


void EditRDL::OnCellLeftClick( wxGridEvent& ev )
{
  #if wxUSE_LOG
    wxLogMessage(_T("Left click at row %d, col %d"), ev.GetRow(), ev.GetCol());
#endif

    // you must call event skip if you want default grid processing
    // (cell highlighting etc.)
    //
    ev.Skip();
}


void EditRDL::OnRowSize( wxGridSizeEvent& ev )
{
  #if wxUSE_LOG
    wxLogMessage(_T("Resized row %d"), ev.GetRowOrCol());
#endif

    ev.Skip();
}


void EditRDL::OnColSize( wxGridSizeEvent& ev )
{
  #if wxUSE_LOG
    wxLogMessage(_T("Resized col %d"), ev.GetRowOrCol());
#endif

    ev.Skip();
}


void EditRDL::OnShowSelection(wxCommandEvent& WXUNUSED(event))
{
    // max number of elements to dump -- otherwise it can take too much time
    static const size_t countMax = 100;

    bool rows = false;

    switch ( grid->GetSelectionMode() )
    {
        case wxGrid::wxGridSelectCells:
            {
                const wxGridCellCoordsArray cells(grid->GetSelectedCells());
                size_t count = cells.size();
                wxLogMessage(_T("%lu cells selected:"), (unsigned long)count);
                if ( count > countMax )
                {
                    wxLogMessage(_T("[too many selected cells, ")
                                 _T("showing only the first %lu]"),
                                 (unsigned long)countMax);
                    count = countMax;
                }

                for ( size_t n = 0; n < count; n++ )
                {
                    const wxGridCellCoords& c = cells[n];
                    wxLogMessage(_T("  selected cell %lu: (%d, %d)"),
                                 (unsigned long)n, c.GetCol(), c.GetRow());
                }
            }
            break;

        case wxGrid::wxGridSelectRows:
            rows = true;
            // fall through

        case wxGrid::wxGridSelectColumns:
            {
                const wxChar *plural, *single;
                if ( rows )
                {
                    plural = _T("rows");
                    single = _T("row");
                }
                else // columns
                {
                    plural = _T("columns");
                    single = _T("column");
                }

                // NB: extra parentheses needed to avoid bcc 5.82 errors
                const wxArrayInt sels((rows ? grid->GetSelectedRows()
                                            : grid->GetSelectedCols()));
                size_t count = sels.size();
                wxLogMessage(_T("%lu %s selected:"),
                             (unsigned long)count, plural);
                if ( count > countMax )
                {
                    wxLogMessage(_T("[too many selected %s, ")
                                 _T("showing only the first %lu]"),
                                 plural, (unsigned long)countMax);
                    count = countMax;
                }

                for ( size_t n = 0; n < count; n++ )
                {
                    wxLogMessage(_T("  selected %s %lu: %d"),
                                 single, (unsigned long)n, sels[n]);
                }
            }
            break;

        default:
            wxFAIL_MSG( _T("unknown wxGrid selection mode") );
            break;
    }
}

void EditRDL::OnSelectCell( wxGridEvent& ev )
{
#if wxUSE_LOG
    wxString logBuf;
    if ( ev.Selecting() )
        logBuf << _T("Selected ");
    else
        logBuf << _T("Deselected ");
    logBuf << _T("cell at row ") << ev.GetRow()
           << _T(" col ") << ev.GetCol()
           << _T(" ( ControlDown: ")<< (ev.ControlDown() ? 'T':'F')
           << _T(", ShiftDown: ")<< (ev.ShiftDown() ? 'T':'F')
           << _T(", AltDown: ")<< (ev.AltDown() ? 'T':'F')
           << _T(", MetaDown: ")<< (ev.MetaDown() ? 'T':'F') << _T(" )");

    //Indicate whether this column was moved
    if ( ((wxGrid *)ev.GetEventObject())->GetColPos( ev.GetCol() ) != ev.GetCol() )
        logBuf << _T(" *** Column moved, current position: ") << ((wxGrid *)ev.GetEventObject())->GetColPos( ev.GetCol() );

    wxLogMessage( wxT("%s"), logBuf.c_str() );
#endif

    // you must call Skip() if you want the default processing
    // to occur in wxGrid
    ev.Skip();
}

void EditRDL::OnRangeSelected( wxGridRangeSelectEvent& ev )
{
#if wxUSE_LOG
    wxString logBuf;
    if ( ev.Selecting() )
        logBuf << _T("Selected ");
    else
        logBuf << _T("Deselected ");
    logBuf << _T("cells from row ") << ev.GetTopRow()
           << _T(" col ") << ev.GetLeftCol()
           << _T(" to row ") << ev.GetBottomRow()
           << _T(" col ") << ev.GetRightCol()
           << _T(" ( ControlDown: ")<< (ev.ControlDown() ? 'T':'F')
           << _T(", ShiftDown: ")<< (ev.ShiftDown() ? 'T':'F')
           << _T(", AltDown: ")<< (ev.AltDown() ? 'T':'F')
           << _T(", MetaDown: ")<< (ev.MetaDown() ? 'T':'F') << _T(" )");
    wxLogMessage( wxT("%s"), logBuf.c_str() );
#endif

    ev.Skip();
}

void EditRDL::OnCellValueChanged( wxGridEvent& ev )
{
    int row = ev.GetRow(),
        col = ev.GetCol();

    #if wxUSE_LOG
    wxLogMessage(_T("Value changed for cell at row %d, col %d: now \"%s\""),
                 row, col, grid->GetCellValue(row, col).c_str());
#endif

    ev.Skip();
}

void EditRDL::OnCellBeginDrag( wxGridEvent& ev )
{
  #if wxUSE_LOG
    wxLogMessage(_T("Got request to drag cell at row %d, col %d"),
                 ev.GetRow(), ev.GetCol());
#endif

    ev.Skip();
}


void EditRDL::About(  wxCommandEvent& WXUNUSED(ev) )
{
    (void)wxMessageBox( _T("\n\nEdit Resource Description List \n\n")
                        _T("Copyright 2010, The Unversity of Iowa."),
                        _T("About Edit Resource Description List"),
                        wxOK );
}


void EditRDL::OnQuit( wxCommandEvent& WXUNUSED(ev) )
{
    Close( true );
}

void EditRDL::DoCopyToClipboard( wxCommandEvent& event ){
    // On X11, we want to get the data from the primary selection instead
    // of the normal clipboard (which isn't normal under X11 at all). This
    // call has no effect under MSW.
    wxTheClipboard->UsePrimarySelection();

    const int row = grid->GetGridCursorRow();
    const int col = grid->GetGridCursorCol();

    wxString text = grid->GetCellValue(row, col);
    //grid->GetCellValue(row, col).c_str()

    if (text.IsEmpty()){
        wxLogMessage( _T("No text to copy."));
        return;
    }

    if (!wxTheClipboard->Open()){
        wxLogMessage( _T("Error opening the clipboard."));
        return;
    } else {
        wxLogMessage( _T("Successfully opened the clipboard."));
    }

    // Clear the clipboard before adding to the clipboard.
    // Not clearing the clipboard is a common mistake. 
    // See http://www.clipboardextender.com/?page_id=7
    //  You’re supposed to open the clipboard, erase the clipboard, add your data 
    // (for all formats), close the clipboard.  It’s simple - open, clear, update, close.
    wxTheClipboard->Clear();

    wxTextDataObject *data = new wxTextDataObject( text );

    if (!wxTheClipboard->SetData( data )){
        wxLogMessage( _T("Error while copying to the clipboard."));
    }else{
        wxLogMessage( _T("Successfully copied data to the clipboard."));
    }

    wxTheClipboard->Close();

    wxLogMessage( _T("Closed the clipboard."));
}

void EditRDL::DoPasteFromClipboard( wxCommandEvent& event ){
    // On X11, we want to get the data from the primary selection instead
    // of the normal clipboard (which isn't normal under X11 at all). This
    // call has no effect under MSW.
    wxTheClipboard->UsePrimarySelection();

    const int row = grid->GetGridCursorRow();
    const int col = grid->GetGridCursorCol();

    //const wxGridCellCoordsArray selectedCells = grid->GetSelectedCells();
    //wxArrayInt temp1 = grid->GetSelectedRows();
    //wxArrayInt temp2 = grid->GetSelectedCols();
    //wxGridCellCoordsArray temp3 = grid->GetSelectionBlockTopLeft();
    //wxGridCellCoordsArray temp4 = grid->GetSelectionBlockBottomRight();



    if (!wxTheClipboard->Open()){
        wxLogMessage( _T("Error opening the clipboard."));
        return;
    }else{
        wxLogMessage( _T("Successfully opened the clipboard."));
    }

    wxTextDataObject data;

    if (wxTheClipboard->IsSupported( data.GetFormat() )){
        wxLogMessage( _T("Clipboard supports requested format."));

        if (wxTheClipboard->GetData( data )){
          wxLogMessage( _T("Successfully retrieved data from the clipboard."));
          wxLogMessage( data.GetText());

          // Below is a hack since GetSelectedCells, GetSelectedRows, GetSelectedCols,
          // GetSelectionBlockTopLeft, GetSelectionBlockBottomRight does not work
          // But it does work for arbitrarily selected regions when pasting a single value.
          if ( grid->IsSelection() ){
            grid->BeginBatch();
            for(int j=0; j<grid->GetNumberCols(); j++) {
              for(int i=0; i<grid->GetNumberRows(); i++){
                if ( grid->IsInSelection(i,j) ){
                  grid->SetCellValue( i, j, data.GetText() );
                  //wxLogMessage(_T("Value changed for cell at row %d, col %d: now \"%s\""),
                  //  i, j, grid->GetCellValue(i, j).c_str());
                }  
              }
            }
            grid->EndBatch();
          } else {
            grid->SetCellValue( row, col, data.GetText() );
          }

        }else{
          wxLogMessage( _T("Error getting data from the clipboard."));
        }
    }else{
        wxLogMessage( _T("Clipboard doesn't support requested format."));
    }

    wxTheClipboard->Close();

    wxLogMessage( _T("Closed the clipboard."));

}