[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"

// FIXME: A lot of mouse-related tests sporadically fail in wxGTK. This happens
//        almost all the time but sometimes the tests do pass and the failure
//        doesn't happen when debugging so this looks like some kind of event
//        dispatching/simulating problem rather than a real problem in wxGrid.
//
//        Just disable these tests for now but it would be really great to
//        really fix the problem.
#ifdef __WXGTK__
    #define NONGTK_TEST(test)
#else
    #define NONGTK_TEST(test) WXUISIM_TEST(test)
#endif


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

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

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