| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| package complex.toolkit; |
| |
| import com.sun.star.awt.XControl; |
| import com.sun.star.awt.XControlContainer; |
| import com.sun.star.awt.XControlModel; |
| import com.sun.star.awt.XToolkit; |
| import com.sun.star.awt.grid.DefaultGridDataModel; |
| import com.sun.star.awt.grid.XGridColumn; |
| import com.sun.star.awt.grid.XGridColumnModel; |
| import com.sun.star.awt.grid.XGridControl; |
| import com.sun.star.awt.grid.XGridDataModel; |
| import com.sun.star.awt.grid.XMutableGridDataModel; |
| import com.sun.star.awt.grid.XSortableMutableGridDataModel; |
| import com.sun.star.beans.Pair; |
| import com.sun.star.beans.XPropertySet; |
| import com.sun.star.container.ContainerEvent; |
| import com.sun.star.container.XContainerListener; |
| import com.sun.star.container.XNameContainer; |
| import com.sun.star.lang.EventObject; |
| import com.sun.star.lang.IndexOutOfBoundsException; |
| import com.sun.star.lang.XComponent; |
| import com.sun.star.lang.XEventListener; |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.uno.Exception; |
| import com.sun.star.uno.UnoRuntime; |
| import com.sun.star.uno.XComponentContext; |
| import com.sun.star.uno.XInterface; |
| import com.sun.star.util.XCloneable; |
| import complex.toolkit.awtgrid.DummyColumn; |
| import complex.toolkit.awtgrid.TMutableGridDataModel; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Random; |
| import org.junit.AfterClass; |
| import org.junit.BeforeClass; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| import static org.junit.Assert.*; |
| import org.openoffice.test.OfficeConnection; |
| |
| /** is a unit test for the grid control related implementations |
| * @author frank.schoenheit@sun.com |
| */ |
| public class GridControl |
| { |
| // ----------------------------------------------------------------------------------------------------------------- |
| public GridControl() |
| { |
| m_context = m_connection.getComponentContext(); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private static void impl_dispose( final Object... i_components ) |
| { |
| for ( int i=0; i<i_components.length; ++i ) |
| { |
| if ( i_components[i] != null ) |
| { |
| final XComponent component = UnoRuntime.queryInterface( XComponent.class, i_components[i] ); |
| component.dispose(); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private void impl_recreateGridModel() throws Exception |
| { |
| impl_dispose( m_gridControlModel, m_columnModel, m_dataModel ); |
| |
| // create a grid control model, and ensure it has a proper data and column model already |
| m_gridControlModel = UnoRuntime.queryInterface( XPropertySet.class, |
| createInstance( "com.sun.star.awt.grid.UnoControlGridModel" ) ); |
| assertNotNull( "grid control model does not provide XPropertySet interface", m_gridControlModel ); |
| |
| // ensure that the model has default column/data models |
| m_columnModel = UnoRuntime.queryInterface( XGridColumnModel.class, m_gridControlModel.getPropertyValue( "ColumnModel" ) ); |
| assertNotNull( "the control model is expected to have an initial column model", m_columnModel ); |
| final XGridDataModel dataModel = UnoRuntime.queryInterface( XGridDataModel.class, m_gridControlModel.getPropertyValue( "GridDataModel" ) ); |
| assertNotNull( "the control model is expected to have an initial data model", dataModel ); |
| m_dataModel = UnoRuntime.queryInterface( XSortableMutableGridDataModel.class, |
| dataModel ); |
| assertNotNull( "the out-of-the-box data model should be mutable and sortable", m_dataModel ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @Test |
| public void testGridControlCloning() throws Exception |
| { |
| impl_recreateGridModel(); |
| |
| // give the test something to compare, actually |
| XGridColumnModel columnModel = UnoRuntime.queryInterface( XGridColumnModel.class, |
| m_gridControlModel.getPropertyValue( "ColumnModel" ) ); |
| columnModel.setDefaultColumns( 10 ); |
| |
| // clone the grid model |
| final XCloneable cloneable = UnoRuntime.queryInterface( XCloneable.class, m_gridControlModel ); |
| assertNotNull( "all UnoControlModel's are expected to be cloneable", cloneable ); |
| |
| final XInterface clone = cloneable.createClone(); |
| final XPropertySet clonedProps = UnoRuntime.queryInterface( XPropertySet.class, clone ); |
| |
| // TODO: check all those generic properties for equality |
| |
| // the data model and the column model should have been cloned, too |
| // in particular, the clone should not share the sub models with the orignal |
| final XMutableGridDataModel originalDataModel = UnoRuntime.queryInterface( XMutableGridDataModel.class, |
| m_gridControlModel.getPropertyValue( "GridDataModel" ) ); |
| final XMutableGridDataModel clonedDataModel = UnoRuntime.queryInterface( XMutableGridDataModel.class, |
| clonedProps.getPropertyValue( "GridDataModel" ) ); |
| assertFalse( "data model should not be shared after cloning", UnoRuntime.areSame( originalDataModel, clonedDataModel ) ); |
| impl_assertEquality( originalDataModel, clonedDataModel ); |
| |
| final XGridColumnModel originalColumnModel = columnModel; |
| final XGridColumnModel clonedColumnModel = UnoRuntime.queryInterface( XGridColumnModel.class, |
| clonedProps.getPropertyValue( "ColumnModel" ) ); |
| assertFalse( "column model should not be shared after cloning", UnoRuntime.areSame( originalColumnModel, clonedColumnModel ) ); |
| impl_assertEquality( originalColumnModel, clonedColumnModel ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @Test |
| public void testDisposal() throws Exception |
| { |
| impl_recreateGridModel(); |
| |
| final int columnCount = 3; |
| m_columnModel.setDefaultColumns( columnCount ); |
| |
| // add disposal listeners to all columns so far |
| final XGridColumn[] columns = m_columnModel.getColumns(); |
| assertEquals( "creating default columns resulted in unexpected column count", columnCount, columns.length ); |
| final DisposeListener[] columnListeners = new DisposeListener[columnCount]; |
| for ( int i=0; i<columnCount; ++i ) |
| columnListeners[i] = new DisposeListener( columns[i] ); |
| |
| // add another column, and check that upon removal, it is disposed |
| final int newColumnIndex = m_columnModel.addColumn( m_columnModel.createColumn() ); |
| final DisposeListener columnListener = new DisposeListener( m_columnModel.getColumn( newColumnIndex ) ); |
| m_columnModel.removeColumn( newColumnIndex ); |
| assertTrue( "explicit column removal is expected to dispose the column", columnListener.isDisposed() ); |
| |
| // by definition, the grid control model is the owner of both the column and the data model. So, setting |
| // a new column/data model should implicitly dispose the old models |
| final DisposeListener oldDataModelListener = new DisposeListener( m_dataModel ); |
| final DisposeListener oldColumnModelListener = new DisposeListener( m_columnModel ); |
| |
| final Object newDataModel = createInstance( "com.sun.star.awt.grid.DefaultGridDataModel" ); |
| final Object newColumnModel = createInstance( "com.sun.star.awt.grid.DefaultGridColumnModel" ); |
| final DisposeListener newDataModelListener = new DisposeListener( newDataModel ); |
| final DisposeListener newColumnModelListener = new DisposeListener( newColumnModel ); |
| |
| m_gridControlModel.setPropertyValue( "GridDataModel", newDataModel ); |
| assertTrue( "setting a new data model failed", impl_areSameInterface( newDataModel, m_gridControlModel.getPropertyValue( "GridDataModel" ) ) ); |
| m_gridControlModel.setPropertyValue( "ColumnModel", newColumnModel ); |
| assertTrue( "setting a new column model failed", impl_areSameInterface( newColumnModel, m_gridControlModel.getPropertyValue( "ColumnModel" ) ) ); |
| |
| assertTrue( "old data model has not been disposed", oldDataModelListener.isDisposed() ); |
| assertTrue( "old column model has not been disposed", oldColumnModelListener.isDisposed() ); |
| for ( int i=0; i<columnCount; ++i ) |
| assertTrue( "column no. " + i + " has not been disposed", columnListeners[i].isDisposed() ); |
| |
| // the same holds if the grid control model itself is disposed - it should dispose the depending models, too |
| assertFalse( "new data model is already disposed - this is unexpected", newDataModelListener.isDisposed() ); |
| assertFalse( "new column model is already disposed - this is unexpected", newColumnModelListener.isDisposed() ); |
| impl_dispose( m_gridControlModel ); |
| assertTrue( "new data model is not disposed after disposing the grid column model", newDataModelListener.isDisposed() ); |
| assertTrue( "new column model is not disposed after disposing the grid column model", newColumnModelListener.isDisposed() ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| /** |
| * tests various aspects of the <code>XMutableGridDataModel</code> interface |
| */ |
| @Test |
| public void testMutableGridDataModel() throws Exception |
| { |
| impl_recreateGridModel(); |
| |
| TMutableGridDataModel test = new TMutableGridDataModel( m_dataModel ); |
| test.testAddRow(); |
| test.testAddRows(); |
| test.testInsertRow(); |
| test.testInsertRows(); |
| test.testRemoveRow(); |
| test.testRemoveAllRows(); |
| test.testUpdateCellData(); |
| test.testUpdateRowData(); |
| test.testUpdateRowHeading(); |
| test.cleanup(); |
| |
| // a somehwat less straight-forward test: the data model is expected to implicitly increase its column count |
| // when you add a row which has more columns than currently known |
| final XMutableGridDataModel dataModel = DefaultGridDataModel.create( m_context ); |
| dataModel.addRow( 0, new Object[] { 1 } ); |
| assertEquals( "unexpected column count after adding the most simple row", 1, dataModel.getColumnCount() ); |
| dataModel.addRow( 1, new Object[] { 1, 2 } ); |
| assertEquals( "implicit extension of the column count doesn't work", 2, dataModel.getColumnCount() ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @Test |
| public void testGridColumnModel() throws Exception |
| { |
| impl_recreateGridModel(); |
| |
| ColumnModelListener listener = new ColumnModelListener(); |
| m_columnModel.addContainerListener( listener ); |
| |
| // insert default columns into the previously empty model, ensure we get the right notifications |
| final int defaultColumnsCount = 3; |
| m_columnModel.setDefaultColumns( defaultColumnsCount ); |
| impl_assertColumnModelConsistency(); |
| List< ContainerEvent > events = listener.assertExclusiveInsertionEvents(); |
| listener.reset(); |
| assertEquals( "wrong number of events fired by setDefaulColumns", defaultColumnsCount, events.size() ); |
| for ( int i=0; i<defaultColumnsCount; ++i ) |
| { |
| final ContainerEvent event = events.get(i); |
| final int index = impl_assertInteger( event.Accessor ); |
| assertEquals( "unexpected Accessor value in insert notification", i, index ); |
| assertTrue( "wrong column object notified in insert notification", |
| impl_areSameInterface( event.Element, m_columnModel.getColumn(i) ) ); |
| } |
| |
| // insert some more default columns, ensure that all previously existing columns are removed |
| final int moreDefaultColumnsCount = 5; |
| m_columnModel.setDefaultColumns( moreDefaultColumnsCount ); |
| impl_assertColumnModelConsistency(); |
| assertEquals( "setting default columns is expected to remove all previously existing columns", |
| moreDefaultColumnsCount, m_columnModel.getColumnCount() ); |
| |
| // in this situation, both removal and insertion events have been notified |
| final List< ContainerEvent > removalEvents = listener.getRemovalEvents(); |
| final List< ContainerEvent > insertionEvents = listener.getInsertionEvents(); |
| listener.reset(); |
| |
| // for the removal events, check the indexes |
| assertEquals( "wrong number of columns removed (or notified) upon setting default columns", |
| defaultColumnsCount, removalEvents.size() ); |
| for ( int i=0; i<removalEvents.size(); ++i ) |
| { |
| final ContainerEvent event = removalEvents.get(i); |
| final int removedIndex = impl_assertInteger( event.Accessor ); |
| |
| // The implementation is allowed to remove the columns from the beginning, in which case the |
| // index of the removed column must always be 0, since e.g. the second column has index 0 |
| // after the first column (which previously had index 0) had been removed. |
| // Alternatively, the implementation is allowed to remove columns from the end, which means |
| // that the column index given in the event is steadily increasing. |
| assertTrue( "unexpected column removal event column index", |
| ( removedIndex == 0 ) || ( removedIndex == removalEvents.size() - 1 - i ) ); |
| } |
| |
| // for the insertion events, check the indexes as well |
| assertEquals( "wrong number of insertion events when setting default columns over existing columns", |
| moreDefaultColumnsCount, insertionEvents.size() ); |
| for ( int i=0; i<insertionEvents.size(); ++i ) |
| { |
| final ContainerEvent event = insertionEvents.get(i); |
| final int index = impl_assertInteger( event.Accessor ); |
| assertEquals( i, index ); |
| } |
| |
| // okay, remove all those columns |
| while ( m_columnModel.getColumnCount() != 0 ) |
| { |
| final int columnCount = m_columnModel.getColumnCount(); |
| final int removeColumnIndex = m_randomGenerator.nextInt( columnCount ); |
| m_columnModel.removeColumn( removeColumnIndex ); |
| events = listener.assertExclusiveRemovalEvents(); |
| listener.reset(); |
| assertEquals( "removing a single column should notify a single event", 1, events.size() ); |
| final ContainerEvent event = events.get(0); |
| final int removalIndex = impl_assertInteger( event.Accessor ); |
| assertEquals( "removing an arbitrary column does not notify the proper accessor", |
| removeColumnIndex, removalIndex ); |
| } |
| |
| // calling addColumn with a column not created by the given model/implementatoion should not succeed |
| boolean caughtExpected = false; |
| try |
| { |
| m_columnModel.addColumn( new DummyColumn() ); |
| } |
| catch( final com.sun.star.lang.IllegalArgumentException e ) |
| { |
| assertTrue( impl_areSameInterface( e.Context, m_columnModel ) ); |
| caughtExpected = true; |
| } |
| assertTrue( "adding a dummy (self-implemented) grid column to the model should not succeed", caughtExpected ); |
| |
| // adding a single column to the end should succeed, properly notify, and still be consistent |
| final XGridColumn newColumn = m_columnModel.createColumn(); |
| m_columnModel.addColumn( newColumn ); |
| impl_assertColumnModelConsistency(); |
| events = listener.assertExclusiveInsertionEvents(); |
| listener.reset(); |
| assertEquals( "addColumn notifies the wrong number of insertion events", 1, events.size() ); |
| final int insertionIndex = impl_assertInteger( events.get(0).Accessor ); |
| assertEquals( insertionIndex, newColumn.getIndex() ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @Test |
| public void testDataModel() throws Exception |
| { |
| impl_recreateGridModel(); |
| |
| // ensure that getCellData and getRowData have the same opinion on the data they deliver |
| final Object[][] data = new Object[][] { |
| new Object[] { 15, 17, 0 }, |
| new Object[] { 9, 8, 14 }, |
| new Object[] { 17, 2, 16 }, |
| new Object[] { 0, 7, 14 }, |
| new Object[] { 10, 16, 16 }, |
| }; |
| m_dataModel.addRows( new Object[ data.length ], data ); |
| |
| for ( int row = 0; row < data.length; ++row ) |
| { |
| assertArrayEquals( "getRowData delivers wrong data in row " + row, data[row], m_dataModel.getRowData( row ) ); |
| for ( int col = 0; col < data[row].length; ++col ) |
| { |
| assertEquals( "getCellData delivers wrong data at position (" + col + ", " + row + ")", |
| data[row][col], m_dataModel.getCellData( col, row ) ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @Test |
| public void testSortableDataModel() throws Exception |
| { |
| impl_recreateGridModel(); |
| |
| final int colCount = 3; |
| final int rowCount = 10; |
| // initialize with some data |
| final Object[][] data = new Object[][] { |
| new Object[] { 15, 17, 0 }, |
| new Object[] { 9, 8, 14 }, |
| new Object[] { 17, 2, 16 }, |
| new Object[] { 0, 7, 14 }, |
| new Object[] { 10, 16, 16 }, |
| new Object[] { 2, 8, 10 }, |
| new Object[] { 4, 8, 3 }, |
| new Object[] { 7, 9, 0 }, |
| new Object[] { 15, 6, 19 }, |
| new Object[] { 2, 14, 19 } |
| }; |
| final Object[] rowHeadings = new Object[] { |
| 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 |
| }; |
| // ensure consistency of the test data |
| assertEquals( rowHeadings.length, rowCount ); |
| assertEquals( data.length, rowCount ); |
| for ( Object[] rowData : data ) |
| assertEquals( rowData.length, colCount ); |
| |
| // add the test data |
| m_dataModel.addRows( rowHeadings, data ); |
| assertEquals( rowCount, m_dataModel.getRowCount() ); |
| assertEquals( colCount, m_dataModel.getColumnCount() ); |
| |
| // sort by each column |
| for ( int colIndex = 0; colIndex < colCount; ++colIndex ) |
| { |
| for ( boolean ascending : new boolean[] { true, false } ) |
| { |
| m_dataModel.sortByColumn( colIndex, ascending ); |
| Pair currentSortOrder = m_dataModel.getCurrentSortOrder(); |
| assertEquals( "invalid current sort column (column " + colIndex + ")", ((Integer)currentSortOrder.First).intValue(), colIndex ); |
| assertEquals( "invalid current sort direction", ((Boolean)currentSortOrder.Second).booleanValue(), ascending ); |
| |
| /*for ( int i=0; i<rowCount; ++i ) |
| { |
| for ( int j=0; j<colCount; ++j ) |
| System.out.print( m_dataModel.getCellData( j, i ).toString() + ", " ); |
| System.out.println(); |
| }*/ |
| |
| // verify the data is actually sorted by this column |
| for ( int rowIndex = 0; rowIndex < rowCount - 1; ++rowIndex ) |
| { |
| final Object currentValue = m_dataModel.getCellData( colIndex, rowIndex ); |
| final int currentIntValue = impl_assertInteger( currentValue ); |
| final Object nextValue = m_dataModel.getCellData( colIndex, rowIndex + 1 ); |
| final int nextIntValue = impl_assertInteger( nextValue ); |
| assertTrue( "data in row " + rowIndex + " is actually not sorted " + ( ascending ? "ascending" : "descending" ), |
| ascending ? currentIntValue <= nextIntValue |
| : currentIntValue >= nextIntValue ); |
| |
| // ensure the data in the other columns, and the row headings, are sorted as well |
| final Object rowHeading = m_dataModel.getRowHeading( rowIndex ); |
| final int unsortedRowIndex = impl_assertInteger( rowHeading ); |
| for ( int innerColIndex = 0; innerColIndex < colCount; ++innerColIndex ) |
| { |
| assertEquals( "sorted row " + rowIndex + ", unsorted row " + unsortedRowIndex + ", col " + innerColIndex + |
| ": wrong data", |
| data[unsortedRowIndex][innerColIndex], m_dataModel.getCellData( innerColIndex, rowIndex ) ); |
| } |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @Test |
| public void testView() throws Exception |
| { |
| final XControl control = impl_createDialogWithGridControl(); |
| final XPropertySet gridModelProps = |
| UnoRuntime.queryInterface( XPropertySet.class, control.getModel() ); |
| |
| // in the current implementation (not sure this is a good idea at all), the control (more precise: the peer) |
| // ensures that if there are no columns in the column model, but in the data model, then the column model |
| // will implicitly have the needed columns added. |
| // To ensure that clients which rely on this do not break in the future, check this here. |
| final XMutableGridDataModel dataModel = UnoRuntime.queryInterface( XMutableGridDataModel.class, |
| gridModelProps.getPropertyValue( "GridDataModel" ) ); |
| assertNotNull( dataModel ); |
| assertEquals( 0, dataModel.getColumnCount() ); |
| |
| final XGridColumnModel columnModel = UnoRuntime.queryInterface( XGridColumnModel.class, |
| gridModelProps.getPropertyValue( "ColumnModel" ) ); |
| assertNotNull( columnModel ); |
| assertEquals( 0, columnModel.getColumnCount() ); |
| |
| final int columnCount = 3; |
| final int rowCount = 2; |
| dataModel.addRow( null, new Object[] { 1, 2, 3 } ); |
| dataModel.addRow( null, new Object[] { 6, 5, 4 } ); |
| |
| assertEquals( columnCount, dataModel.getColumnCount() ); |
| assertEquals( columnCount, columnModel.getColumnCount() ); |
| |
| // some cursor traveling |
| final XGridControl gridControl = UnoRuntime.queryInterface( XGridControl.class, control ); |
| gridControl.goToCell( 0, 0 ); |
| assertEquals( "wrong 'current column' (1)", 0, gridControl.getCurrentColumn() ); |
| assertEquals( "wrong 'current row' (1)", 0, gridControl.getCurrentRow() ); |
| gridControl.goToCell( columnCount - 1, rowCount - 1 ); |
| assertEquals( "wrong 'current column' (2)", dataModel.getColumnCount() - 1, gridControl.getCurrentColumn() ); |
| assertEquals( "wrong 'current row' (2)", dataModel.getRowCount() - 1, gridControl.getCurrentRow() ); |
| |
| // removing the last column, while the active cell is in this very last column, is expected to adjust |
| // the active cell |
| columnModel.removeColumn( columnCount - 1 ); |
| assertEquals( "removed the last and active column, active column was not adjusted!", |
| columnCount - 2, gridControl.getCurrentColumn() ); |
| // same holds for rows |
| dataModel.removeRow( rowCount - 1 ); |
| assertEquals( "removed the last and active row, active row was not adjusted!", |
| rowCount - 2, gridControl.getCurrentRow() ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private XControl impl_createDialogWithGridControl() throws Exception |
| { |
| // create a simple dialog model/control/peer trinity |
| final XControlModel dialogModel = createInstance( XControlModel.class, "com.sun.star.awt.UnoControlDialogModel" ); |
| m_disposables.add( dialogModel ); |
| final XPropertySet dialogProps = UnoRuntime.queryInterface( XPropertySet.class, dialogModel ); |
| dialogProps.setPropertyValue( "Width", 200 ); |
| dialogProps.setPropertyValue( "Height", 100 ); |
| dialogProps.setPropertyValue( "Title", "Grid Control Unit Test" ); |
| final XControl dialogControl = createInstance( XControl.class, "com.sun.star.awt.UnoControlDialog" ); |
| m_disposables.add( dialogControl ); |
| dialogControl.setModel( dialogModel ); |
| dialogControl.createPeer( createInstance( XToolkit.class, "com.sun.star.awt.Toolkit" ), null ); |
| |
| // insert a grid control model |
| final XMultiServiceFactory controlModelFactory = UnoRuntime.queryInterface( XMultiServiceFactory.class, |
| dialogModel ); |
| final XPropertySet gridModelProps = UnoRuntime.queryInterface( XPropertySet.class, |
| controlModelFactory.createInstance( "com.sun.star.awt.grid.UnoControlGridModel" ) ); |
| m_disposables.add( gridModelProps ); |
| gridModelProps.setPropertyValue( "PositionX", 6 ); |
| gridModelProps.setPropertyValue( "PositionY", 6 ); |
| gridModelProps.setPropertyValue( "Width", 188 ); |
| gridModelProps.setPropertyValue( "Height", 88 ); |
| final XNameContainer modelContainer = UnoRuntime.queryInterface( XNameContainer.class, dialogModel ); |
| modelContainer.insertByName( "grid", gridModelProps ); |
| |
| // check the respective control has been created |
| final XControlContainer controlContainer = UnoRuntime.queryInterface( XControlContainer.class, dialogControl ); |
| final XControl gridControl = controlContainer.getControl( "grid" ); |
| assertNotNull( "no grid control created in the dialog", gridControl ); |
| |
| return gridControl; |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private int impl_assertInteger( final Object i_object ) |
| { |
| assertTrue( i_object instanceof Integer ); |
| return ((Integer)i_object).intValue(); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private void impl_assertColumnModelConsistency() throws IndexOutOfBoundsException |
| { |
| for ( int col = 0; col < m_columnModel.getColumnCount(); ++col ) |
| { |
| final XGridColumn column = m_columnModel.getColumn( col ); |
| assertNotNull( column ); |
| assertEquals( "column/model inconsistency: column " + col + " has a wrong index!", col, column.getIndex() ); |
| } |
| |
| final XGridColumn[] allColumns = m_columnModel.getColumns(); |
| assertEquals( "getColumns returns the wrong number of column objects", |
| m_columnModel.getColumnCount(), allColumns.length ); |
| for ( int col = 0; col < m_columnModel.getColumnCount(); ++col ) |
| { |
| assertTrue( "getColumns inconsistency", impl_areSameInterface( allColumns[col], m_columnModel.getColumn(col) ) ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private void impl_assertEquality( final XGridDataModel i_reference, final XGridDataModel i_compare ) throws IndexOutOfBoundsException |
| { |
| assertNotNull( i_reference ); |
| assertNotNull( i_compare ); |
| |
| assertEquals( "data model comparison: wrong column counts", i_reference.getColumnCount(), i_compare.getColumnCount() ); |
| assertEquals( "data model comparison: wrong row counts", i_reference.getRowCount(), i_compare.getRowCount() ); |
| |
| for ( int row = 0; row < i_reference.getRowCount(); ++row ) |
| { |
| assertEquals( "data model comparison: wrong row heading content in row " + row, |
| i_reference.getRowHeading( row ) ); |
| for ( int col = 0; col < i_reference.getRowCount(); ++col ) |
| { |
| assertEquals( "data model comparison: wrong cell content in cell (" + col + ", " + row + ")", |
| i_reference.getCellData( col, row ) ); |
| assertEquals( "data model comparison: wrong tooltip content in cell (" + col + ", " + row + ")", |
| i_reference.getCellToolTip( col, row ) ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private void impl_assertEquality( final XGridColumnModel i_reference, final XGridColumnModel i_compare ) throws IndexOutOfBoundsException |
| { |
| assertEquals( "column model comparison: wrong column counts", i_reference.getColumnCount(), i_compare.getColumnCount() ); |
| for ( int col = 0; col < i_reference.getColumnCount(); ++col ) |
| { |
| final XGridColumn referenceColumn = i_reference.getColumn( col ); |
| final XGridColumn compareColumn = i_compare.getColumn( col ); |
| impl_assertEquality( referenceColumn, compareColumn ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private void impl_assertEquality( final XGridColumn i_reference, final XGridColumn i_compare ) |
| { |
| final Method[] methods = XGridColumn.class.getMethods(); |
| for ( int m=0; m<methods.length; ++m ) |
| { |
| if ( !methods[m].getName().startsWith( "get" ) ) |
| continue; |
| try |
| { |
| final Object referenceValue = methods[m].invoke( i_reference ); |
| final Object compareValue = methods[m].invoke( i_compare ); |
| assertEquals( "grid column comparison: column attribute '" + methods[m].getName().substring(3) + "' does not match", |
| referenceValue, compareValue ); |
| } |
| catch ( java.lang.Exception ex ) |
| { |
| fail( " could not retrieve object attributes: " + ex.toString() ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private boolean impl_areSameInterface( final Object i_lhs, final Object i_rhs ) |
| { |
| final XInterface lhs = UnoRuntime.queryInterface( XInterface.class, i_lhs ); |
| final XInterface rhs = UnoRuntime.queryInterface( XInterface.class, i_rhs ); |
| return UnoRuntime.areSame( lhs, rhs ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @Before |
| public void initTestCase() |
| { |
| m_disposables.clear(); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @After |
| public void cleanupTestCase() |
| { |
| impl_dispose( m_disposables.toArray() ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @BeforeClass |
| public static void setUpConnection() throws java.lang.Exception |
| { |
| System.out.println( "--------------------------------------------------------------------------------" ); |
| System.out.println( "starting class: " + GridControl.class.getName() ); |
| System.out.print( "connecting ... " ); |
| m_connection.setUp(); |
| System.out.println( "done."); |
| |
| final long seed = m_randomGenerator.nextLong(); |
| m_randomGenerator.setSeed( seed ); |
| System.out.println( "seeding random number generator with " + seed ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| @AfterClass |
| public static void tearDownConnection() |
| throws InterruptedException, com.sun.star.uno.Exception |
| { |
| System.out.println(); |
| System.out.println( "tearing down connection" ); |
| m_connection.tearDown(); |
| System.out.println( "finished class: " + GridControl.class.getName() ); |
| System.out.println( "--------------------------------------------------------------------------------" ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| public <T> T createInstance( Class<T> i_interfaceClass, final String i_serviceIndentifer ) throws Exception |
| { |
| return UnoRuntime.queryInterface( i_interfaceClass, createInstance( i_serviceIndentifer ) ); |
| } |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private Object createInstance( final String i_serviceName ) throws Exception |
| { |
| Object instance = m_context.getServiceManager().createInstanceWithContext( i_serviceName, m_context ); |
| assertNotNull( "could not create an instance of '" + i_serviceName + "'", instance ); |
| return instance; |
| } |
| // ----------------------------------------------------------------------------------------------------------------- |
| private static final class DisposeListener implements XEventListener |
| { |
| DisposeListener( final Object i_component ) |
| { |
| m_component = UnoRuntime.queryInterface( XComponent.class, i_component ); |
| assertNotNull( m_component ); |
| m_component.addEventListener( this ); |
| } |
| |
| public void disposing( EventObject i_event ) |
| { |
| assertTrue( UnoRuntime.areSame( i_event.Source, m_component ) ); |
| m_isDisposed = true; |
| } |
| |
| final boolean isDisposed() { return m_isDisposed; } |
| |
| private final XComponent m_component; |
| private boolean m_isDisposed; |
| }; |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private static final class ColumnModelListener implements XContainerListener |
| { |
| ColumnModelListener() |
| { |
| } |
| |
| public void elementInserted( ContainerEvent i_event ) |
| { |
| m_insertionEvents.add( i_event ); |
| } |
| |
| public void elementRemoved( ContainerEvent i_event ) |
| { |
| m_removalEvents.add( i_event ); |
| } |
| |
| public void elementReplaced( ContainerEvent i_event ) |
| { |
| m_replacementEvents.add( i_event ); |
| } |
| |
| public void disposing( EventObject eo ) |
| { |
| m_isDisposed = true; |
| } |
| |
| private List< ContainerEvent > assertExclusiveInsertionEvents() |
| { |
| assertFalse( m_insertionEvents.isEmpty() ); |
| assertTrue( m_removalEvents.isEmpty() ); |
| assertTrue( m_replacementEvents.isEmpty() ); |
| return m_insertionEvents; |
| } |
| |
| private List< ContainerEvent > assertExclusiveRemovalEvents() |
| { |
| assertTrue( m_insertionEvents.isEmpty() ); |
| assertFalse( m_removalEvents.isEmpty() ); |
| assertTrue( m_replacementEvents.isEmpty() ); |
| return m_removalEvents; |
| } |
| |
| private void reset() |
| { |
| m_insertionEvents = new ArrayList< ContainerEvent >(); |
| m_removalEvents = new ArrayList< ContainerEvent >(); |
| m_replacementEvents = new ArrayList< ContainerEvent >(); |
| } |
| |
| private List< ContainerEvent > getInsertionEvents() { return m_insertionEvents; } |
| private List< ContainerEvent > getRemovalEvents() { return m_removalEvents; } |
| |
| final boolean isDisposed() { return m_isDisposed; } |
| |
| private List< ContainerEvent > m_insertionEvents = new ArrayList< ContainerEvent >(); |
| private List< ContainerEvent > m_removalEvents = new ArrayList< ContainerEvent >(); |
| private List< ContainerEvent > m_replacementEvents = new ArrayList< ContainerEvent >(); |
| private boolean m_isDisposed = false; |
| }; |
| |
| // ----------------------------------------------------------------------------------------------------------------- |
| private static final OfficeConnection m_connection = new OfficeConnection(); |
| private static Random m_randomGenerator = new Random(); |
| private final XComponentContext m_context; |
| |
| private XPropertySet m_gridControlModel; |
| private XGridColumnModel m_columnModel; |
| private XSortableMutableGridDataModel m_dataModel; |
| private final List< Object > m_disposables = new ArrayList< Object >(); |
| } |
