[wxWidgets.git] / tests / controls / gridtest.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/controls/gridtest.cpp
// Purpose:     wxGrid unit test
// Author:      Steven Lamerton
// Created:     2010-06-25
// RCS-ID:      $Id$
// Copyright:   (c) 2010 Steven Lamerton
///////////////////////////////////////////////////////////////////////////////

#include "testprec.h"

#if wxUSE_GRID

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/grid.h"
#include "testableframe.h"
#include "asserthelper.h"
#include "wx/uiaction.h"

class GridTestCase : public CppUnit::TestCase
{
public:
    GridTestCase() { }

    virtual void setUp();
    virtual void tearDown();

private:
    CPPUNIT_TEST_SUITE( GridTestCase );
        WXUISIM_TEST( CellEdit );
        WXUISIM_TEST( CellClick );
        WXUISIM_TEST( CellSelect );
        WXUISIM_TEST( LabelClick );
        WXUISIM_TEST( SortClick );
        WXUISIM_TEST( Size );
        WXUISIM_TEST( RangeSelect );
        CPPUNIT_TEST( Cursor );
        CPPUNIT_TEST( Selection );
        CPPUNIT_TEST( AddRowCol );
        CPPUNIT_TEST( ColumnOrder );
        CPPUNIT_TEST( LineFormatting );
        CPPUNIT_TEST( SortSupport );
        CPPUNIT_TEST( Labels );
        CPPUNIT_TEST( SelectionMode );
        CPPUNIT_TEST( CellFormatting );
        WXUISIM_TEST( Editable );
        WXUISIM_TEST( ReadOnly );
        CPPUNIT_TEST( PseudoTest_NativeHeader );
        WXUISIM_TEST( LabelClick );
        WXUISIM_TEST( SortClick );
        CPPUNIT_TEST( ColumnOrder );
        CPPUNIT_TEST( PseudoTest_NativeLabels );
        WXUISIM_TEST( LabelClick );
        WXUISIM_TEST( SortClick );
        CPPUNIT_TEST( ColumnOrder );
    CPPUNIT_TEST_SUITE_END();

    void CellEdit();
    void CellClick();
    void CellSelect();
    void LabelClick();
    void SortClick();
    void Size();
    void RangeSelect();
    void Cursor();
    void Selection();
    void AddRowCol();
    void ColumnOrder();
    void LineFormatting();
    void SortSupport();
    void Labels();
    void SelectionMode();
    void CellFormatting();
    void Editable();
    void ReadOnly();
    void PseudoTest_NativeHeader() { ms_nativeheader = true; }
    void PseudoTest_NativeLabels() { ms_nativeheader = false;
                                     ms_nativelabels = true; }

    static bool ms_nativeheader;
    static bool ms_nativelabels;

    wxGrid *m_grid;

    DECLARE_NO_COPY_CLASS(GridTestCase)
};

// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( GridTestCase );

// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( GridTestCase, "GridTestCase" );

//initialise the static variable
bool GridTestCase::ms_nativeheader = false;
bool GridTestCase::ms_nativelabels = false;

void GridTestCase::setUp()
{
    m_grid = new wxGrid(wxTheApp->GetTopWindow(), wxID_ANY);
    m_grid->CreateGrid(10, 2);
    m_grid->SetSize(400, 200);

    if( ms_nativeheader )
        m_grid->UseNativeColHeader();

    if( ms_nativelabels )
        m_grid->SetUseNativeColLabels();

    m_grid->Refresh();
    m_grid->Update();
}

void GridTestCase::tearDown()
{
    // This is just a hack to continue the rest of the tests to run: if we
    // destroy the header control while it has capture, this results in an
    // assert failure and while handling an exception from it more bad things
    // happen (as it's thrown from a dtor), resulting in simply aborting
    // everything. So ensure that it doesn't have capture in any case.
    //
    // Of course, the right thing to do would be to understand why does it
    // still have capture when the grid is destroyed sometimes.
    wxWindow* const win = wxWindow::GetCapture();
    if ( win )
        win->ReleaseMouse();

    wxDELETE(m_grid);
}

void GridTestCase::CellEdit()
{
#if wxUSE_UIACTIONSIMULATOR
    EventCounter changing(m_grid, wxEVT_GRID_CELL_CHANGING);
    EventCounter changed(m_grid, wxEVT_GRID_CELL_CHANGED);
    EventCounter created(m_grid, wxEVT_GRID_EDITOR_CREATED);

    wxUIActionSimulator sim;

    m_grid->SetFocus();
    m_grid->SetGridCursor(1, 1);
    m_grid->ShowCellEditControl();

    sim.Text("abab");
    sim.Char(WXK_RETURN);

    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, created.GetCount());
    CPPUNIT_ASSERT_EQUAL(1, changing.GetCount());
    CPPUNIT_ASSERT_EQUAL(1, changed.GetCount());
#endif
}

void GridTestCase::CellClick()
{
#if wxUSE_UIACTIONSIMULATOR
    EventCounter lclick(m_grid, wxEVT_GRID_CELL_LEFT_CLICK);
    EventCounter ldclick(m_grid, wxEVT_GRID_CELL_LEFT_DCLICK);
    EventCounter rclick(m_grid, wxEVT_GRID_CELL_RIGHT_CLICK);
    EventCounter rdclick(m_grid, wxEVT_GRID_CELL_RIGHT_DCLICK);


    wxUIActionSimulator sim;

    wxRect rect = m_grid->CellToRect(0, 0);
    wxPoint point = m_grid->CalcScrolledPosition(rect.GetPosition());
    point = m_grid->ClientToScreen(point + wxPoint(m_grid->GetRowLabelSize(),
                                                   m_grid->GetColLabelSize())
                                         + wxPoint(2, 2));

    sim.MouseMove(point);
    wxYield();

    sim.MouseClick();
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, lclick.GetCount());
    lclick.Clear();

    sim.MouseDblClick();
    wxYield();

    //A double click event sends a single click event first
    //test to ensure this still happens in the future
    CPPUNIT_ASSERT_EQUAL(1, lclick.GetCount());
    CPPUNIT_ASSERT_EQUAL(1, ldclick.GetCount());

    sim.MouseClick(wxMOUSE_BTN_RIGHT);
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, rclick.GetCount());
    rclick.Clear();

    sim.MouseDblClick(wxMOUSE_BTN_RIGHT);
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, rclick.GetCount());
    CPPUNIT_ASSERT_EQUAL(1, rdclick.GetCount());
#endif
}

void GridTestCase::CellSelect()
{
#if wxUSE_UIACTIONSIMULATOR
    EventCounter cell(m_grid, wxEVT_GRID_SELECT_CELL);

    wxUIActionSimulator sim;

    wxRect rect = m_grid->CellToRect(0, 0);
    wxPoint point = m_grid->CalcScrolledPosition(rect.GetPosition());
    point = m_grid->ClientToScreen(point + wxPoint(m_grid->GetRowLabelSize(),
                                                   m_grid->GetColLabelSize())
                                         + wxPoint(4, 4));

    sim.MouseMove(point);
    wxYield();

    sim.MouseClick();
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, cell.GetCount());

    cell.Clear();

    m_grid->SetGridCursor(1, 1);
    m_grid->GoToCell(1, 0);

    sim.MouseMove(point);
    wxYield();

    sim.MouseDblClick();
    wxYield();

    CPPUNIT_ASSERT_EQUAL(3, cell.GetCount());
#endif
}

void GridTestCase::LabelClick()
{
#if wxUSE_UIACTIONSIMULATOR
    EventCounter lclick(m_grid, wxEVT_GRID_LABEL_LEFT_CLICK);
    EventCounter ldclick(m_grid, wxEVT_GRID_LABEL_LEFT_DCLICK);
    EventCounter rclick(m_grid, wxEVT_GRID_LABEL_RIGHT_CLICK);
    EventCounter rdclick(m_grid, wxEVT_GRID_LABEL_RIGHT_DCLICK);

    wxUIActionSimulator sim;

    wxPoint pos(m_grid->GetRowLabelSize() + 2, 2);
    pos = m_grid->ClientToScreen(pos);

    sim.MouseMove(pos);
    wxYield();

    sim.MouseClick();
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, lclick.GetCount());

    sim.MouseDblClick();
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, ldclick.GetCount());

    sim.MouseClick(wxMOUSE_BTN_RIGHT);
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, rclick.GetCount());
    rclick.Clear();

    sim.MouseDblClick(wxMOUSE_BTN_RIGHT);
    wxYield();

    if( ms_nativeheader )
    {
        //Right double click not supported with native headers so we get two
        //right click events
        CPPUNIT_ASSERT_EQUAL(2, rclick.GetCount());
    }
    else
    {
        CPPUNIT_ASSERT_EQUAL(1, rclick.GetCount());
        CPPUNIT_ASSERT_EQUAL(1, rdclick.GetCount());
    }
#endif
}

void GridTestCase::SortClick()
{
#if wxUSE_UIACTIONSIMULATOR
    m_grid->SetSortingColumn(0);

    EventCounter sort(m_grid, wxEVT_GRID_COL_SORT);

    wxUIActionSimulator sim;

    wxPoint pos(m_grid->GetRowLabelSize() + 4, 4);
    pos = m_grid->ClientToScreen(pos);

    sim.MouseMove(pos);
    wxYield();

    sim.MouseClick();
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, sort.GetCount());
#endif
}

void GridTestCase::Size()
{
#if wxUSE_UIACTIONSIMULATOR && !defined(__WXGTK__)
    EventCounter colsize(m_grid, wxEVT_GRID_COL_SIZE);
    EventCounter rowsize(m_grid, wxEVT_GRID_ROW_SIZE);

    wxUIActionSimulator sim;

    wxPoint pt = m_grid->ClientToScreen(wxPoint(m_grid->GetRowLabelSize() +
                                        m_grid->GetColSize(0), 5));

    sim.MouseMove(pt);
    wxYield();

    sim.MouseDown();
    wxYield();

    sim.MouseMove(pt.x + 50, pt.y);
    wxYield();

    sim.MouseUp();
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, colsize.GetCount());

    pt = m_grid->ClientToScreen(wxPoint(5, m_grid->GetColLabelSize() +
                                        m_grid->GetRowSize(0)));

    sim.MouseDragDrop(pt.x, pt.y, pt.x, pt.y + 50);
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, rowsize.GetCount());
#endif
}

void GridTestCase::RangeSelect()
{
#if wxUSE_UIACTIONSIMULATOR
    EventCounter select(m_grid, wxEVT_GRID_RANGE_SELECT);

    wxUIActionSimulator sim;

    //We add the extra 10 to ensure that we are inside the cell
    wxPoint pt = m_grid->ClientToScreen(wxPoint(m_grid->GetRowLabelSize() + 10,
                                                m_grid->GetColLabelSize() + 10)
                                                );

    sim.MouseMove(pt);
    wxYield();

    sim.MouseDown();
    wxYield();

    sim.MouseMove(pt.x + 50, pt.y + 50);
    wxYield();

    sim.MouseUp();
    wxYield();

    CPPUNIT_ASSERT_EQUAL(1, select.GetCount());
#endif
}

void GridTestCase::Cursor()
{
    m_grid->SetGridCursor(1, 1);

    CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorCol());
    CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorRow());

    m_grid->MoveCursorDown(false);
    m_grid->MoveCursorLeft(false);
    m_grid->MoveCursorUp(false);
    m_grid->MoveCursorUp(false);
    m_grid->MoveCursorRight(false);

    CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorCol());
    CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorRow());

    m_grid->SetCellValue(0, 0, "some text");
    m_grid->SetCellValue(3, 0, "other text");
    m_grid->SetCellValue(0, 1, "more text");
    m_grid->SetCellValue(3, 1, "extra text");

    m_grid->Update();
    m_grid->Refresh();

    m_grid->MoveCursorLeftBlock(false);

    CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorCol());
    CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorRow());

    m_grid->MoveCursorDownBlock(false);

    CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorCol());
    CPPUNIT_ASSERT_EQUAL(3, m_grid->GetGridCursorRow());

    m_grid->MoveCursorRightBlock(false);

    CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorCol());
    CPPUNIT_ASSERT_EQUAL(3, m_grid->GetGridCursorRow());

    m_grid->MoveCursorUpBlock(false);

    CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorCol());
    CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorRow());
}

void GridTestCase::Selection()
{
    m_grid->SelectAll();

    CPPUNIT_ASSERT(m_grid->IsSelection());
    CPPUNIT_ASSERT(m_grid->IsInSelection(0, 0));
    CPPUNIT_ASSERT(m_grid->IsInSelection(9, 1));

    m_grid->SelectBlock(1, 0, 3, 1);

    wxGridCellCoordsArray topleft = m_grid->GetSelectionBlockTopLeft();
    wxGridCellCoordsArray bottomright = m_grid->GetSelectionBlockBottomRight();

    CPPUNIT_ASSERT_EQUAL(1, topleft.Count());
    CPPUNIT_ASSERT_EQUAL(1, bottomright.Count());

    CPPUNIT_ASSERT_EQUAL(0, topleft.Item(0).GetCol());
    CPPUNIT_ASSERT_EQUAL(1, topleft.Item(0).GetRow());
    CPPUNIT_ASSERT_EQUAL(1, bottomright.Item(0).GetCol());
    CPPUNIT_ASSERT_EQUAL(3, bottomright.Item(0).GetRow());

    m_grid->SelectCol(1);

    CPPUNIT_ASSERT(m_grid->IsInSelection(0, 1));
    CPPUNIT_ASSERT(m_grid->IsInSelection(9, 1));
    CPPUNIT_ASSERT(!m_grid->IsInSelection(3, 0));

    m_grid->SelectRow(4);

    CPPUNIT_ASSERT(m_grid->IsInSelection(4, 0));
    CPPUNIT_ASSERT(m_grid->IsInSelection(4, 1));
    CPPUNIT_ASSERT(!m_grid->IsInSelection(3, 0));
}

void GridTestCase::AddRowCol()
{
    CPPUNIT_ASSERT_EQUAL(10, m_grid->GetNumberRows());
    CPPUNIT_ASSERT_EQUAL(2, m_grid->GetNumberCols());

    m_grid->AppendCols();
    m_grid->AppendRows();

    CPPUNIT_ASSERT_EQUAL(11, m_grid->GetNumberRows());
    CPPUNIT_ASSERT_EQUAL(3, m_grid->GetNumberCols());

    m_grid->AppendCols(2);
    m_grid->AppendRows(2);

    CPPUNIT_ASSERT_EQUAL(13, m_grid->GetNumberRows());
    CPPUNIT_ASSERT_EQUAL(5, m_grid->GetNumberCols());

    m_grid->InsertCols(1, 2);
    m_grid->InsertRows(2, 3);

    CPPUNIT_ASSERT_EQUAL(16, m_grid->GetNumberRows());
    CPPUNIT_ASSERT_EQUAL(7, m_grid->GetNumberCols());
}

void GridTestCase::ColumnOrder()
{
    m_grid->AppendCols(2);

    CPPUNIT_ASSERT_EQUAL(4, m_grid->GetNumberCols());

    wxArrayInt neworder;
    neworder.push_back(1);
    neworder.push_back(3);
    neworder.push_back(2);
    neworder.push_back(0);

    m_grid->SetColumnsOrder(neworder);

    CPPUNIT_ASSERT_EQUAL(0, m_grid->GetColPos(1));
    CPPUNIT_ASSERT_EQUAL(1, m_grid->GetColPos(3));
    CPPUNIT_ASSERT_EQUAL(2, m_grid->GetColPos(2));
    CPPUNIT_ASSERT_EQUAL(3, m_grid->GetColPos(0));

    CPPUNIT_ASSERT_EQUAL(1, m_grid->GetColAt(0));
    CPPUNIT_ASSERT_EQUAL(3, m_grid->GetColAt(1));
    CPPUNIT_ASSERT_EQUAL(2, m_grid->GetColAt(2));
    CPPUNIT_ASSERT_EQUAL(0, m_grid->GetColAt(3));

    m_grid->ResetColPos();

    CPPUNIT_ASSERT_EQUAL(0, m_grid->GetColPos(0));
    CPPUNIT_ASSERT_EQUAL(1, m_grid->GetColPos(1));
    CPPUNIT_ASSERT_EQUAL(2, m_grid->GetColPos(2));
    CPPUNIT_ASSERT_EQUAL(3, m_grid->GetColPos(3));
}

void GridTestCase::LineFormatting()
{
    CPPUNIT_ASSERT(m_grid->GridLinesEnabled());

    m_grid->EnableGridLines(false);

    CPPUNIT_ASSERT(!m_grid->GridLinesEnabled());

    m_grid->EnableGridLines();

    m_grid->SetGridLineColour(*wxRED);

    CPPUNIT_ASSERT_EQUAL(m_grid->GetGridLineColour(), *wxRED);
}

void GridTestCase::SortSupport()
{
    CPPUNIT_ASSERT_EQUAL(wxNOT_FOUND, m_grid->GetSortingColumn());

    m_grid->SetSortingColumn(1);

    CPPUNIT_ASSERT(!m_grid->IsSortingBy(0));
    CPPUNIT_ASSERT(m_grid->IsSortingBy(1));
    CPPUNIT_ASSERT(m_grid->IsSortOrderAscending());

    m_grid->SetSortingColumn(0, false);

    CPPUNIT_ASSERT(m_grid->IsSortingBy(0));
    CPPUNIT_ASSERT(!m_grid->IsSortingBy(1));
    CPPUNIT_ASSERT(!m_grid->IsSortOrderAscending());

    m_grid->UnsetSortingColumn();

    CPPUNIT_ASSERT(!m_grid->IsSortingBy(0));
    CPPUNIT_ASSERT(!m_grid->IsSortingBy(1));
}

void GridTestCase::Labels()
{
    CPPUNIT_ASSERT_EQUAL("A", m_grid->GetColLabelValue(0));
    CPPUNIT_ASSERT_EQUAL("1", m_grid->GetRowLabelValue(0));

    m_grid->SetColLabelValue(0, "Column 1");
    m_grid->SetRowLabelValue(0, "Row 1");

    CPPUNIT_ASSERT_EQUAL("Column 1", m_grid->GetColLabelValue(0));
    CPPUNIT_ASSERT_EQUAL("Row 1", m_grid->GetRowLabelValue(0));

    m_grid->SetLabelTextColour(*wxGREEN);
    m_grid->SetLabelBackgroundColour(*wxRED);

    CPPUNIT_ASSERT_EQUAL(*wxGREEN, m_grid->GetLabelTextColour());
    CPPUNIT_ASSERT_EQUAL(*wxRED, m_grid->GetLabelBackgroundColour());

    m_grid->SetColLabelTextOrientation(wxVERTICAL);

    CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxVERTICAL),
                         static_cast<int>(m_grid->GetColLabelTextOrientation()));
}

void GridTestCase::SelectionMode()
{
    //We already test this mode in Select
    CPPUNIT_ASSERT_EQUAL(wxGrid::wxGridSelectCells,
                         m_grid->GetSelectionMode());

    //Test row selection be selecting a single cell and checking the whole
    //row is selected
    m_grid->SetSelectionMode(wxGrid::wxGridSelectRows);
    m_grid->SelectBlock(3, 1, 3, 1);

    wxArrayInt selectedRows = m_grid->GetSelectedRows();
    CPPUNIT_ASSERT_EQUAL(1, selectedRows.Count());
    CPPUNIT_ASSERT_EQUAL(3, selectedRows[0]);

    CPPUNIT_ASSERT_EQUAL(wxGrid::wxGridSelectRows,
                         m_grid->GetSelectionMode());


    //Test column selection be selecting a single cell and checking the whole
    //column is selected
    m_grid->SetSelectionMode(wxGrid::wxGridSelectColumns);
    m_grid->SelectBlock(3, 1, 3, 1);

    wxArrayInt selectedCols = m_grid->GetSelectedCols();
    CPPUNIT_ASSERT_EQUAL(1, selectedCols.Count());
    CPPUNIT_ASSERT_EQUAL(1, selectedCols[0]);

    CPPUNIT_ASSERT_EQUAL(wxGrid::wxGridSelectColumns,
                         m_grid->GetSelectionMode());
}

void GridTestCase::CellFormatting()
{
    //Check that initial alignment is default
    int horiz, cellhoriz, vert, cellvert;

    m_grid->GetDefaultCellAlignment(&horiz, &vert);
    m_grid->GetCellAlignment(0, 0, &cellhoriz, &cellvert);

    CPPUNIT_ASSERT_EQUAL(cellhoriz, horiz);
    CPPUNIT_ASSERT_EQUAL(cellvert, vert);

    //Check initial text colour and background colour are default
    wxColour text, back;

    back = m_grid->GetDefaultCellBackgroundColour();

    CPPUNIT_ASSERT_EQUAL(back, m_grid->GetCellBackgroundColour(0, 0));

    back = m_grid->GetDefaultCellTextColour();

    CPPUNIT_ASSERT_EQUAL(back, m_grid->GetCellTextColour(0, 0));

#if WXWIN_COMPATIBILITY_2_8
    m_grid->SetCellAlignment(wxALIGN_CENTRE, 0, 0);
    m_grid->GetCellAlignment(0, 0, &cellhoriz, &cellvert);

    CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxALIGN_CENTRE), cellhoriz);
    CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxALIGN_CENTRE), cellvert);
#endif // WXWIN_COMPATIBILITY_2_8

    m_grid->SetCellAlignment(0, 0, wxALIGN_LEFT, wxALIGN_BOTTOM);
    m_grid->GetCellAlignment(0, 0, &cellhoriz, &cellvert);

    CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxALIGN_LEFT), cellhoriz);
    CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxALIGN_BOTTOM), cellvert);

#if WXWIN_COMPATIBILITY_2_8
    m_grid->SetCellTextColour(*wxRED, 0, 0);
    CPPUNIT_ASSERT_EQUAL(*wxRED, m_grid->GetCellTextColour(0, 0));
#endif // WXWIN_COMPATIBILITY_2_8

    m_grid->SetCellTextColour(0, 0, *wxGREEN);
    CPPUNIT_ASSERT_EQUAL(*wxGREEN, m_grid->GetCellTextColour(0, 0));
}

void GridTestCase::Editable()
{
#if wxUSE_UIACTIONSIMULATOR
    //As the grid is not editable we shouldn't create an editor
    EventCounter created(m_grid, wxEVT_GRID_EDITOR_CREATED);

    wxUIActionSimulator sim;

    CPPUNIT_ASSERT(m_grid->IsEditable());

    m_grid->EnableEditing(false);

    CPPUNIT_ASSERT(!m_grid->IsEditable());

    m_grid->SetFocus();
    m_grid->SetGridCursor(1, 1);
    m_grid->ShowCellEditControl();

    sim.Text("abab");
    wxYield();

    sim.Char(WXK_RETURN);
    wxYield();

    CPPUNIT_ASSERT_EQUAL(0, created.GetCount());
#endif
}

void GridTestCase::ReadOnly()
{
#if wxUSE_UIACTIONSIMULATOR
    //As the cell is readonly we shouldn't create an editor
    EventCounter created(m_grid, wxEVT_GRID_EDITOR_CREATED);

    wxUIActionSimulator sim;

    CPPUNIT_ASSERT(!m_grid->IsReadOnly(1, 1));

    m_grid->SetReadOnly(1, 1);

    CPPUNIT_ASSERT(m_grid->IsReadOnly(1, 1));

    m_grid->SetFocus();
    m_grid->SetGridCursor(1, 1);

    CPPUNIT_ASSERT(m_grid->IsCurrentCellReadOnly());

    m_grid->ShowCellEditControl();

    sim.Text("abab");
    wxYield();

    sim.Char(WXK_RETURN);
    wxYield();

    CPPUNIT_ASSERT_EQUAL(0, created.GetCount());
#endif
}

#endif //wxUSE_GRID
Commit	Line	Data
232fdc63 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/controls/gridtest.cpp
	3	// Purpose: wxGrid unit test
	4	// Author: Steven Lamerton
	5	// Created: 2010-06-25
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2010 Steven Lamerton
	8	///////////////////////////////////////////////////////////////////////////////
	9
	10	#include "testprec.h"
	11
	12	#if wxUSE_GRID
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#ifndef WX_PRECOMP
	19	#include "wx/app.h"
	20	#endif // WX_PRECOMP
	21
	22	#include "wx/grid.h"
	23	#include "testableframe.h"
	24	#include "asserthelper.h"
	25	#include "wx/uiaction.h"
	26
	27	class GridTestCase : public CppUnit::TestCase
	28	{
	29	public:
	30	GridTestCase() { }
	31
	32	virtual void setUp();
	33	virtual void tearDown();
	34
	35	private:
	36	CPPUNIT_TEST_SUITE( GridTestCase );
	37	WXUISIM_TEST( CellEdit );
	38	WXUISIM_TEST( CellClick );
	39	WXUISIM_TEST( CellSelect );
	40	WXUISIM_TEST( LabelClick );
	41	WXUISIM_TEST( SortClick );
	42	WXUISIM_TEST( Size );
	43	WXUISIM_TEST( RangeSelect );
	44	CPPUNIT_TEST( Cursor );
	45	CPPUNIT_TEST( Selection );
	46	CPPUNIT_TEST( AddRowCol );
	47	CPPUNIT_TEST( ColumnOrder );
	48	CPPUNIT_TEST( LineFormatting );
	49	CPPUNIT_TEST( SortSupport );
	50	CPPUNIT_TEST( Labels );
	51	CPPUNIT_TEST( SelectionMode );
	52	CPPUNIT_TEST( CellFormatting );
	53	WXUISIM_TEST( Editable );
	54	WXUISIM_TEST( ReadOnly );
	55	CPPUNIT_TEST( PseudoTest_NativeHeader );
	56	WXUISIM_TEST( LabelClick );
	57	WXUISIM_TEST( SortClick );
	58	CPPUNIT_TEST( ColumnOrder );
	59	CPPUNIT_TEST( PseudoTest_NativeLabels );
	60	WXUISIM_TEST( LabelClick );
	61	WXUISIM_TEST( SortClick );
	62	CPPUNIT_TEST( ColumnOrder );
	63	CPPUNIT_TEST_SUITE_END();
	64
65	void CellEdit();
66	void CellClick();
67	void CellSelect();
68	void LabelClick();
69	void SortClick();
70	void Size();
71	void RangeSelect();
72	void Cursor();
73	void Selection();
74	void AddRowCol();
75	void ColumnOrder();
76	void LineFormatting();
77	void SortSupport();
78	void Labels();
79	void SelectionMode();
80	void CellFormatting();
81	void Editable();
82	void ReadOnly();
83	void PseudoTest_NativeHeader() { ms_nativeheader = true; }
84	void PseudoTest_NativeLabels() { ms_nativeheader = false;
85	ms_nativelabels = true; }
86
87	static bool ms_nativeheader;
88	static bool ms_nativelabels;
89
90	wxGrid *m_grid;
91
92	DECLARE_NO_COPY_CLASS(GridTestCase)
93	};
94
95	// register in the unnamed registry so that these tests are run by default
96	CPPUNIT_TEST_SUITE_REGISTRATION( GridTestCase );
97
e3778b4d	98	// also include in its own registry so that these tests can be run alone
232fdc63 VZ	99	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( GridTestCase, "GridTestCase" );
	100
	101	//initialise the static variable
	102	bool GridTestCase::ms_nativeheader = false;
	103	bool GridTestCase::ms_nativelabels = false;
	104
	105	void GridTestCase::setUp()
	106	{
	107	m_grid = new wxGrid(wxTheApp->GetTopWindow(), wxID_ANY);
	108	m_grid->CreateGrid(10, 2);
	109	m_grid->SetSize(400, 200);
	110
	111	if( ms_nativeheader )
	112	m_grid->UseNativeColHeader();
	113
	114	if( ms_nativelabels )
	115	m_grid->SetUseNativeColLabels();
	116
	117	m_grid->Refresh();
	118	m_grid->Update();
	119	}
	120
	121	void GridTestCase::tearDown()
	122	{
7c7bd972 VZ	123	// This is just a hack to continue the rest of the tests to run: if we
	124	// destroy the header control while it has capture, this results in an
	125	// assert failure and while handling an exception from it more bad things
	126	// happen (as it's thrown from a dtor), resulting in simply aborting
	127	// everything. So ensure that it doesn't have capture in any case.
	128	//
	129	// Of course, the right thing to do would be to understand why does it
	130	// still have capture when the grid is destroyed sometimes.
	131	wxWindow* const win = wxWindow::GetCapture();
	132	if ( win )
	133	win->ReleaseMouse();
	134
232fdc63 VZ	135	wxDELETE(m_grid);
	136	}
	137
	138	void GridTestCase::CellEdit()
	139	{
	140	#if wxUSE_UIACTIONSIMULATOR
744d91d4 SL	141	EventCounter changing(m_grid, wxEVT_GRID_CELL_CHANGING);
	142	EventCounter changed(m_grid, wxEVT_GRID_CELL_CHANGED);
	143	EventCounter created(m_grid, wxEVT_GRID_EDITOR_CREATED);
232fdc63 VZ	144
	145	wxUIActionSimulator sim;
	146
	147	m_grid->SetFocus();
	148	m_grid->SetGridCursor(1, 1);
	149	m_grid->ShowCellEditControl();
	150
	151	sim.Text("abab");
	152	sim.Char(WXK_RETURN);
	153
	154	wxYield();
	155
744d91d4 SL	156	CPPUNIT_ASSERT_EQUAL(1, created.GetCount());
	157	CPPUNIT_ASSERT_EQUAL(1, changing.GetCount());
	158	CPPUNIT_ASSERT_EQUAL(1, changed.GetCount());
232fdc63 VZ	159	#endif
	160	}
	161
	162	void GridTestCase::CellClick()
	163	{
	164	#if wxUSE_UIACTIONSIMULATOR
744d91d4 SL	165	EventCounter lclick(m_grid, wxEVT_GRID_CELL_LEFT_CLICK);
	166	EventCounter ldclick(m_grid, wxEVT_GRID_CELL_LEFT_DCLICK);
	167	EventCounter rclick(m_grid, wxEVT_GRID_CELL_RIGHT_CLICK);
	168	EventCounter rdclick(m_grid, wxEVT_GRID_CELL_RIGHT_DCLICK);
232fdc63 VZ	169
	170
	171	wxUIActionSimulator sim;
	172
	173	wxRect rect = m_grid->CellToRect(0, 0);
	174	wxPoint point = m_grid->CalcScrolledPosition(rect.GetPosition());
744d91d4 SL	175	point = m_grid->ClientToScreen(point + wxPoint(m_grid->GetRowLabelSize(),
	176	m_grid->GetColLabelSize())
	177	+ wxPoint(2, 2));
232fdc63 VZ	178
	179	sim.MouseMove(point);
	180	wxYield();
	181
	182	sim.MouseClick();
	183	wxYield();
	184
744d91d4 SL	185	CPPUNIT_ASSERT_EQUAL(1, lclick.GetCount());
744d91d4 SL	186	lclick.Clear();
232fdc63 VZ	187
	188	sim.MouseDblClick();
	189	wxYield();
	190
	191	//A double click event sends a single click event first
	192	//test to ensure this still happens in the future
744d91d4 SL	193	CPPUNIT_ASSERT_EQUAL(1, lclick.GetCount());
744d91d4 SL	194	CPPUNIT_ASSERT_EQUAL(1, ldclick.GetCount());
232fdc63 VZ	195
	196	sim.MouseClick(wxMOUSE_BTN_RIGHT);
	197	wxYield();
	198
744d91d4 SL	199	CPPUNIT_ASSERT_EQUAL(1, rclick.GetCount());
744d91d4 SL	200	rclick.Clear();
232fdc63 VZ	201
	202	sim.MouseDblClick(wxMOUSE_BTN_RIGHT);
	203	wxYield();
	204
744d91d4 SL	205	CPPUNIT_ASSERT_EQUAL(1, rclick.GetCount());
744d91d4 SL	206	CPPUNIT_ASSERT_EQUAL(1, rdclick.GetCount());
232fdc63 VZ	207	#endif
	208	}
	209
	210	void GridTestCase::CellSelect()
	211	{
	212	#if wxUSE_UIACTIONSIMULATOR
744d91d4	213	EventCounter cell(m_grid, wxEVT_GRID_SELECT_CELL);
232fdc63 VZ	214
	215	wxUIActionSimulator sim;
	216
	217	wxRect rect = m_grid->CellToRect(0, 0);
	218	wxPoint point = m_grid->CalcScrolledPosition(rect.GetPosition());
744d91d4 SL	219	point = m_grid->ClientToScreen(point + wxPoint(m_grid->GetRowLabelSize(),
	220	m_grid->GetColLabelSize())
	221	+ wxPoint(4, 4));
232fdc63 VZ	222
	223	sim.MouseMove(point);
	224	wxYield();
	225
	226	sim.MouseClick();
	227	wxYield();
	228
744d91d4 SL	229	CPPUNIT_ASSERT_EQUAL(1, cell.GetCount());
	230
	231	cell.Clear();
232fdc63 VZ	232
	233	m_grid->SetGridCursor(1, 1);
	234	m_grid->GoToCell(1, 0);
	235
	236	sim.MouseMove(point);
	237	wxYield();
	238
	239	sim.MouseDblClick();
	240	wxYield();
	241
744d91d4	242	CPPUNIT_ASSERT_EQUAL(3, cell.GetCount());
232fdc63 VZ	243	#endif
	244	}
	245
	246	void GridTestCase::LabelClick()
	247	{
da7ae357	248	#if wxUSE_UIACTIONSIMULATOR
744d91d4 SL	249	EventCounter lclick(m_grid, wxEVT_GRID_LABEL_LEFT_CLICK);
	250	EventCounter ldclick(m_grid, wxEVT_GRID_LABEL_LEFT_DCLICK);
	251	EventCounter rclick(m_grid, wxEVT_GRID_LABEL_RIGHT_CLICK);
	252	EventCounter rdclick(m_grid, wxEVT_GRID_LABEL_RIGHT_DCLICK);
232fdc63 VZ	253
	254	wxUIActionSimulator sim;
	255
	256	wxPoint pos(m_grid->GetRowLabelSize() + 2, 2);
	257	pos = m_grid->ClientToScreen(pos);
	258
	259	sim.MouseMove(pos);
	260	wxYield();
	261
	262	sim.MouseClick();
	263	wxYield();
	264
744d91d4	265	CPPUNIT_ASSERT_EQUAL(1, lclick.GetCount());
232fdc63 VZ	266
	267	sim.MouseDblClick();
	268	wxYield();
	269
744d91d4	270	CPPUNIT_ASSERT_EQUAL(1, ldclick.GetCount());
232fdc63 VZ	271
	272	sim.MouseClick(wxMOUSE_BTN_RIGHT);
	273	wxYield();
	274
744d91d4 SL	275	CPPUNIT_ASSERT_EQUAL(1, rclick.GetCount());
744d91d4 SL	276	rclick.Clear();
232fdc63 VZ	277
	278	sim.MouseDblClick(wxMOUSE_BTN_RIGHT);
	279	wxYield();
	280
	281	if( ms_nativeheader )
	282	{
	283	//Right double click not supported with native headers so we get two
	284	//right click events
744d91d4	285	CPPUNIT_ASSERT_EQUAL(2, rclick.GetCount());
232fdc63 VZ	286	}
	287	else
	288	{
744d91d4 SL	289	CPPUNIT_ASSERT_EQUAL(1, rclick.GetCount());
744d91d4 SL	290	CPPUNIT_ASSERT_EQUAL(1, rdclick.GetCount());
232fdc63 VZ	291	}
	292	#endif
	293	}
	294
	295	void GridTestCase::SortClick()
	296	{
da7ae357	297	#if wxUSE_UIACTIONSIMULATOR
232fdc63 VZ	298	m_grid->SetSortingColumn(0);
232fdc63 VZ	299
744d91d4	300	EventCounter sort(m_grid, wxEVT_GRID_COL_SORT);
232fdc63 VZ	301
	302	wxUIActionSimulator sim;
	303
	304	wxPoint pos(m_grid->GetRowLabelSize() + 4, 4);
	305	pos = m_grid->ClientToScreen(pos);
	306
	307	sim.MouseMove(pos);
	308	wxYield();
	309
	310	sim.MouseClick();
	311	wxYield();
	312
744d91d4	313	CPPUNIT_ASSERT_EQUAL(1, sort.GetCount());
232fdc63 VZ	314	#endif
	315	}
	316
	317	void GridTestCase::Size()
	318	{
	319	#if wxUSE_UIACTIONSIMULATOR && !defined(__WXGTK__)
744d91d4 SL	320	EventCounter colsize(m_grid, wxEVT_GRID_COL_SIZE);
744d91d4 SL	321	EventCounter rowsize(m_grid, wxEVT_GRID_ROW_SIZE);
232fdc63 VZ	322
	323	wxUIActionSimulator sim;
	324
	325	wxPoint pt = m_grid->ClientToScreen(wxPoint(m_grid->GetRowLabelSize() +
	326	m_grid->GetColSize(0), 5));
	327
	328	sim.MouseMove(pt);
	329	wxYield();
	330
	331	sim.MouseDown();
	332	wxYield();
	333
	334	sim.MouseMove(pt.x + 50, pt.y);
	335	wxYield();
	336
	337	sim.MouseUp();
	338	wxYield();
	339
744d91d4	340	CPPUNIT_ASSERT_EQUAL(1, colsize.GetCount());
232fdc63 VZ	341
	342	pt = m_grid->ClientToScreen(wxPoint(5, m_grid->GetColLabelSize() +
	343	m_grid->GetRowSize(0)));
	344
	345	sim.MouseDragDrop(pt.x, pt.y, pt.x, pt.y + 50);
	346	wxYield();
	347
744d91d4	348	CPPUNIT_ASSERT_EQUAL(1, rowsize.GetCount());
232fdc63 VZ	349	#endif
	350	}
	351
	352	void GridTestCase::RangeSelect()
	353	{
	354	#if wxUSE_UIACTIONSIMULATOR
744d91d4	355	EventCounter select(m_grid, wxEVT_GRID_RANGE_SELECT);
232fdc63 VZ	356
	357	wxUIActionSimulator sim;
	358
	359	//We add the extra 10 to ensure that we are inside the cell
	360	wxPoint pt = m_grid->ClientToScreen(wxPoint(m_grid->GetRowLabelSize() + 10,
	361	m_grid->GetColLabelSize() + 10)
	362	);
	363
	364	sim.MouseMove(pt);
	365	wxYield();
	366
	367	sim.MouseDown();
	368	wxYield();
	369
	370	sim.MouseMove(pt.x + 50, pt.y + 50);
	371	wxYield();
	372
	373	sim.MouseUp();
	374	wxYield();
	375
744d91d4	376	CPPUNIT_ASSERT_EQUAL(1, select.GetCount());
232fdc63 VZ	377	#endif
	378	}
	379
	380	void GridTestCase::Cursor()
	381	{
	382	m_grid->SetGridCursor(1, 1);
	383
	384	CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorCol());
	385	CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorRow());
	386
	387	m_grid->MoveCursorDown(false);
	388	m_grid->MoveCursorLeft(false);
	389	m_grid->MoveCursorUp(false);
	390	m_grid->MoveCursorUp(false);
	391	m_grid->MoveCursorRight(false);
	392
	393	CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorCol());
	394	CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorRow());
	395
	396	m_grid->SetCellValue(0, 0, "some text");
	397	m_grid->SetCellValue(3, 0, "other text");
	398	m_grid->SetCellValue(0, 1, "more text");
	399	m_grid->SetCellValue(3, 1, "extra text");
	400
	401	m_grid->Update();
	402	m_grid->Refresh();
	403
	404	m_grid->MoveCursorLeftBlock(false);
	405
	406	CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorCol());
	407	CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorRow());
	408
	409	m_grid->MoveCursorDownBlock(false);
	410
	411	CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorCol());
	412	CPPUNIT_ASSERT_EQUAL(3, m_grid->GetGridCursorRow());
	413
	414	m_grid->MoveCursorRightBlock(false);
	415
	416	CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorCol());
	417	CPPUNIT_ASSERT_EQUAL(3, m_grid->GetGridCursorRow());
	418
	419	m_grid->MoveCursorUpBlock(false);
	420
	421	CPPUNIT_ASSERT_EQUAL(1, m_grid->GetGridCursorCol());
	422	CPPUNIT_ASSERT_EQUAL(0, m_grid->GetGridCursorRow());
	423	}
	424
	425	void GridTestCase::Selection()
	426	{
	427	m_grid->SelectAll();
	428
	429	CPPUNIT_ASSERT(m_grid->IsSelection());
	430	CPPUNIT_ASSERT(m_grid->IsInSelection(0, 0));
	431	CPPUNIT_ASSERT(m_grid->IsInSelection(9, 1));
	432
	433	m_grid->SelectBlock(1, 0, 3, 1);
	434
	435	wxGridCellCoordsArray topleft = m_grid->GetSelectionBlockTopLeft();
	436	wxGridCellCoordsArray bottomright = m_grid->GetSelectionBlockBottomRight();
	437
	438	CPPUNIT_ASSERT_EQUAL(1, topleft.Count());
	439	CPPUNIT_ASSERT_EQUAL(1, bottomright.Count());
	440
441	CPPUNIT_ASSERT_EQUAL(0, topleft.Item(0).GetCol());
442	CPPUNIT_ASSERT_EQUAL(1, topleft.Item(0).GetRow());
443	CPPUNIT_ASSERT_EQUAL(1, bottomright.Item(0).GetCol());
444	CPPUNIT_ASSERT_EQUAL(3, bottomright.Item(0).GetRow());
445
446	m_grid->SelectCol(1);
447
448	CPPUNIT_ASSERT(m_grid->IsInSelection(0, 1));
449	CPPUNIT_ASSERT(m_grid->IsInSelection(9, 1));
450	CPPUNIT_ASSERT(!m_grid->IsInSelection(3, 0));
451
452	m_grid->SelectRow(4);
453
454	CPPUNIT_ASSERT(m_grid->IsInSelection(4, 0));
455	CPPUNIT_ASSERT(m_grid->IsInSelection(4, 1));
456	CPPUNIT_ASSERT(!m_grid->IsInSelection(3, 0));
457	}
458
459	void GridTestCase::AddRowCol()
460	{
461	CPPUNIT_ASSERT_EQUAL(10, m_grid->GetNumberRows());
462	CPPUNIT_ASSERT_EQUAL(2, m_grid->GetNumberCols());
463
464	m_grid->AppendCols();
465	m_grid->AppendRows();
466
467	CPPUNIT_ASSERT_EQUAL(11, m_grid->GetNumberRows());
468	CPPUNIT_ASSERT_EQUAL(3, m_grid->GetNumberCols());
469
470	m_grid->AppendCols(2);
471	m_grid->AppendRows(2);
472
473	CPPUNIT_ASSERT_EQUAL(13, m_grid->GetNumberRows());
474	CPPUNIT_ASSERT_EQUAL(5, m_grid->GetNumberCols());
475
476	m_grid->InsertCols(1, 2);
477	m_grid->InsertRows(2, 3);
478
479	CPPUNIT_ASSERT_EQUAL(16, m_grid->GetNumberRows());
480	CPPUNIT_ASSERT_EQUAL(7, m_grid->GetNumberCols());
481	}
482
483	void GridTestCase::ColumnOrder()
484	{
485	m_grid->AppendCols(2);
486
487	CPPUNIT_ASSERT_EQUAL(4, m_grid->GetNumberCols());
488
489	wxArrayInt neworder;
490	neworder.push_back(1);
491	neworder.push_back(3);
492	neworder.push_back(2);
493	neworder.push_back(0);
494
495	m_grid->SetColumnsOrder(neworder);
496
497	CPPUNIT_ASSERT_EQUAL(0, m_grid->GetColPos(1));
498	CPPUNIT_ASSERT_EQUAL(1, m_grid->GetColPos(3));
499	CPPUNIT_ASSERT_EQUAL(2, m_grid->GetColPos(2));
500	CPPUNIT_ASSERT_EQUAL(3, m_grid->GetColPos(0));
501
502	CPPUNIT_ASSERT_EQUAL(1, m_grid->GetColAt(0));
503	CPPUNIT_ASSERT_EQUAL(3, m_grid->GetColAt(1));
504	CPPUNIT_ASSERT_EQUAL(2, m_grid->GetColAt(2));
505	CPPUNIT_ASSERT_EQUAL(0, m_grid->GetColAt(3));
506
507	m_grid->ResetColPos();
508
509	CPPUNIT_ASSERT_EQUAL(0, m_grid->GetColPos(0));
510	CPPUNIT_ASSERT_EQUAL(1, m_grid->GetColPos(1));
511	CPPUNIT_ASSERT_EQUAL(2, m_grid->GetColPos(2));
512	CPPUNIT_ASSERT_EQUAL(3, m_grid->GetColPos(3));
513	}
514
515	void GridTestCase::LineFormatting()
516	{
517	CPPUNIT_ASSERT(m_grid->GridLinesEnabled());
518
519	m_grid->EnableGridLines(false);
520
521	CPPUNIT_ASSERT(!m_grid->GridLinesEnabled());
522
523	m_grid->EnableGridLines();
524
525	m_grid->SetGridLineColour(*wxRED);
526
527	CPPUNIT_ASSERT_EQUAL(m_grid->GetGridLineColour(), *wxRED);
528	}
529
530	void GridTestCase::SortSupport()
531	{
532	CPPUNIT_ASSERT_EQUAL(wxNOT_FOUND, m_grid->GetSortingColumn());
533
534	m_grid->SetSortingColumn(1);
535
536	CPPUNIT_ASSERT(!m_grid->IsSortingBy(0));
537	CPPUNIT_ASSERT(m_grid->IsSortingBy(1));
538	CPPUNIT_ASSERT(m_grid->IsSortOrderAscending());
539
540	m_grid->SetSortingColumn(0, false);
541
542	CPPUNIT_ASSERT(m_grid->IsSortingBy(0));
543	CPPUNIT_ASSERT(!m_grid->IsSortingBy(1));
544	CPPUNIT_ASSERT(!m_grid->IsSortOrderAscending());
545
546	m_grid->UnsetSortingColumn();
547
548	CPPUNIT_ASSERT(!m_grid->IsSortingBy(0));
549	CPPUNIT_ASSERT(!m_grid->IsSortingBy(1));
550	}
551
552	void GridTestCase::Labels()
553	{
554	CPPUNIT_ASSERT_EQUAL("A", m_grid->GetColLabelValue(0));
555	CPPUNIT_ASSERT_EQUAL("1", m_grid->GetRowLabelValue(0));
556
557	m_grid->SetColLabelValue(0, "Column 1");
558	m_grid->SetRowLabelValue(0, "Row 1");
559
560	CPPUNIT_ASSERT_EQUAL("Column 1", m_grid->GetColLabelValue(0));
561	CPPUNIT_ASSERT_EQUAL("Row 1", m_grid->GetRowLabelValue(0));
562
563	m_grid->SetLabelTextColour(*wxGREEN);
564	m_grid->SetLabelBackgroundColour(*wxRED);
565
566	CPPUNIT_ASSERT_EQUAL(*wxGREEN, m_grid->GetLabelTextColour());
567	CPPUNIT_ASSERT_EQUAL(*wxRED, m_grid->GetLabelBackgroundColour());
568
569	m_grid->SetColLabelTextOrientation(wxVERTICAL);
570
571	CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxVERTICAL),
572	static_cast<int>(m_grid->GetColLabelTextOrientation()));
573	}
574
575	void GridTestCase::SelectionMode()
576	{
577	//We already test this mode in Select
578	CPPUNIT_ASSERT_EQUAL(wxGrid::wxGridSelectCells,
579	m_grid->GetSelectionMode());
580
581	//Test row selection be selecting a single cell and checking the whole
582	//row is selected
583	m_grid->SetSelectionMode(wxGrid::wxGridSelectRows);
584	m_grid->SelectBlock(3, 1, 3, 1);
585
e4aadc2f VZ	586	wxArrayInt selectedRows = m_grid->GetSelectedRows();
	587	CPPUNIT_ASSERT_EQUAL(1, selectedRows.Count());
	588	CPPUNIT_ASSERT_EQUAL(3, selectedRows[0]);
232fdc63 VZ	589
	590	CPPUNIT_ASSERT_EQUAL(wxGrid::wxGridSelectRows,
	591	m_grid->GetSelectionMode());
	592
	593
	594	//Test column selection be selecting a single cell and checking the whole
	595	//column is selected
	596	m_grid->SetSelectionMode(wxGrid::wxGridSelectColumns);
	597	m_grid->SelectBlock(3, 1, 3, 1);
	598
e4aadc2f VZ	599	wxArrayInt selectedCols = m_grid->GetSelectedCols();
	600	CPPUNIT_ASSERT_EQUAL(1, selectedCols.Count());
	601	CPPUNIT_ASSERT_EQUAL(1, selectedCols[0]);
232fdc63 VZ	602
	603	CPPUNIT_ASSERT_EQUAL(wxGrid::wxGridSelectColumns,
	604	m_grid->GetSelectionMode());
	605	}
	606
	607	void GridTestCase::CellFormatting()
	608	{
	609	//Check that initial alignment is default
	610	int horiz, cellhoriz, vert, cellvert;
	611
	612	m_grid->GetDefaultCellAlignment(&horiz, &vert);
	613	m_grid->GetCellAlignment(0, 0, &cellhoriz, &cellvert);
	614
	615	CPPUNIT_ASSERT_EQUAL(cellhoriz, horiz);
	616	CPPUNIT_ASSERT_EQUAL(cellvert, vert);
	617
	618	//Check initial text colour and background colour are default
	619	wxColour text, back;
	620
	621	back = m_grid->GetDefaultCellBackgroundColour();
	622
	623	CPPUNIT_ASSERT_EQUAL(back, m_grid->GetCellBackgroundColour(0, 0));
	624
	625	back = m_grid->GetDefaultCellTextColour();
	626
	627	CPPUNIT_ASSERT_EQUAL(back, m_grid->GetCellTextColour(0, 0));
	628
4a04898f VZ	629	#if WXWIN_COMPATIBILITY_2_8
4a04898f VZ	630	m_grid->SetCellAlignment(wxALIGN_CENTRE, 0, 0);
232fdc63 VZ	631	m_grid->GetCellAlignment(0, 0, &cellhoriz, &cellvert);
	632
	633	CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxALIGN_CENTRE), cellhoriz);
	634	CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxALIGN_CENTRE), cellvert);
4a04898f	635	#endif // WXWIN_COMPATIBILITY_2_8
232fdc63 VZ	636
	637	m_grid->SetCellAlignment(0, 0, wxALIGN_LEFT, wxALIGN_BOTTOM);
	638	m_grid->GetCellAlignment(0, 0, &cellhoriz, &cellvert);
	639
	640	CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxALIGN_LEFT), cellhoriz);
	641	CPPUNIT_ASSERT_EQUAL(static_cast<int>(wxALIGN_BOTTOM), cellvert);
	642
4a04898f VZ	643	#if WXWIN_COMPATIBILITY_2_8
4a04898f VZ	644	m_grid->SetCellTextColour(*wxRED, 0, 0);
232fdc63	645	CPPUNIT_ASSERT_EQUAL(*wxRED, m_grid->GetCellTextColour(0, 0));
4a04898f	646	#endif // WXWIN_COMPATIBILITY_2_8
232fdc63 VZ	647
232fdc63 VZ	648	m_grid->SetCellTextColour(0, 0, *wxGREEN);
232fdc63 VZ	649	CPPUNIT_ASSERT_EQUAL(*wxGREEN, m_grid->GetCellTextColour(0, 0));
	650	}
	651
	652	void GridTestCase::Editable()
	653	{
	654	#if wxUSE_UIACTIONSIMULATOR
232fdc63	655	//As the grid is not editable we shouldn't create an editor
744d91d4	656	EventCounter created(m_grid, wxEVT_GRID_EDITOR_CREATED);
232fdc63 VZ	657
	658	wxUIActionSimulator sim;
	659
	660	CPPUNIT_ASSERT(m_grid->IsEditable());
	661
	662	m_grid->EnableEditing(false);
	663
	664	CPPUNIT_ASSERT(!m_grid->IsEditable());
	665
	666	m_grid->SetFocus();
	667	m_grid->SetGridCursor(1, 1);
	668	m_grid->ShowCellEditControl();
	669
	670	sim.Text("abab");
	671	wxYield();
	672
	673	sim.Char(WXK_RETURN);
	674	wxYield();
	675
744d91d4	676	CPPUNIT_ASSERT_EQUAL(0, created.GetCount());
232fdc63 VZ	677	#endif
	678	}
	679
	680	void GridTestCase::ReadOnly()
	681	{
	682	#if wxUSE_UIACTIONSIMULATOR
232fdc63	683	//As the cell is readonly we shouldn't create an editor
744d91d4	684	EventCounter created(m_grid, wxEVT_GRID_EDITOR_CREATED);
232fdc63 VZ	685
	686	wxUIActionSimulator sim;
	687
	688	CPPUNIT_ASSERT(!m_grid->IsReadOnly(1, 1));
	689
	690	m_grid->SetReadOnly(1, 1);
	691
	692	CPPUNIT_ASSERT(m_grid->IsReadOnly(1, 1));
	693
	694	m_grid->SetFocus();
	695	m_grid->SetGridCursor(1, 1);
	696
	697	CPPUNIT_ASSERT(m_grid->IsCurrentCellReadOnly());
	698
	699	m_grid->ShowCellEditControl();
	700
	701	sim.Text("abab");
	702	wxYield();
	703
	704	sim.Char(WXK_RETURN);
	705	wxYield();
	706
744d91d4	707	CPPUNIT_ASSERT_EQUAL(0, created.GetCount());
232fdc63 VZ	708	#endif
	709	}
	710
	711	#endif //wxUSE_GRID