diff --git a/include/wx/generic/grid.h b/include/wx/generic/grid.h index dc563ad0c1..f90fff3954 100644 --- a/include/wx/generic/grid.h +++ b/include/wx/generic/grid.h @@ -747,10 +747,133 @@ private: }; +// ---------------------------------------------------------------------------- +// wxGridBlockCoords: location of a block of cells in the grid +// ---------------------------------------------------------------------------- + +struct wxGridBlockDiffResult; + +class WXDLLIMPEXP_CORE wxGridBlockCoords +{ +public: + wxGridBlockCoords() : + m_topRow(-1), + m_leftCol(-1), + m_bottomRow(-1), + m_rightCol(-1) + { + } + + wxGridBlockCoords(int topRow, int leftCol, int bottomRow, int rightCol) : + m_topRow(topRow), + m_leftCol(leftCol), + m_bottomRow(bottomRow), + m_rightCol(rightCol) + { + } + + // default copy ctor is ok + + int GetTopRow() const { return m_topRow; } + void SetTopRow(int row) { m_topRow = row; } + int GetLeftCol() const { return m_leftCol; } + void SetLeftCol(int col) { m_leftCol = col; } + int GetBottomRow() const { return m_bottomRow; } + void SetBottomRow(int row) { m_bottomRow = row; } + int GetRightCol() const { return m_rightCol; } + void SetRightCol(int col) { m_rightCol = col; } + + wxGridCellCoords GetTopLeft() const + { + return wxGridCellCoords(m_topRow, m_leftCol); + } + + wxGridCellCoords GetBottomRight() const + { + return wxGridCellCoords(m_bottomRow, m_rightCol); + } + + wxGridBlockCoords Canonicalize() const + { + wxGridBlockCoords result = *this; + + if ( result.m_topRow > result.m_bottomRow ) + wxSwap(result.m_topRow, result.m_bottomRow); + + if ( result.m_leftCol > result.m_rightCol ) + wxSwap(result.m_leftCol, result.m_rightCol); + + return result; + } + + bool Intersects(const wxGridBlockCoords& other) const + { + return m_topRow <= other.m_bottomRow && m_bottomRow >= other.m_topRow && + m_leftCol <= other.m_rightCol && m_rightCol >= other.m_leftCol; + } + + // Whether the block contains the cell. + // returns @true, if the block contains the cell, + // @false, otherwise + bool ContainCell(const wxGridCellCoords& cell) const; + + // Whether the blocks contain each other. + // returns 1, if this block contains the other, + // -1, if the other block contains this one, + // 0, otherwise + int ContainBlock(const wxGridBlockCoords& other) const; + + // Calculates the result blocks by subtracting the other block from this + // block. splitOrientation can be wxVERTICAL or wxHORIZONTAL. + wxGridBlockDiffResult + Difference(const wxGridBlockCoords& other, int splitOrientation) const; + + // Calculates the symmetric difference of the blocks. + wxGridBlockDiffResult + SymDifference(const wxGridBlockCoords& other) const; + + bool operator==(const wxGridBlockCoords& other) const + { + return m_topRow == other.m_topRow && m_leftCol == other.m_leftCol && + m_bottomRow == other.m_bottomRow && m_rightCol == other.m_rightCol; + } + + bool operator!=(const wxGridBlockCoords& other) const + { + return !(*this == other); + } + + bool operator!() const + { + return m_topRow == -1 && m_leftCol == -1 && + m_bottomRow == -1 && m_rightCol == -1; + } + +private: + int m_topRow; + int m_leftCol; + int m_bottomRow; + int m_rightCol; +}; + +// ---------------------------------------------------------------------------- +// wxGridBlockDiffResult: The helper struct uses as a result type for difference +// functions of wxGridBlockCoords class. +// Parts can be uninitialized (equals to wxGridNoBlockCoords), that means +// that the corresponding part doesn't exists in the result. +// ---------------------------------------------------------------------------- + +struct wxGridBlockDiffResult +{ + wxGridBlockCoords m_parts[4]; +}; + + // For comparisons... // -extern WXDLLIMPEXP_CORE wxGridCellCoords wxGridNoCellCoords; -extern WXDLLIMPEXP_CORE wxRect wxGridNoCellRect; +extern WXDLLIMPEXP_CORE wxGridCellCoords wxGridNoCellCoords; +extern WXDLLIMPEXP_CORE wxGridBlockCoords wxGridNoBlockCoords; +extern WXDLLIMPEXP_CORE wxRect wxGridNoCellRect; // An array of cell coords... // diff --git a/interface/wx/grid.h b/interface/wx/grid.h index dfbdb73740..1bbad92e42 100644 --- a/interface/wx/grid.h +++ b/interface/wx/grid.h @@ -1816,6 +1816,195 @@ public: bool operator!() const; }; +/** + Represents coordinates of a block of cells in the grid. + + An object of this class contains coordinates of the left top and the bottom right + corners of a block. + + @since 3.1.4 + */ +class wxGridBlockCoords +{ +public: + /** + Default constructor initializes the object to invalid state. + + Initially the coordinates are invalid (-1) and so operator!() for an + uninitialized wxGridBlockCoords returns @true. + */ + wxGridBlockCoords(); + + /** + Constructor taking a coordinates of the left top and the bottom right + corners. + */ + wxGridBlockCoords(int topRow, int leftCol, int bottomRow, int rightCol); + + /** + Return the row of the left top corner. + */ + int GetTopRow() const; + + /** + Set the row of the left top corner. + */ + void SetTopRow(int row); + + /** + Return the column of the left top corner. + */ + int GetLeftCol() const; + + /** + Set the column of the left top corner. + */ + void SetLeftCol(int col); + + /** + Return the row of the bottom right corner. + */ + int GetBottomRow() const; + + /** + Set the row of the bottom right corner. + */ + void SetBottomRow(int row); + + /** + Return the column of the bottom right corner. + */ + int GetRightCol() const; + + /** + Set the column of the bottom right corner. + */ + void SetRightCol(int col); + + /** + Return the coordinates of the top left corner. + */ + wxGridCellCoords GetTopLeft() const + { + return wxGridCellCoords(m_topRow, m_leftCol); + } + + /** + Return the coordinates of the bottom right corner. + */ + wxGridCellCoords GetBottomRight() const + { + return wxGridCellCoords(m_bottomRow, m_rightCol); + } + + /** + Return the canonicalized block where top left coordinates is less + then bottom right coordinates. + */ + wxGridBlockCoords Canonicalize() const; + + /** + Whether the blocks intersects. + + @return + @true, if the block intersects with the other, @false, otherwise. + */ + bool Intersects(const wxGridBlockCoords& other) const + { + return m_topRow <= other.m_bottomRow && m_bottomRow >= other.m_topRow && + m_leftCol <= other.m_rightCol && m_rightCol >= other.m_leftCol; + } + + /** + Whether the block contains the cell. + + @return + @true, if the block contains the cell, @false, otherwise. + */ + bool ContainCell(const wxGridCellCoords& cell) const; + + /** + Whether the blocks contain each other. + + @return + 1, if this block contains the other, + -1, if the other block contains this one, + 0, otherwise. + */ + int ContainBlock(const wxGridBlockCoords& other) const; + + /** + Calculates the result blocks by subtracting the other block from this + block. + + @param other + The block to subtract from this block. + @param splitOrientation + The block splitting orientation (either @c wxHORIZONTAL or + @c wxVERTICAL). + @return + Up to 4 blocks. If block doesn't exist in the result, it has value + of @c wxGridNoBlockCoords. + */ + wxGridBlockDiffResult + Difference(const wxGridBlockCoords& other, int splitOrientation) const; + + /** + Calculates the symmetric difference of the blocks. + + @param other + The block to subtract from this block. + @return + Up to 4 blocks. If block doesn't exist in the result, it has value + of @c wxGridNoBlockCoords. + */ + wxGridBlockDiffResult + SymDifference(const wxGridBlockCoords& other) const; + + /** + Equality operator. + */ + bool operator==(const wxGridBlockCoords& other) const; + + /** + Inequality operator. + */ + bool operator!=(const wxGridBlockCoords& other) const; + + /** + Checks whether the cells block is invalid. + + Returns @true only if all components are -1. Notice that if one + of the components (but not all) is -1, this method returns @false even + if the object is invalid. This is done because objects in such state + should actually never exist, i.e. either all components should be -1 + or none of them should be -1. + */ + bool operator!() const; + +private: + int m_topRow; + int m_leftCol; + int m_bottomRow; + int m_rightCol; +}; + +/** + @class wxGridBlockDiffResult + + The helper struct uses as a result type for difference functions of + @c wxGridBlockCoords class. + + Parts can be uninitialized (equals to @c wxGridNoBlockCoords), that means + that the corresponding part doesn't exists in the result. + + @since 3.1.4 + */ +struct wxGridBlockDiffResult +{ + wxGridBlockCoords m_parts[4]; +}; + /** @class wxGridTableBase diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp index e5ecf32eee..1fed7a841d 100644 --- a/src/generic/grid.cpp +++ b/src/generic/grid.cpp @@ -94,6 +94,7 @@ struct DefaultHeaderRenderers // ---------------------------------------------------------------------------- wxGridCellCoords wxGridNoCellCoords( -1, -1 ); +wxGridBlockCoords wxGridNoBlockCoords( -1, -1, -1, -1 ); wxRect wxGridNoCellRect( -1, -1, -1, -1 ); namespace @@ -1152,6 +1153,226 @@ const wxGridCornerHeaderRenderer& wxGridCellAttrProvider::GetCornerRenderer() return gs_defaultHeaderRenderers.cornerRenderer; } +// ---------------------------------------------------------------------------- +// wxGridBlockCoords +// ---------------------------------------------------------------------------- + +bool wxGridBlockCoords::ContainCell(const wxGridCellCoords& cell) const +{ + return m_topRow <= cell.GetRow() && cell.GetRow() <= m_bottomRow && + m_leftCol <= cell.GetCol() && cell.GetCol() <= m_rightCol; +} + +int wxGridBlockCoords::ContainBlock(const wxGridBlockCoords& other) const +{ +// returns 1, if this block contains the other, +// -1, if the other block contains this one, +// 0, otherwise + if ( m_topRow <= other.m_topRow && other.m_bottomRow <= m_bottomRow && + m_leftCol <= other.m_leftCol && other.m_rightCol <= m_rightCol ) + return 1; + else if ( other.m_topRow <= m_topRow && m_bottomRow <= other.m_bottomRow && + other.m_leftCol <= m_leftCol && m_rightCol <= other.m_rightCol ) + return -1; + + return 0; +} + +wxGridBlockDiffResult +wxGridBlockCoords::Difference(const wxGridBlockCoords& other, + int splitOrientation) const +{ + wxGridBlockDiffResult result; + + // Check whether the blocks intersect. + if (!Intersects(other)) + { + result.m_parts[0] = *this; + return result; + } + + // Split the block in up to 4 new parts, that don't contain the other + // block, like this (for wxHORIZONTAL): + // |-----------------------------| + // | | + // | part[0] | + // | | + // |-----------------------------| + // | part[2] | other | part[3] | + // |-----------------------------| + // | | + // | part[1] | + // | | + // |-----------------------------| + // And for wxVERTICAL: + // |-----------------------------| + // | | | | + // | | part[2] | | + // | | | | + // | |---------| | + // | part[0] | other | part[1] | + // | |---------| | + // | | | | + // | | part[3] | | + // | | | | + // |-----------------------------| + + if ( splitOrientation == wxHORIZONTAL ) + { + // Part[0]. + if ( m_topRow < other.m_topRow ) + result.m_parts[0] = + wxGridBlockCoords(m_topRow, m_leftCol, + other.m_topRow - 1, m_rightCol); + + // Part[1]. + if ( m_bottomRow > other.m_bottomRow ) + result.m_parts[1] = + wxGridBlockCoords(other.m_bottomRow + 1, m_leftCol, + m_bottomRow, m_rightCol); + + const int maxTopRow = wxMax(m_topRow, other.m_topRow); + const int minBottomRow = wxMin(m_bottomRow, other.m_bottomRow); + + // Part[2]. + if ( m_leftCol < other.m_leftCol ) + result.m_parts[2] = + wxGridBlockCoords(maxTopRow, m_leftCol, + minBottomRow, other.m_leftCol - 1); + + // Part[3]. + if ( m_rightCol > other.m_rightCol ) + result.m_parts[3] = + wxGridBlockCoords(maxTopRow, other.m_rightCol + 1, + minBottomRow, m_rightCol); + } + else // wxVERTICAL + { + // Part[0]. + if ( m_leftCol < other.m_leftCol ) + result.m_parts[0] = + wxGridBlockCoords(m_topRow, m_leftCol, + m_bottomRow, other.m_leftCol - 1); + + // Part[1]. + if ( m_rightCol > other.m_rightCol ) + result.m_parts[1] = + wxGridBlockCoords(m_topRow, other.m_rightCol + 1, + m_bottomRow, m_rightCol); + + const int maxLeftCol = wxMax(m_leftCol, other.m_leftCol); + const int minRightCol = wxMin(m_rightCol, other.m_rightCol); + + // Part[2]. + if ( m_topRow < other.m_topRow ) + result.m_parts[2] = + wxGridBlockCoords(m_topRow, maxLeftCol, + other.m_topRow - 1, minRightCol); + + // Part[3]. + if ( m_bottomRow > other.m_bottomRow ) + result.m_parts[3] = + wxGridBlockCoords(other.m_bottomRow + 1, maxLeftCol, + m_bottomRow, minRightCol); + } + + return result; +} + +wxGridBlockDiffResult +wxGridBlockCoords::SymDifference(const wxGridBlockCoords& other) const +{ + wxGridBlockDiffResult result; + + // Check whether the blocks intersect. + if ( !Intersects(other) ) + { + result.m_parts[0] = *this; + result.m_parts[1] = other; + return result; + } + + // Possible result blocks: + // |------------------| + // | | minUpper->m_topRow + // | part[0] | + // | | maxUpper->m_topRow - 1 + // |-----------------------------| + // | | | | maxUpper->m_topRow + // | part[2] | x | part[3] | + // | | | | minLower->m_bottomRow + // |-----------------------------| + // | | minLower->m_bottomRow + 1 + // | part[1] | + // | | maxLower->m_bottomRow + // |-------------------| + // + // The x marks the intersection of the blocks, which is not a part + // of the result. + + // Part[0]. + int maxUpperRow; + if ( m_topRow != other.m_topRow ) + { + const bool block1Min = m_topRow < other.m_topRow; + const wxGridBlockCoords& minUpper = block1Min ? *this : other; + const wxGridBlockCoords& maxUpper = block1Min ? other : *this; + maxUpperRow = maxUpper.m_topRow; + + result.m_parts[0] = wxGridBlockCoords(minUpper.m_topRow, + minUpper.m_leftCol, + maxUpper.m_topRow - 1, + minUpper.m_rightCol); + } + else + { + maxUpperRow = m_topRow; + } + + // Part[1]. + int minLowerRow; + if ( m_bottomRow != other.m_bottomRow ) + { + const bool block1Min = m_bottomRow < other.m_bottomRow; + const wxGridBlockCoords& minLower = block1Min ? *this : other; + const wxGridBlockCoords& maxLower = block1Min ? other : *this; + minLowerRow = minLower.m_bottomRow; + + result.m_parts[1] = wxGridBlockCoords(minLower.m_bottomRow + 1, + maxLower.m_leftCol, + maxLower.m_bottomRow, + maxLower.m_rightCol); + } + else + { + minLowerRow = m_bottomRow; + } + + // Part[2]. + if ( m_leftCol != other.m_leftCol ) + { + result.m_parts[2] = wxGridBlockCoords(maxUpperRow, + wxMin(m_leftCol, + other.m_leftCol), + minLowerRow, + wxMax(m_leftCol, + other.m_leftCol) - 1); + } + + // Part[3]. + if ( m_rightCol != other.m_rightCol ) + { + result.m_parts[3] = wxGridBlockCoords(maxUpperRow, + wxMin(m_rightCol, + other.m_rightCol) + 1, + minLowerRow, + wxMax(m_rightCol, + other.m_rightCol)); + } + + return result; +} + // ---------------------------------------------------------------------------- // wxGridTableBase // ---------------------------------------------------------------------------- diff --git a/tests/controls/gridtest.cpp b/tests/controls/gridtest.cpp index 23de3046a5..a562eaafde 100644 --- a/tests/controls/gridtest.cpp +++ b/tests/controls/gridtest.cpp @@ -1259,4 +1259,191 @@ TEST_CASE_METHOD(GridTestCase, "Grid::AutoSizeColumn", "[grid]") } } +// Test wxGridBlockCoords here because it'a a part of grid sources. + +std::ostream& operator<<(std::ostream& os, const wxGridBlockCoords& block) { + os << "wxGridBlockCoords(" << + block.GetTopRow() << ", " << block.GetLeftCol() << ", " << + block.GetBottomRow() << ", " << block.GetRightCol() << ")"; + return os; +} + +TEST_CASE("GridBlockCoords::Canonicalize", "[grid]") +{ + const wxGridBlockCoords block = + wxGridBlockCoords(4, 3, 2, 1).Canonicalize(); + + CHECK(block.GetTopRow() == 2); + CHECK(block.GetLeftCol() == 1); + CHECK(block.GetBottomRow() == 4); + CHECK(block.GetRightCol() == 3); +} + +TEST_CASE("GridBlockCoords::Intersects", "[grid]") +{ + // Inside. + CHECK(wxGridBlockCoords(1, 1, 3, 3).Intersects(wxGridBlockCoords(1, 2, 2, 3))); + + // Intersects. + CHECK(wxGridBlockCoords(1, 1, 3, 3).Intersects(wxGridBlockCoords(2, 2, 4, 4))); + + // Doesn't intersects. + CHECK(!wxGridBlockCoords(1, 1, 3, 3).Intersects(wxGridBlockCoords(4, 4, 6, 6))); +} + +TEST_CASE("GridBlockCoords::ContainCell", "[grid]") +{ + // Inside. + CHECK(wxGridBlockCoords(1, 1, 3, 3).ContainCell(wxGridCellCoords(2, 2))); + + // Outside. + CHECK(!wxGridBlockCoords(1, 1, 3, 3).ContainCell(wxGridCellCoords(5, 5))); +} + +TEST_CASE("GridBlockCoords::ContainBlock", "[grid]") +{ + wxGridBlockCoords block1(1, 1, 5, 5); + wxGridBlockCoords block2(1, 1, 3, 3); + wxGridBlockCoords block3(2, 2, 7, 7); + wxGridBlockCoords block4(10, 10, 12, 12); + + CHECK(block1.ContainBlock(block2) == 1); + CHECK(block2.ContainBlock(block1) == -1); + CHECK(block1.ContainBlock(block3) == 0); + CHECK(block1.ContainBlock(block4) == 0); +} + +TEST_CASE("GridBlockCoords::Difference", "[grid]") +{ + SECTION("Subtract contained block (splitted horizontally)") + { + const wxGridBlockCoords block1(1, 1, 7, 7); + const wxGridBlockCoords block2(3, 3, 5, 5); + const wxGridBlockDiffResult result = + block1.Difference(block2, wxHORIZONTAL); + + CHECK(result.m_parts[0] == wxGridBlockCoords(1, 1, 2, 7)); + CHECK(result.m_parts[1] == wxGridBlockCoords(6, 1, 7, 7)); + CHECK(result.m_parts[2] == wxGridBlockCoords(3, 1, 5, 2)); + CHECK(result.m_parts[3] == wxGridBlockCoords(3, 6, 5, 7)); + } + + SECTION("Subtract contained block (splitted vertically)") + { + const wxGridBlockCoords block1(1, 1, 7, 7); + const wxGridBlockCoords block2(3, 3, 5, 5); + const wxGridBlockDiffResult result = + block1.Difference(block2, wxVERTICAL); + + CHECK(result.m_parts[0] == wxGridBlockCoords(1, 1, 7, 2)); + CHECK(result.m_parts[1] == wxGridBlockCoords(1, 6, 7, 7)); + CHECK(result.m_parts[2] == wxGridBlockCoords(1, 3, 2, 5)); + CHECK(result.m_parts[3] == wxGridBlockCoords(6, 3, 7, 5)); + } + + SECTION("Blocks intersect by the corner (splitted horizontally)") + { + const wxGridBlockCoords block1(1, 1, 5, 5); + const wxGridBlockCoords block2(3, 3, 7, 7); + const wxGridBlockDiffResult result = + block1.Difference(block2, wxHORIZONTAL); + + CHECK(result.m_parts[0] == wxGridBlockCoords(1, 1, 2, 5)); + CHECK(result.m_parts[1] == wxGridNoBlockCoords); + CHECK(result.m_parts[2] == wxGridBlockCoords(3, 1, 5, 2)); + CHECK(result.m_parts[3] == wxGridNoBlockCoords); + } + + SECTION("Blocks intersect by the corner (splitted vertically)") + { + const wxGridBlockCoords block1(1, 1, 5, 5); + const wxGridBlockCoords block2(3, 3, 7, 7); + const wxGridBlockDiffResult result = + block1.Difference(block2, wxVERTICAL); + + CHECK(result.m_parts[0] == wxGridBlockCoords(1, 1, 5, 2)); + CHECK(result.m_parts[1] == wxGridNoBlockCoords); + CHECK(result.m_parts[2] == wxGridBlockCoords(1, 3, 2, 5)); + CHECK(result.m_parts[3] == wxGridNoBlockCoords); + } + + SECTION("Blocks are the same") + { + const wxGridBlockCoords block1(1, 1, 3, 3); + const wxGridBlockCoords block2(1, 1, 3, 3); + const wxGridBlockDiffResult result = + block1.Difference(block2, wxHORIZONTAL); + + CHECK(result.m_parts[0] == wxGridNoBlockCoords); + CHECK(result.m_parts[1] == wxGridNoBlockCoords); + CHECK(result.m_parts[2] == wxGridNoBlockCoords); + CHECK(result.m_parts[3] == wxGridNoBlockCoords); + } + + SECTION("Blocks doesn't intersects") + { + const wxGridBlockCoords block1(1, 1, 3, 3); + const wxGridBlockCoords block2(5, 5, 7, 7); + const wxGridBlockDiffResult result = + block1.Difference(block2, wxHORIZONTAL); + + CHECK(result.m_parts[0] == wxGridBlockCoords(1, 1, 3, 3)); + CHECK(result.m_parts[1] == wxGridNoBlockCoords); + CHECK(result.m_parts[2] == wxGridNoBlockCoords); + CHECK(result.m_parts[3] == wxGridNoBlockCoords); + } +} + + +TEST_CASE("GridBlockCoords::SymDifference", "[grid]") +{ + SECTION("With contained block") + { + const wxGridBlockCoords block1(1, 1, 7, 7); + const wxGridBlockCoords block2(3, 3, 5, 5); + const wxGridBlockDiffResult result = block1.SymDifference(block2); + + CHECK(result.m_parts[0] == wxGridBlockCoords(1, 1, 2, 7)); + CHECK(result.m_parts[1] == wxGridBlockCoords(6, 1, 7, 7)); + CHECK(result.m_parts[2] == wxGridBlockCoords(3, 1, 5, 2)); + CHECK(result.m_parts[3] == wxGridBlockCoords(3, 6, 5, 7)); + } + + SECTION("Blocks intersect by the corner") + { + const wxGridBlockCoords block1(1, 1, 5, 5); + const wxGridBlockCoords block2(3, 3, 7, 7); + const wxGridBlockDiffResult result = block1.SymDifference(block2); + + CHECK(result.m_parts[0] == wxGridBlockCoords(1, 1, 2, 5)); + CHECK(result.m_parts[1] == wxGridBlockCoords(6, 3, 7, 7)); + CHECK(result.m_parts[2] == wxGridBlockCoords(3, 1, 5, 2)); + CHECK(result.m_parts[3] == wxGridBlockCoords(3, 6, 5, 7)); + } + + SECTION("Blocks are the same") + { + const wxGridBlockCoords block1(1, 1, 3, 3); + const wxGridBlockCoords block2(1, 1, 3, 3); + const wxGridBlockDiffResult result = block1.SymDifference(block2); + + CHECK(result.m_parts[0] == wxGridNoBlockCoords); + CHECK(result.m_parts[1] == wxGridNoBlockCoords); + CHECK(result.m_parts[2] == wxGridNoBlockCoords); + CHECK(result.m_parts[3] == wxGridNoBlockCoords); + } + + SECTION("Blocks doesn't intersects") + { + const wxGridBlockCoords block1(1, 1, 3, 3); + const wxGridBlockCoords block2(5, 5, 7, 7); + const wxGridBlockDiffResult result = block1.SymDifference(block2); + + CHECK(result.m_parts[0] == wxGridBlockCoords(1, 1, 3, 3)); + CHECK(result.m_parts[1] == wxGridBlockCoords(5, 5, 7, 7)); + CHECK(result.m_parts[2] == wxGridNoBlockCoords); + CHECK(result.m_parts[3] == wxGridNoBlockCoords); + } +} + #endif //wxUSE_GRID