l10ntooling18: merge

1 files changed, 525 insertions, 104 deletions

diff --git a/svtools/source/uno/svtxgridcontrol.cxx b/svtools/source/uno/svtxgridcontrol.cxx
index 80c31e65d4f1..b411181c2aab 100644..100755
--- a/svtools/source/uno/svtxgridcontrol.cxx
+++ b/svtools/source/uno/svtxgridcontrol.cxx
@@ -28,6 +28,7 @@
 #include "precompiled_svtools.hxx"
 
 #include "svtxgridcontrol.hxx"
+#include "accessibletableimp.hxx"
 #include <com/sun/star/view/SelectionType.hpp>
 #include "svtools/table/gridtablerenderer.hxx"
 #include "svtools/table/defaultinputhandler.hxx"
@@ -37,12 +38,17 @@
 #include <rtl/ref.hxx>
 #include <tools/debug.hxx>
 #include <toolkit/helper/property.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
 #include <comphelper/processfactory.hxx>
 #include <com/sun/star/awt/grid/XGridColumn.hpp>
 #include <com/sun/star/accessibility/AccessibleTableModelChange.hpp>
 #include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp>
 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
-
+#include <com/sun/star/awt/XControl.hpp>
+#include <com/sun/star/awt/grid/GridInvalidDataException.hpp>
+#include <com/sun/star/awt/grid/GridInvalidModelException.hpp>
+#include <com/sun/star/util/Color.hpp>
+#include <com/sun/star/awt/FontDescriptor.hpp>
 
 using ::rtl::OUString;
 using namespace ::svt::table;
@@ -63,7 +69,10 @@ SVTXGridControl::SVTXGridControl()
     m_bHasColumnHeaders(false),
     m_bHasRowHeaders(false),
     m_bVScroll(false),
-    m_bHScroll(false)
+    m_bHScroll(false),
+    m_bUpdate(false),
+    m_nSelectedRowCount(0),
+    m_aSelectionListeners( *this )
 {
 }
 
@@ -76,9 +85,10 @@ SVTXGridControl::~SVTXGridControl()
 ::com::sun::star::uno::Any SVTXGridControl::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
 {
     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
-                                        SAL_STATIC_CAST( ::com::sun::star::awt::grid::XGridControl*, this ),
-                                        SAL_STATIC_CAST( ::com::sun::star::awt::grid::XGridDataListener*, this ),
-                                        SAL_STATIC_CAST( ::com::sun::star::lang::XTypeProvider*, this ) );
+                                SAL_STATIC_CAST( ::com::sun::star::awt::grid::XGridControl*, this ),
+                                SAL_STATIC_CAST( ::com::sun::star::awt::grid::XGridDataListener*, this ),
+                                SAL_STATIC_CAST( ::com::sun::star::awt::grid::XGridColumnListener*, this ),
+                                SAL_STATIC_CAST( ::com::sun::star::lang::XTypeProvider*, this ) );
     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
 }
 
@@ -90,36 +100,26 @@ IMPL_XTYPEPROVIDER_START( SVTXGridControl )
     VCLXWindow::getTypes()
 IMPL_XTYPEPROVIDER_END
 
-::com::sun::star::uno::Reference< ::com::sun::star::awt::grid::XGridColumnModel > SAL_CALL SVTXGridControl::getColumnModel(  ) throw (::com::sun::star::uno::RuntimeException)
-{
-    return NULL;
-}
-void SAL_CALL SVTXGridControl::setColumnModel( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::grid::XGridColumnModel >& model ) throw (::com::sun::star::uno::RuntimeException)
-{
-    (void)model;
-}
-::com::sun::star::uno::Reference< ::com::sun::star::awt::grid::XGridDataModel > SAL_CALL SVTXGridControl::getDataModel(  ) throw (::com::sun::star::uno::RuntimeException)
-{
-    return NULL;
-}
-void SAL_CALL SVTXGridControl::setDataModel( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::grid::XGridDataModel >& model ) throw (::com::sun::star::uno::RuntimeException)
-{
-    (void)model;
-}
 sal_Int32 SAL_CALL SVTXGridControl::getItemIndexAtPoint(::sal_Int32 x, ::sal_Int32 y) throw (::com::sun::star::uno::RuntimeException)
 {
     TableControl* pTable = (TableControl*)GetWindow();
     return pTable->GetCurrentRow( Point(x,y) );
 }
 
+void SAL_CALL SVTXGridControl::setToolTip(const ::com::sun::star::uno::Sequence< ::rtl::OUString >& text, const com::sun::star::uno::Sequence< sal_Int32 >& columns) throw (::com::sun::star::uno::RuntimeException)
+{
+    TableControl* pTable = (TableControl*)GetWindow();
+    pTable->setTooltip(text, columns);
+}
+
 void SAL_CALL SVTXGridControl::addSelectionListener(const ::com::sun::star::uno::Reference< ::com::sun::star::awt::grid::XGridSelectionListener > & listener) throw (::com::sun::star::uno::RuntimeException)
 {
-    (void)listener;
+    m_aSelectionListeners.addInterface(listener);
 }
 
 void SAL_CALL SVTXGridControl::removeSelectionListener(const ::com::sun::star::uno::Reference< ::com::sun::star::awt::grid::XGridSelectionListener > & listener) throw (::com::sun::star::uno::RuntimeException)
 {
-    (void) listener;
+    m_aSelectionListeners.removeInterface(listener);
 }
 
 void SVTXGridControl::setProperty( const ::rtl::OUString& PropertyName, const Any& aValue) throw(RuntimeException)
@@ -127,7 +127,6 @@ void SVTXGridControl::setProperty( const ::rtl::OUString& PropertyName, const An
     ::vos::OGuard aGuard( GetMutex() );
 
     TableControl* pTable = (TableControl*)GetWindow();
-
     switch( GetPropertyId( PropertyName ) )
     {
         case BASEPROPERTY_GRID_SELECTIONMODE:
@@ -155,6 +154,7 @@ void SVTXGridControl::setProperty( const ::rtl::OUString& PropertyName, const An
             if( aValue >>= bHScroll )
             {
                 m_bHScroll = bHScroll;
+                m_pTableModel->setHorizontalScrollbarVisibility(bHScroll);
             }
             break;
         }
@@ -164,9 +164,11 @@ void SVTXGridControl::setProperty( const ::rtl::OUString& PropertyName, const An
             if( aValue >>= bVScroll )
             {
                 m_bVScroll = bVScroll;
+                m_pTableModel->setVerticalScrollbarVisibility(bVScroll);
             }
             break;
         }
+
         case BASEPROPERTY_GRID_SHOWROWHEADER:
         {
             sal_Bool rowHeader = true;
@@ -176,6 +178,66 @@ void SVTXGridControl::setProperty( const ::rtl::OUString& PropertyName, const An
             }
             break;
         }
+        case BASEPROPERTY_GRID_HEADER_BACKGROUND:
+        {
+            sal_Int32 colorHeader = 0x000000;
+            if( aValue >>= colorHeader )
+            {
+                m_pTableModel->setHeaderBackgroundColor(colorHeader);
+            }
+            break;
+        }
+        case BASEPROPERTY_GRID_LINE_COLOR:
+        {
+            sal_Int32 colorLine = 0x000000;
+            if( aValue >>= colorLine )
+            {
+                m_pTableModel->setLineColor(colorLine);
+            }
+            break;
+        }
+        case BASEPROPERTY_GRID_EVEN_ROW_BACKGROUND:
+        {
+            sal_Int32 colorEvenRow = 0x000000;
+            if( aValue >>= colorEvenRow )
+            {
+                m_pTableModel->setEvenRowBackgroundColor(colorEvenRow);
+            }
+            break;
+        }
+        case BASEPROPERTY_GRID_ROW_BACKGROUND:
+        {
+            sal_Int32 colorBackground = 0x000000;
+            if( aValue >>= colorBackground )
+            {
+                m_pTableModel->setOddRowBackgroundColor(colorBackground);
+            }
+            break;
+        }
+        case BASEPROPERTY_TEXTCOLOR:
+        {
+            sal_Int32 colorText = 0xFFFFFF;
+            if( aValue >>= colorText )
+            {
+                m_pTableModel->setTextColor(colorText);
+            }
+            break;
+        }
+        case BASEPROPERTY_VERTICALALIGN:
+        {
+            com::sun::star::style::VerticalAlignment vAlign(com::sun::star::style::VerticalAlignment(0));
+            if( aValue >>= vAlign )
+            {
+                switch( vAlign )
+                {
+                case com::sun::star::style::VerticalAlignment_TOP:  m_pTableModel->setVerticalAlign(com::sun::star::style::VerticalAlignment(0)); break;
+                case com::sun::star::style::VerticalAlignment_MIDDLE:   m_pTableModel->setVerticalAlign(com::sun::star::style::VerticalAlignment(1)); break;
+                case com::sun::star::style::VerticalAlignment_BOTTOM: m_pTableModel->setVerticalAlign(com::sun::star::style::VerticalAlignment(2)); break;
+                default: m_pTableModel->setVerticalAlign(com::sun::star::style::VerticalAlignment(0)); break;
+                }
+            }
+            break;
+        }
 
         case BASEPROPERTY_GRID_SHOWCOLUMNHEADER:
         {
@@ -188,40 +250,97 @@ void SVTXGridControl::setProperty( const ::rtl::OUString& PropertyName, const An
         }
         case BASEPROPERTY_GRID_DATAMODEL:
         {
-            m_xDataModel = Reference< XGridDataModel >( aValue, UNO_QUERY );
-            Sequence<Sequence< ::rtl::OUString > > cellData = m_xDataModel->getData();
-            Sequence<rtl::OUString> rowData(0);
-            std::vector< std::vector< rtl::OUString > > aCellContent(0);
-            for(int i = 0; i< m_xDataModel->getRowCount();++i)
             {
-                rowData = cellData[i];
-                std::vector<rtl::OUString> newRow(
-                    comphelper::sequenceToContainer< std::vector<rtl::OUString > >(rowData));
-                if(newRow.size() < (unsigned)m_pTableModel->getColumnCount())
-                    newRow.resize( m_pTableModel->getColumnCount(),rtl::OUString::createFromAscii(""));
-                aCellContent.push_back(newRow);
+                m_xDataModel = Reference< XGridDataModel >( aValue, UNO_QUERY );
+                if(m_xDataModel != NULL)
+                {
+                    Sequence<Sequence< Any > > cellData = m_xDataModel->getData();
+                    if(cellData.getLength()!= 0)
+                    {
+                        for (int i = 0; i < cellData.getLength(); i++)
+                        {
+                            std::vector< Any > newRow;
+                            Sequence< Any > rawRowData = cellData[i];
+                            //check whether the data row vector length matches with the column count
+                            if(m_xColumnModel->getColumnCount() == 0)
+                            {
+                                for ( ::svt::table::ColPos col = 0; col < rawRowData.getLength(); ++col )
+                                {
+                                    UnoControlTableColumn* tableColumn = new UnoControlTableColumn();
+                                    m_pTableModel->getColumnModel().push_back((PColumnModel)tableColumn);
+                                }
+                                m_xColumnModel->setDefaultColumns(rawRowData.getLength());
+                            }
+                            else
+                                if((unsigned int)rawRowData.getLength()!=(unsigned)m_pTableModel->getColumnCount())
+                                    throw GridInvalidDataException(rtl::OUString::createFromAscii("The column count doesn't match with the length of row data"), m_xDataModel);
+
+                            for ( int k = 0; k < rawRowData.getLength(); k++)
+                            {
+                                newRow.push_back(rawRowData[k]);
+                            }
+                            m_pTableModel->getCellContent().push_back(newRow);
+                        }
+
+                        Sequence< ::rtl::OUString > rowHeaders = m_xDataModel->getRowHeaders();
+                        std::vector< rtl::OUString > newRow(
+                            comphelper::sequenceToContainer< std::vector<rtl::OUString > >(rowHeaders));
+                        m_pTableModel->setRowCount(m_xDataModel->getRowCount());
+                        m_pTableModel->setRowHeaderName(newRow);
+                    }
+                }
+                else
+                    throw GridInvalidDataException(rtl::OUString::createFromAscii("The data model isn't set!"), m_xDataModel);
+                sal_Int32 fontHeight = pTable->PixelToLogic( Size( 0, pTable->GetTextHeight()+3 ), MAP_APPFONT ).Height();
+                if(m_xDataModel->getRowHeight() == 0)
+                {
+                    m_pTableModel->setRowHeight(fontHeight);
+                    m_xDataModel->setRowHeight(fontHeight);
+                }
+                else
+                    m_pTableModel->setRowHeight(m_xDataModel->getRowHeight());
+                m_pTableModel->setRowHeaderWidth(m_xDataModel->getRowHeaderWidth());
             }
-            m_pTableModel->setCellContent(aCellContent);
-            Sequence< ::rtl::OUString > rowHeaders = m_xDataModel->getRowHeaders();
-            std::vector< rtl::OUString > newRow(
-                comphelper::sequenceToContainer< std::vector<rtl::OUString > >(rowHeaders));
-            m_pTableModel->setRowCount(m_xDataModel->getRowCount());
-            m_pTableModel->setRowHeaderName(newRow);
             break;
         }
         case BASEPROPERTY_GRID_COLUMNMODEL:
         {
             m_xColumnModel = Reference< XGridColumnModel >( aValue, UNO_QUERY );
-            Sequence<Reference< XGridColumn > > columns = m_xColumnModel->getColumns();
-            std::vector<Reference< XGridColumn > > aNewColumns(
-                comphelper::sequenceToContainer<std::vector<Reference< XGridColumn > > >(columns));
-        /*  if(m_pTable->GetColumnCount().size()>0)
-                m_pTable->GetColumnName.clear();*/
-            for ( ::svt::table::ColPos col = 0; col < m_xColumnModel->getColumnCount(); ++col )
+            if(m_xColumnModel != NULL)
             {
-                UnoControlTableColumn* tableColumn = new UnoControlTableColumn(aNewColumns[col]);
-                m_pTableModel->getColumnModel().push_back((PColumnModel)tableColumn);
+                if(m_xColumnModel->getColumnCount() != 0)
+                {
+                    Sequence<Reference< XGridColumn > > columns = m_xColumnModel->getColumns();
+                    std::vector<Reference< XGridColumn > > aNewColumns(
+                        comphelper::sequenceToContainer<std::vector<Reference< XGridColumn > > >(columns));
+                    sal_Int32 fontHeight = pTable->PixelToLogic( Size( 0, pTable->GetTextHeight()+3 ), MAP_APPFONT ).Height();
+                    if(m_xColumnModel->getColumnHeaderHeight() == 0)
+                    {
+                        m_pTableModel->setColumnHeaderHeight(fontHeight);
+                        m_xColumnModel->setColumnHeaderHeight(fontHeight);
+                    }
+                    else
+                        m_pTableModel->setColumnHeaderHeight(m_xColumnModel->getColumnHeaderHeight());
+                    for ( ::svt::table::ColPos col = 0; col < m_xColumnModel->getColumnCount(); ++col )
+                    {
+                        UnoControlTableColumn* tableColumn = new UnoControlTableColumn(aNewColumns[col]);
+                        Reference< XGridColumn > xGridColumn = m_xColumnModel->getColumn(col);
+                        m_pTableModel->getColumnModel().push_back((PColumnModel)tableColumn);
+                        tableColumn->setHorizontalAlign(xGridColumn->getHorizontalAlign());
+                        tableColumn->setWidth(xGridColumn->getColumnWidth());
+                        if(xGridColumn->getPreferredWidth() != 0)
+                            tableColumn->setPreferredWidth(xGridColumn->getPreferredWidth());
+                        if(xGridColumn->getMaxWidth() != 0)
+                            tableColumn->setMaxWidth(xGridColumn->getMaxWidth());
+                        if(xGridColumn->getMinWidth() != 0)
+                            tableColumn->setMinWidth(xGridColumn->getMinWidth());
+                        tableColumn->setResizable(xGridColumn->getResizeable());
+                    }
+                }
             }
+            else
+                throw GridInvalidModelException(rtl::OUString::createFromAscii("The column model isn't set!"), m_xColumnModel);
+
             break;
         }
         default:
@@ -281,7 +400,11 @@ void SVTXGridControl::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
                      BASEPROPERTY_GRID_SHOWCOLUMNHEADER,
                      BASEPROPERTY_GRID_DATAMODEL,
                      BASEPROPERTY_GRID_COLUMNMODEL,
-                     BASEPROPERTY_GRID_SELECTIONMODE,
+             BASEPROPERTY_GRID_SELECTIONMODE,
+             BASEPROPERTY_GRID_EVEN_ROW_BACKGROUND,
+             BASEPROPERTY_GRID_HEADER_BACKGROUND,
+             BASEPROPERTY_GRID_LINE_COLOR,
+             BASEPROPERTY_GRID_ROW_BACKGROUND,
                      0);
     VCLXWindow::ImplGetPropertyIds( rIds, true );
 }
@@ -291,7 +414,6 @@ void SAL_CALL SVTXGridControl::setVisible( sal_Bool bVisible ) throw(::com::sun:
     if ( pTable )
     {
         pTable->SetModel(PTableModel(m_pTableModel));
-        //m_pTable->SetPosSizePixel( Point( nPosX, nPosY ), Size(nWidth, nHeight) );
         pTable->Show( bVisible );
     }
 }
@@ -303,17 +425,32 @@ void SAL_CALL SVTXGridControl::setFocus() throw(::com::sun::star::uno::RuntimeEx
 }
 void SAL_CALL SVTXGridControl::rowAdded(const ::com::sun::star::awt::grid::GridDataEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
 {
-    std::vector<OUString> aNewRow(
-        comphelper::sequenceToContainer< std::vector<rtl::OUString > >(Event.rowData));
-    if(aNewRow.size()< (unsigned)m_pTableModel->getColumnCount())
-        aNewRow.resize(m_pTableModel->getColumnCount(),rtl::OUString::createFromAscii(""));
-    m_pTableModel->getCellContent().push_back(aNewRow);
+    std::vector< Any > newRow;
+    Sequence< Any > rawRowData = Event.rowData;
+    int colCount = m_xColumnModel->getColumnCount();
+    if(colCount == 0)
+    {
+        Reference<XGridColumnListener> listener(*this,UNO_QUERY_THROW);
+        m_xColumnModel->setDefaultColumns(rawRowData.getLength());
+        for ( ::svt::table::ColPos col = 0; col < rawRowData.getLength(); ++col )
+        {
+            UnoControlTableColumn* tableColumn = new UnoControlTableColumn();
+            m_pTableModel->getColumnModel().push_back((PColumnModel)tableColumn);
+            m_xColumnModel->getColumn(col)->addColumnListener(listener);
+        }
+
+    }
+    else if((unsigned int)rawRowData.getLength()!=(unsigned)colCount)
+        throw GridInvalidDataException(rtl::OUString::createFromAscii("The column count doesn't match with the length of row data"), m_xDataModel);
+
+    for ( int k = 0; k < rawRowData.getLength(); k++)
+        newRow.push_back(rawRowData[k]);
+    m_pTableModel->getCellContent().push_back(newRow);
     if(m_pTableModel->hasRowHeaders())
         m_pTableModel->getRowHeaderName().push_back(Event.headerName);
-    m_pTableModel->setRowCount(m_pTableModel->getRowHeaderName().size());
+    m_pTableModel->setRowCount(m_pTableModel->getCellContent().size());
     TableControl* pTable = (TableControl*)GetWindow();
-    pTable->InvalidateDataWindow(m_pTableModel->getRowHeaderName().size()-1, false);
-    //pTable->GrabFocus();
+    pTable->InvalidateDataWindow(m_pTableModel->getCellContent().size()-1, 0, false);
     if(pTable->isAccessibleAlive())
     {
         pTable->commitGridControlEvent(TABLE_MODEL_CHANGED,
@@ -335,9 +472,10 @@ void SAL_CALL SVTXGridControl::rowAdded(const ::com::sun::star::awt::grid::GridD
 void SAL_CALL SVTXGridControl::rowRemoved(const ::com::sun::star::awt::grid::GridDataEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
 {
     TableControl* pTable = (TableControl*)GetWindow();
-    //unsigned int rows =m_pImpl->aCellContent.size()-1;
     if(Event.index == -1)
     {
+        if(!isSelectionEmpty())
+            deselectAllRows();
         if(m_pTableModel->hasRowHeaders())
             m_pTableModel->getRowHeaderName().clear();
         m_pTableModel->getCellContent().clear();
@@ -348,76 +486,242 @@ void SAL_CALL SVTXGridControl::rowRemoved(const ::com::sun::star::awt::grid::Gri
                 Any());
         }
     }
-    else
+    else if(Event.index >= 0 && Event.index < m_pTableModel->getRowCount())
     {
-        pTable->removeSelectedRow(Event.index);
-        if(m_pTableModel->getCellContent().size()>1)
+        if(isSelectedIndex(Event.index))
         {
-            if(m_pTableModel->hasRowHeaders())
-                m_pTableModel->getRowHeaderName().erase(m_pTableModel->getRowHeaderName().begin()+Event.index);
-            m_pTableModel->getCellContent().erase(m_pTableModel->getCellContent().begin()+Event.index);
-
-        }
-        else
-        {
-            if(m_pTableModel->hasRowHeaders())
-                m_pTableModel->getRowHeaderName().clear();
-            m_pTableModel->getCellContent().clear();
-            //m_pImpl->nRowCount=0;
+            Sequence<sal_Int32> selected(1);
+            selected[0]=Event.index;
+            deselectRows(selected);
         }
+        if(m_pTableModel->hasRowHeaders())
+            m_pTableModel->getRowHeaderName().erase(m_pTableModel->getRowHeaderName().begin()+Event.index);
+        std::vector<std::vector<Any> >::iterator rowPos =m_pTableModel->getCellContent().begin() + Event.index;
+        m_pTableModel->getCellContent().erase( rowPos );
     }
-    //pTable->InvalidateDataWindow(Event.index, true);
     m_pTableModel->setRowCount(m_pTableModel->getCellContent().size());
-    pTable->InvalidateDataWindow(Event.index, true);
+    pTable->InvalidateDataWindow(Event.index, Event.index, true);
     if(pTable->isAccessibleAlive())
     {
         pTable->commitGridControlEvent(TABLE_MODEL_CHANGED,
              makeAny( AccessibleTableModelChange(DELETE, Event.index, Event.index+1, 0, m_pTableModel->getColumnCount())),
             Any());
-        //pTable->commitGridControlEvent(CHILD,
-     //     makeAny( pTable->m_pAccessTable->m_pAccessible->getTableHeader(TCTYPE_ROWHEADERBAR)),
-        //  Any());
-        //for (sal_Int32 i = 0 ; i <= m_pTableModel->getColumnCount() ; ++i)
-        //{
-        //  pTable->commitGridControlEvent(
-  //              CHILD,
-        //      makeAny( pTable->m_pAccessTable->m_pAccessible->getTable() ),
-        //      Any());
-        //}
     }
-    //pTable->Invalidate();
 }
 
+void SAL_CALL  SVTXGridControl::columnChanged(const ::com::sun::star::awt::grid::GridColumnEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
+{
+    TableControl* pTable = (TableControl*)GetWindow();
+    if(Event.valueName == rtl::OUString::createFromAscii("ColumnResize"))
+    {
+        bool resizable = m_pTableModel->getColumnModel()[Event.index]->isResizable();
+        Event.newValue>>=resizable;
+        m_pTableModel->getColumnModel()[Event.index]->setResizable(resizable);
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("ColWidth"))
+    {
+        sal_Int32 colWidth = m_pTableModel->getColumnModel()[Event.index]->getWidth();
+        Event.newValue>>=colWidth;
+        m_pTableModel->getColumnModel()[Event.index]->setWidth(colWidth);
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("MaxWidth"))
+    {
+        sal_Int32 maxWidth = m_pTableModel->getColumnModel()[Event.index]->getMaxWidth();
+        Event.newValue>>=maxWidth;
+        m_pTableModel->getColumnModel()[Event.index]->setMaxWidth(maxWidth);
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("MinWidth"))
+    {
+        sal_Int32 minWidth = m_pTableModel->getColumnModel()[Event.index]->getMinWidth();
+        Event.newValue>>=minWidth;
+        m_pTableModel->getColumnModel()[Event.index]->setMinWidth(minWidth);
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("PrefWidth"))
+    {
+        sal_Int32 prefWidth = m_pTableModel->getColumnModel()[Event.index]->getPreferredWidth();
+        Event.newValue>>=prefWidth;
+        m_pTableModel->getColumnModel()[Event.index]->setPreferredWidth(prefWidth);
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("HAlign"))
+    {
+        ::com::sun::star::style::HorizontalAlignment hAlign = m_pTableModel->getColumnModel()[Event.index]->getHorizontalAlign();
+        Event.newValue>>=hAlign;
+        m_pTableModel->getColumnModel()[Event.index]->setHorizontalAlign(hAlign);
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("UpdateWidth"))
+    {
+        if(m_pTableModel->getColumnModel()[Event.index]->getPreferredWidth() != 0)
+            m_xColumnModel->getColumn(Event.index)->updateColumn(rtl::OUString::createFromAscii("PrefWidth"), m_pTableModel->getColumnModel()[Event.index]->getPreferredWidth());
+        m_xColumnModel->getColumn(Event.index)->updateColumn(rtl::OUString::createFromAscii("ColWidth"), m_pTableModel->getColumnModel()[Event.index]->getWidth());
+    }
+    pTable->Invalidate();
+}
 void SAL_CALL  SVTXGridControl::dataChanged(const ::com::sun::star::awt::grid::GridDataEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
 {
-    (void) Event;
+    TableControl* pTable = (TableControl*)GetWindow();
+    if(Event.valueName == rtl::OUString::createFromAscii("RowHeight"))
+    {
+        sal_Int32 rowHeight = m_pTableModel->getRowHeight();
+        Event.newValue>>=rowHeight;
+        m_pTableModel->setRowHeight(rowHeight);
+        pTable->Invalidate();
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("RowHeaderWidth"))
+    {
+        sal_Int32 rowHeaderWidth = m_pTableModel->getRowHeaderWidth();
+        Event.newValue>>=rowHeaderWidth;
+        m_pTableModel->setRowHeaderWidth(rowHeaderWidth);
+        pTable->Invalidate();
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("RowHeaders"))
+    {
+        Sequence< rtl::OUString > headers(0);
+        Event.newValue>>=headers;
+        std::vector< rtl::OUString > headerNames( comphelper::sequenceToContainer <std::vector< rtl::OUString > >(headers) );
+        m_pTableModel->setRowHeaderName(headerNames);
+        pTable->Invalidate();
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("CellUpdated"))
+    {
+        std::vector< std::vector< Any > >& rowContent = m_pTableModel->getCellContent();
+        sal_Int32 col = -1;
+        Event.oldValue>>=col;
+        rowContent[Event.index][col] = Event.newValue;
+        pTable->InvalidateDataWindow(Event.index, Event.index, false);
+    }
+    else if(Event.valueName == rtl::OUString::createFromAscii("RowUpdated"))
+    {
+        std::vector<std::vector< Any > >& rowContent = m_pTableModel->getCellContent();
+        Sequence< sal_Int32 > cols(0);
+        Sequence< Any > values(0);
+        Event.oldValue>>=cols;
+        Event.newValue>>=values;
+        for(int i = 0; i< cols.getLength(); i++)
+        {
+            if(cols[i]>=0 && cols[i]<m_pTableModel->getColumnCount())
+                rowContent[Event.index][cols[i]]=values[i];
+            else
+                break;
+        }
+        pTable->InvalidateDataWindow(Event.index, Event.index, false);
+    }
 }
 
- void SAL_CALL SVTXGridControl::disposing( const ::com::sun::star::lang::EventObject& Source ) throw(::com::sun::star::uno::RuntimeException)
- {
+void SAL_CALL SVTXGridControl::disposing( const ::com::sun::star::lang::EventObject& Source ) throw(::com::sun::star::uno::RuntimeException)
+{
     VCLXWindow::disposing( Source );
- }
+}
 
 ::sal_Int32 SAL_CALL SVTXGridControl::getMinSelectionIndex() throw (::com::sun::star::uno::RuntimeException)
 {
-    return 0;
+    TableControl* pTable = (TableControl*)GetWindow();
+    std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+    if(selectedRows.empty())
+        return -1;
+    else
+    {
+        std::vector<RowPos>::iterator itStart = selectedRows.begin();
+        std::vector<RowPos>::iterator itEnd = selectedRows.end();
+        return *(std::min_element(itStart, itEnd));
+    }
 }
 
 ::sal_Int32 SAL_CALL SVTXGridControl::getMaxSelectionIndex() throw (::com::sun::star::uno::RuntimeException)
 {
-    return 0;
+    TableControl* pTable = (TableControl*)GetWindow();
+    std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+    if(selectedRows.empty())
+        return -1;
+    else
+    {
+        std::vector<RowPos>::iterator itStart = selectedRows.begin();
+        std::vector<RowPos>::iterator itEnd = selectedRows.end();
+        return *(std::max_element(itStart, itEnd));
+    }
+}
+
+void SAL_CALL SVTXGridControl::selectRows(const ::com::sun::star::uno::Sequence< ::sal_Int32 >& rangeOfRows) throw (::com::sun::star::uno::RuntimeException)
+{
+    TableControl* pTable = (TableControl*)GetWindow();
+    SelectionMode eSelMode = pTable->getSelEngine()->GetSelectionMode();
+    if(eSelMode != NO_SELECTION)
+    {
+        sal_Int32 start = rangeOfRows[0];
+        int seqSize = rangeOfRows.getLength();
+        sal_Int32 end = rangeOfRows[seqSize-1];
+        if((start >= 0 && start < m_pTableModel->getRowCount()) && (end >= 0 && end < m_pTableModel->getRowCount()))
+        {
+            std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+            if(!selectedRows.empty())
+                selectedRows.clear();
+            if(eSelMode == SINGLE_SELECTION)
+            {
+                if(rangeOfRows.getLength() == 1)
+                    selectedRows.push_back(start);
+                else
+                    return;
+            }
+            else
+            {
+                for(int i=0;i<seqSize;i++)
+                    selectedRows.push_back(rangeOfRows[i]);
+            }
+            pTable->selectionChanged(true);
+            pTable->InvalidateDataWindow(start, end, false);
+            SetSynthesizingVCLEvent( sal_True );
+            pTable->Select();
+            SetSynthesizingVCLEvent( sal_False );
+        }
+    }
 }
 
-void SAL_CALL SVTXGridControl::insertIndexIntervall(::sal_Int32 start, ::sal_Int32 length) throw (::com::sun::star::uno::RuntimeException)
+void SAL_CALL SVTXGridControl::selectAllRows() throw (::com::sun::star::uno::RuntimeException)
 {
-    (void)length;
-    (void)start;
+    TableControl* pTable = (TableControl*)GetWindow();
+    SelectionMode eSelMode = pTable->getSelEngine()->GetSelectionMode();
+    if(eSelMode != NO_SELECTION)
+    {
+        std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+        if(!selectedRows.empty())
+            selectedRows.clear();
+        for(int i=0;i<m_pTableModel->getRowCount();i++)
+            selectedRows.push_back(i);
+        pTable->Invalidate();
+        SetSynthesizingVCLEvent( sal_True );
+        pTable->Select();
+        SetSynthesizingVCLEvent( sal_False );
+    }
+}
+void SAL_CALL SVTXGridControl::deselectRows(const ::com::sun::star::uno::Sequence< ::sal_Int32 >& rangeOfRows) throw (::com::sun::star::uno::RuntimeException)
+{
+    TableControl* pTable = (TableControl*)GetWindow();
+    std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+    std::vector<RowPos>::iterator itStart = selectedRows.begin();
+    std::vector<RowPos>::iterator itEnd = selectedRows.end();
+    sal_Int32 start = rangeOfRows[0];
+    sal_Int32 end = rangeOfRows[rangeOfRows.getLength()-1];
+    if((start >= 0 && start < m_pTableModel->getRowCount()) && (end >= 0 && end < m_pTableModel->getRowCount()))
+    {
+        std::vector<RowPos>::iterator iter = std::find(itStart, itEnd, start);
+        selectedRows.erase(iter, iter+(end-start)+1);
+        pTable->selectionChanged(true);
+        pTable->InvalidateDataWindow(start, end, false);
+        SetSynthesizingVCLEvent( sal_True );
+        pTable->Select();
+        SetSynthesizingVCLEvent( sal_False );
+    }
 }
 
-void SAL_CALL SVTXGridControl::removeIndexIntervall(::sal_Int32 start, ::sal_Int32 end) throw (::com::sun::star::uno::RuntimeException)
+void SAL_CALL SVTXGridControl::deselectAllRows() throw (::com::sun::star::uno::RuntimeException)
 {
-    (void)end;
-    (void)start;
+    TableControl* pTable = (TableControl*)GetWindow();
+    std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+    if(!selectedRows.empty())
+        selectedRows.clear();
+    pTable->Invalidate();
+    SetSynthesizingVCLEvent( sal_True );
+    pTable->Select();
+    SetSynthesizingVCLEvent( sal_False );
 }
 
 ::com::sun::star::uno::Sequence< ::sal_Int32 > SAL_CALL SVTXGridControl::getSelection() throw (::com::sun::star::uno::RuntimeException)
@@ -435,21 +739,138 @@ void SAL_CALL SVTXGridControl::removeIndexIntervall(::sal_Int32 start, ::sal_Int
 
 ::sal_Bool SAL_CALL SVTXGridControl::isSelectionEmpty() throw (::com::sun::star::uno::RuntimeException)
 {
-    return sal_False;
+    TableControl* pTable = (TableControl*)GetWindow();
+    std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+    if(selectedRows.empty())
+        return sal_True;
+    else
+        return sal_False;
 }
 
 ::sal_Bool SAL_CALL SVTXGridControl::isSelectedIndex(::sal_Int32 index) throw (::com::sun::star::uno::RuntimeException)
 {
-    (void)index;
-    return sal_False;
+    TableControl* pTable = (TableControl*)GetWindow();
+    std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+    return std::find(selectedRows.begin(),selectedRows.end(), index) != selectedRows.end();
 }
 
-void SAL_CALL SVTXGridControl::selectRow(::sal_Int32 y) throw (::com::sun::star::uno::RuntimeException)
+void SAL_CALL SVTXGridControl::selectRow(::sal_Int32 index) throw (::com::sun::star::uno::RuntimeException)
 {
-    (void)y;
+    if(index<0 || index>=m_pTableModel->getRowCount())
+        return;
+    TableControl* pTable = (TableControl*)GetWindow();
+    SelectionMode eSelMode = pTable->getSelEngine()->GetSelectionMode();
+    if(eSelMode != NO_SELECTION)
+    {
+        std::vector<RowPos>& selectedRows = pTable->GetSelectedRows();
+        if(eSelMode == MULTIPLE_SELECTION)
+        {
+            if(!isSelectedIndex(index))
+                selectedRows.push_back(index);
+            else
+                return;
+        }
+        else if(eSelMode == SINGLE_SELECTION)
+        {
+            if(!selectedRows.empty())
+            {
+                if(!isSelectedIndex(index))
+                    deselectRows(getSelection());
+                else
+                    return;
+            }
+            selectedRows.push_back(index);
+        }
+        pTable->selectionChanged(true);
+        pTable->InvalidateDataWindow(index, index, false);
+        SetSynthesizingVCLEvent( sal_True );
+        pTable->Select();
+        SetSynthesizingVCLEvent( sal_False );
+    }
 }
 
 void SAL_CALL SVTXGridControl::selectColumn(::sal_Int32 x) throw (::com::sun::star::uno::RuntimeException)
 {
     (void)x;
 }
+void SVTXGridControl::dispose() throw(::com::sun::star::uno::RuntimeException)
+{
+    ::vos::OGuard aGuard( GetMutex() );
+
+    ::com::sun::star::lang::EventObject aObj;
+    aObj.Source = (::cppu::OWeakObject*)this;
+    m_aSelectionListeners.disposeAndClear( aObj );
+    VCLXWindow::dispose();
+}
+
+void SVTXGridControl::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
+{
+    ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
+
+    switch ( rVclWindowEvent.GetId() )
+    {
+        case VCLEVENT_TABLEROW_SELECT:
+        {
+            TableControl* pTable = (TableControl*)GetWindow();
+
+            if( pTable )
+            {
+                if ( m_aSelectionListeners.getLength() )
+                {
+                    ImplCallItemListeners();
+                }
+            }
+        }
+        break;
+
+        default:
+            VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
+            break;
+    }
+}
+
+void SVTXGridControl::ImplCallItemListeners()
+{
+    TableControl* pTable = (TableControl*) GetWindow();
+    if ( pTable && m_aSelectionListeners.getLength() )
+    {
+        ::std::vector<sal_Int32> selRows = pTable->GetSelectedRows();
+        ::com::sun::star::awt::grid::GridSelectionEvent aEvent;
+        aEvent.Source = (::cppu::OWeakObject*)this;
+        aEvent.Column = 0;
+        sal_Int32 actSelRowCount = selRows.size();
+        sal_Int32 diff = actSelRowCount - m_nSelectedRowCount;
+        //row added to selection
+        if(diff >= 1)
+        {
+            aEvent.Action = com::sun::star::awt::grid::SelectionEventType(0);
+            aEvent.Row = selRows[actSelRowCount-1];
+            aEvent.Range = diff;
+        }
+        //selected row changed
+        else if(diff == 0)
+        {
+            aEvent.Row = selRows[actSelRowCount-1];
+            aEvent.Action = com::sun::star::awt::grid::SelectionEventType(2);
+            aEvent.Range = 0;
+        }
+        else
+        {
+            //selection changed: multiple row deselected, only 1 row is selected
+            if(actSelRowCount == 1)
+            {
+                aEvent.Row = selRows[actSelRowCount-1];
+                aEvent.Action = com::sun::star::awt::grid::SelectionEventType(2);
+            }
+            //row is deselected
+            else
+            {
+                aEvent.Row = pTable->GetCurrentRow();
+                aEvent.Action = com::sun::star::awt::grid::SelectionEventType(1);
+            }
+            aEvent.Range = 0;
+        }
+        m_nSelectedRowCount=actSelRowCount;
+        m_aSelectionListeners.selectionChanged( aEvent );
+    }
+}