/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <q3datetimeedit.h>

#include <qapplication.h>

#include <qcombobox.h>

#include <qdialog.h>

#include <qlineedit.h>

#include <q3listbox.h>

#include <q3table.h>

#include <qlayout.h>

#include "../../shared/util.h"

#define WAITS 1

#ifdef WAITS

#endif

Q_DECLARE_METATYPE(QPoint)

//TESTED_FILES=

QT_FORWARD_DECLARE_CLASS(Q3Table)

class tst_Q3Table : public QObject

{

    Q_OBJECT

public:

    tst_Q3Table();

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void setNumRowsColsItems();

    void setNumRowsColsWidgets();

    void selection();

    void selectComboTableItem_data();

    void selectComboTableItem();

    void pageUpDownNavigation_data();

    void pageUpDownNavigation();

    void simpleKeyboardNavigation();

    void setRowStretchable();

    void setColumnStretchable();

    void selectRow_data();

    void selectRow();

    void selectColumn_data();

    void selectColumn();

    void removeSelection_selectionChanged();

    void cellNavigation();

    void cellNavigationWhileEditing();

    void removeRow_data();

    void removeRow();

    void swapRowMemoryLeak();

    void insertRows_data();

    void insertRows();

    void editCheck();

    void setCellWidgetFocus();

    void selectionWithMouse_data();

    void selectionWithMouse();

    void valueChanged();

    void numSelections(); // Task specific, moreNumSelections() should cover all bases

    void dateTimeEdit();

    void onValueChanged(int, int);

    void moreNumSelections_data();

    void moreNumSelections();

    void headerSwapIconset();

    void propagateEscapeKey();

public slots:

    void selectionWasChanged();

private:

    void setupTableItems();

    Q3Table *testWidget;

    bool isValueChanged, receivedSelectionChanged;

};

Q_DECLARE_METATYPE(Q3Table::SelectionMode);

#if 0

/* XPM */

static const char *fileopen[] = {

"    16    13        5            1",

". c #040404",

"# c #808304",

"a c None",

"b c #f3f704",

"c c #f3f7f3",

"aaaaaaaaa...aaaa",

"aaaaaaaa.aaa.a.a",

"aaaaaaaaaaaaa..a",

"a...aaaaaaaa...a",

".bcb.......aaaaa",

".cbcbcbcbc.aaaaa",

".bcbcbcbcb.aaaaa",

".cbcb...........",

".bcb.#########.a",

".cb.#########.aa",

".b.#########.aaa",

"..#########.aaaa",

"...........aaaaa"

};

#endif

tst_Q3Table::tst_Q3Table()

    : isValueChanged( false )

{

}

void tst_Q3Table::initTestCase()

{

}

void tst_Q3Table::cleanupTestCase()

{

}

void tst_Q3Table::init()

{

    // Reset the table

    testWidget = new Q3Table(4,4,0,"testWidget");

    testWidget->show();

#ifdef Q_WS_X11

    qt_x11_wait_for_window_manager( testWidget );

#endif

}

void tst_Q3Table::cleanup()

{

    testWidget->hide();

    delete testWidget;

    testWidget = 0;

}

/*

    Function that will popuplate the testWidget with a variety of Q3TableItems

*/

void tst_Q3Table::setupTableItems()

{

    QStringList list;

    list << "A" << "B";

    Q3ComboTableItem *cbi = new Q3ComboTableItem(testWidget, list);

    testWidget->setItem(1, 1, cbi);

    Q3ComboTableItem *ecbi = new Q3ComboTableItem(testWidget, list, TRUE);

    testWidget->setItem(1, 2, ecbi);

    Q3CheckTableItem *chi = new Q3CheckTableItem(testWidget, "Check");

    testWidget->setItem(2, 2, chi);

    Q3TableItem *ne = new Q3TableItem(testWidget, Q3TableItem::Never, "Never");

    testWidget->setItem(0, 0, ne);

    Q3TableItem *ot = new Q3TableItem(testWidget, Q3TableItem::OnTyping, "On Typing");

    testWidget->setItem(0, 1, ot);

    Q3TableItem *wc = new Q3TableItem(testWidget, Q3TableItem::WhenCurrent, "When Current");

    testWidget->setItem(0, 2, wc);

    Q3TableItem *al = new Q3TableItem(testWidget, Q3TableItem::Always, "Always");

    testWidget->setItem(0, 3, al);

}

#define CELL_TEXT(r, c) QString::number( r ) + "/" + QString::number( c )

void tst_Q3Table::setNumRowsColsItems()

{

    Q3Table *t = new Q3Table( 0, "test_table" );

    const int initial_num_rows = 4;

    const int initial_num_cols = 4;

    const int larger_num_rows = 8;

    const int larger_num_cols = 8;

    const int smaller_num_rows = 3;

    const int smaller_num_cols = 3;

    t->setNumRows( initial_num_cols );

    t->setNumCols( initial_num_cols );

    QCOMPARE( t->numRows(), initial_num_rows );

    QCOMPARE( t->numCols(), initial_num_cols );

    int r, c;

    for ( r = 0; r < initial_num_rows; ++r ) {

	for ( c = 0; c < initial_num_cols; ++c ) {

	    t->setText( r, c, CELL_TEXT( r, c ) );

	}

    }

    for ( r = 0; r < initial_num_rows; ++r ) {

	for ( c = 0; c < initial_num_cols; ++c ) {

	    QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );

	}

    }

    t->setNumRows( larger_num_rows );

    for ( r = 0; r < larger_num_rows; ++r ) {

	for ( c = 0; c < initial_num_cols; ++c ) {

	    if ( r < initial_num_rows && c < initial_num_cols ) {

		QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );

	    } else {

		QCOMPARE( t->text( r, c ), QString() );

	    }

	}

    }

    t->setNumCols( larger_num_cols );

    for ( r = 0; r < larger_num_rows; ++r ) {

	for ( c = 0; c < larger_num_cols; ++c ) {

	    if ( r < initial_num_rows && c < initial_num_cols ) {

		QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );

	    } else {

		QCOMPARE( t->text( r, c ), QString() );

	    }

	}

    }

    t->setNumRows( smaller_num_rows );

    for ( r = 0; r < smaller_num_rows; ++r ) {

	for ( c = 0; c < initial_num_cols; ++c ) {

	    QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );

	}

    }

    t->setNumCols( smaller_num_cols );

    for ( r = 0; r < smaller_num_rows; ++r ) {

	for ( c = 0; c < smaller_num_cols; ++c ) {

	    QCOMPARE( t->text( r, c ), CELL_TEXT( r, c ) );

	}

    }

    delete t;

}

void tst_Q3Table::setNumRowsColsWidgets()

{

    Q3Table *t = new Q3Table( 0, "test_table" );

    const int initial_num_rows = 4;

    const int initial_num_cols = 4;

    const int larger_num_rows = 8;

    const int larger_num_cols = 8;

    const int smaller_num_rows = 3;

    const int smaller_num_cols = 3;

    t->setNumRows( initial_num_cols );

    t->setNumCols( initial_num_cols );

    QCOMPARE( t->numRows(), initial_num_rows );

    QCOMPARE( t->numCols(), initial_num_cols );

    int r, c;

    for ( r = 0; r < initial_num_rows; ++r ) {

	for ( c = 0; c < initial_num_cols; ++c ) {

	    t->setCellWidget( r, c, new QWidget( t, CELL_TEXT( r, c ) ) );

	}

    }

    for ( r = 0; r < initial_num_rows; ++r ) {

	for ( c = 0; c < initial_num_cols; ++c ) {

	    QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );

	}

    }

    t->setNumRows( larger_num_rows );

    for ( r = 0; r < larger_num_rows; ++r ) {

	for ( c = 0; c < initial_num_cols; ++c ) {

	    if ( r < initial_num_rows && c < initial_num_cols ) {

		QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );

	    } else {

		QCOMPARE( t->cellWidget( r, c ), (QWidget*)0 );

	    }

	}

    }

    t->setNumCols( larger_num_cols );

    for ( r = 0; r < larger_num_rows; ++r ) {

	for ( c = 0; c < larger_num_cols; ++c ) {

	    if ( r < initial_num_rows && c < initial_num_cols ) {

		QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );

	    } else {

		QCOMPARE( t->cellWidget( r, c ), (QWidget*)0 );

	    }

	}

    }

    t->setNumRows( smaller_num_rows );

    for ( r = 0; r < smaller_num_rows; ++r ) {

	for ( c = 0; c < initial_num_cols; ++c ) {

	    QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );

	}

    }

    t->setNumCols( smaller_num_cols );

    for ( r = 0; r < smaller_num_rows; ++r ) {

	for ( c = 0; c < smaller_num_cols; ++c ) {

	    QCOMPARE( QString( t->cellWidget( r, c )->name() ), CELL_TEXT( r, c ) );

	}

    }

    delete t;

}

void tst_Q3Table::selection()

{

    Q3Table *t = new Q3Table( 20, 20, 0, "test_table" );

    t->selectCells( 0, 0, 50, 50 );

    Q3TableSelection sel( 60, 60, 100, 100 );

    t->addSelection( sel );

    t->show();

    QCOMPARE( t->numSelections(), 2 );

    delete t;

}

void tst_Q3Table::selectComboTableItem_data()

{

    QTest::addColumn<bool>("editable");

    QTest::newRow( "editable" ) << TRUE;

    QTest::newRow( "non-editable" ) << FALSE;

}

class MyTable : public Q3Table

{

    // Conveience subclass used to be able to call isEditing()

public:

    MyTable(int rows,int cols,QWidget *parent = 0,const char *name = 0)

	: Q3Table(rows,cols,parent,name) {}

    bool isEditing() {

	return Q3Table::isEditing();

    }

};

void tst_Q3Table::selectComboTableItem()

{

#if 0

    MyTable table(4,4,0,"subclassTestWidget");

    // Test for task #25026

    QFETCH( bool, editable );

    QStringList strings;

    strings << "One" << "Two" << "Three" << "Four";

    QComboTableItem *cbi = new QComboTableItem(testWidget,strings,editable);

    table.setItem(0,0,cbi);

    table.hide();

    table.show();

    QComboBox *cb;

    if ( !editable )

	cb = (QComboBox*)table.viewport()->child("qt_editor_cb","QComboBox");

    else

	cb = (QComboBox*)table.cellWidget(0,0);

    QVERIFY( cb );

    QCOMPARE(table.text(0,0),QString("One"));

    QTest::mouseClick(cb,QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(cb->width()-7,cb->height()-5));

    QVERIFY(cb->listBox()->isVisible());

    QTest::mouseClick(cb->listBox()->viewport(),QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(5,cb->listBox()->height()-5));

    QCOMPARE(table.text(0,0),QString("Four"));

    // Ensure the edit is accepted

    QTest::mouseClick(table.viewport(),QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(table.width()-10,table.height()-10));

    QVERIFY(!table.isEditing());

    QCOMPARE(table.text(0,0),QString("Four"));

    // Now check that Escape will revert any changes

    QTest::mouseClick(cb,QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(cb->width()-7,cb->height()-5));

    QVERIFY(cb->listBox()->isVisible());

    QTest::mouseClick(cb->listBox()->viewport(),QtTestCase::LeftButton,QtTestCase::NoButton,QPoint(5,5));

    QCOMPARE(cb->currentText(),QString("One"));

    QTest::keyClick(cb,Qt::Key_Escape);

    QVERIFY(!table.isEditing());

    QCOMPARE(table.text(0,0),QString("Four"));

#else

    QSKIP("This test will fail at the moment since the way qtestlib iss handling mouse events is broken",SkipAll);

#endif

}

void tst_Q3Table::pageUpDownNavigation_data()

{

    QTest::addColumn<Q3Table::SelectionMode>("selectionMode");

    QTest::addColumn<bool>("activeSelection");

    QTest::addColumn<int>("pgUpTopRow");

    QTest::addColumn<int>("pgUpBottomRow");

    QTest::addColumn<int>("pgUpLeftCol");

    QTest::addColumn<int>("pgUpRightCol");

    QTest::addColumn<int>("pgDownTopRow");

    QTest::addColumn<int>("pgDownBottomRow");

    QTest::addColumn<int>("pgDownLeftCol");

    QTest::addColumn<int>("pgDownRightCol");

    QTest::newRow("NoSelection") << Q3Table::NoSelection << FALSE << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1;

    QTest::newRow("SingleSelection") << Q3Table::Single << FALSE << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1;

    QTest::newRow("MultiSelection") << Q3Table::Multi << FALSE << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1;

    QTest::newRow("SingleRowSelection") << Q3Table::SingleRow << TRUE << 0 << 0 << 0 << 3 << 3 << 3 << 0 << 3;

    QTest::newRow("MultiRowSelection") << Q3Table::MultiRow << TRUE << 0 << 0 << 0 << 3 << 3 << 3 << 0 << 3;

}

void tst_Q3Table::pageUpDownNavigation()

{

    setupTableItems();

    // Test for task #25842

    QFETCH(Q3Table::SelectionMode,selectionMode);

    QFETCH(bool,activeSelection);

    QFETCH(int,pgUpTopRow);

    QFETCH(int,pgUpBottomRow);

    QFETCH(int,pgUpLeftCol);

    QFETCH(int,pgUpRightCol);

    QFETCH(int,pgDownTopRow);

    QFETCH(int,pgDownBottomRow);

    QFETCH(int,pgDownLeftCol);

    QFETCH(int,pgDownRightCol);

    // Needed to force the table to have "no selection"

    testWidget->setCurrentCell(-1,-1);

    testWidget->setSelectionMode(selectionMode);

#ifdef WAITS

    QTest::qWait(50);

#endif

    QTest::keyClick(testWidget->viewport(),Qt::Key_PageUp);

#ifdef WAITS

    QTest::qWait(50);

#endif

    Q3TableSelection ts = testWidget->selection(testWidget->currentSelection());

    QVERIFY(ts.isActive() == activeSelection);

    if (activeSelection) {

	QVERIFY(ts.topRow() == pgUpTopRow);

	QVERIFY(ts.bottomRow() == pgUpBottomRow);

	QVERIFY(ts.leftCol() == pgUpLeftCol);

	QVERIFY(ts.rightCol() == pgUpRightCol);

    }

    QTest::keyClick(testWidget->viewport(),Qt::Key_PageDown);

#ifdef WAITS

    QTest::qWait(50);

#endif

    ts = testWidget->selection(testWidget->currentSelection());

    QVERIFY(ts.isActive() == activeSelection);

    if (activeSelection) {

	QVERIFY(ts.topRow() == pgDownTopRow);

	QVERIFY(ts.bottomRow() == pgDownBottomRow);

	QVERIFY(ts.leftCol() == pgDownLeftCol);

	QVERIFY(ts.rightCol() == pgDownRightCol);

    }

}

void tst_Q3Table::simpleKeyboardNavigation()

{

    QApplication::setActiveWindow(testWidget);

    QTRY_COMPARE(QApplication::activeWindow(), testWidget);

    QWidget *w;

    // Test for task #24726

#ifdef WAITS

    QTest::qWait(50);

#endif

    QTest::mouseClick(testWidget->viewport(),

               Qt::LeftButton, Qt::NoModifier,

               QPoint(testWidget->columnPos(0) + 3, testWidget->rowPos(0) + 3));

#ifdef WAITS

    QTest::qWait(50);

#endif

    QCOMPARE(testWidget->currentColumn(), 0);

    QCOMPARE(testWidget->currentRow(), 0);

    QTest::keyClick(testWidget->viewport(), Qt::Key_T);

    // After the first keyevent, the table starts editing the item

    w = testWidget->cellWidget(0, 0);

    QVERIFY(w);

#ifdef WAITS